@sabstravtech/obtservices 0.0.0 → 0.0.1

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

@@ -0,0 +1,103 @@
+import { BehaviorSubject } from 'rxjs';
+import moment from 'moment';
+import { BaseEnterpriseSearch } from './base-enterprise';
+import { BaseStorageService } from '../services/storage.service';
+import { BaseHelperRoutines } from './helpers';
+import { NgbDateStruct, OBTAirportDetails, ParkingQuoteResultArray, TerminalsType, ParkingFiltersInterface, RecentSearch } from '../types/types';
+import { BasketItem, ParkingQuote, SaveRecentSearchMutationVariables, SearchParkingQueryVariables, ServiceType } from '../types/graphql.types';
+import { BaseParkingQuoteFetcher, ParkingQuoteFetcherType } from '../fetchers/parking-quote-fetcher';
+import { EnterpriseBasketServiceInterface } from '../interfaces/Ienterprise-basket.service';
+import { EnterpriseSearchServiceInterface } from '../interfaces/Isearch.service';
+import { ParkingEnterpriseSearchInterface, ParkingTempParams } from '../interfaces/Iparking-enterprise-search';
+import { ICheapestPrice } from '../interfaces/cheapest-price';
+export declare const defaultValidations: {
+    AirportFirst: string;
+    InvardJourney: string;
+    OutwardJourney: string;
+    DateOverlapped: string;
+};
+export declare class ParkingEnterpriseSearch<Q extends ParkingQuoteFetcherType> extends BaseEnterpriseSearch<ParkingTempParams, ParkingQuoteResultArray, ParkingQuoteResultArray> implements ParkingEnterpriseSearchInterface {
+    private parkingfetcher;
+    private helpers;
+    private basketService;
+    private searchService;
+    static readonly STORAGE_SESSION_PARAMS = "search_parking";
+    static readonly STORAGE_SESSION_RESULTS = "results_parking";
+    type: ServiceType;
+    terminals: BehaviorSubject<TerminalsType[]>;
+    listViewToggle: BehaviorSubject<ParkingQuote>;
+    parkingFiltersText: ParkingFiltersInterface;
+    private _locationCode;
+    get outdate(): NgbDateStruct;
+    set outdate(value: NgbDateStruct);
+    get outtime(): string;
+    set outtime(value: string);
+    /**
+     * The date you need the parking till
+     */
+    get departDatetime(): moment.Moment;
+    /**
+     * The date you need the parking till
+     */
+    set departDatetime(value: moment.Moment);
+    get indate(): NgbDateStruct;
+    set indate(value: NgbDateStruct);
+    get intime(): string;
+    set intime(value: string);
+    /**
+     * The date you need the parking from
+     */
+    get arrivalDatetime(): moment.Moment;
+    /**
+     * The date you need the parking from
+     */
+    set arrivalDatetime(value: moment.Moment);
+    get outFlightNumber(): string;
+    set outFlightNumber(value: string);
+    get recommended(): boolean | null;
+    set recommended(value: boolean);
+    get onAirport(): boolean;
+    set onAirport(value: boolean);
+    get meetAndGreet(): boolean;
+    set meetAndGreet(value: boolean);
+    get parkAndRide(): boolean;
+    set parkAndRide(value: boolean);
+    get parkAndStroll(): boolean;
+    set parkAndStroll(value: boolean);
+    get carParkedForYou(): boolean;
+    set carParkedForYou(value: boolean);
+    get terminal(): string;
+    set terminal(input: string);
+    get locationCode(): string | OBTAirportDetails;
+    set locationCode(value: string | OBTAirportDetails);
+    private _selectedTerminal;
+    set selectedTerminal(value: string);
+    get selectedTerminal(): string;
+    min_date: {
+        year: number;
+        month: number;
+        day: number;
+    };
+    min_return_date: {
+        year: number;
+        month: number;
+        day: number;
+    };
+    private travellers;
+    constructor(parkingfetcher: BaseParkingQuoteFetcher<Q>, helpers: BaseHelperRoutines, basketService: EnterpriseBasketServiceInterface, storageService: BaseStorageService, searchService: EnterpriseSearchServiceInterface);
+    protected resultsSessionName: string;
+    private _outdate;
+    private _outtime;
+    private _indate;
+    private _intime;
+    protected resetQuery(): void;
+    private _isValid;
+    startSearch(): Promise<boolean>;
+    getRecentSearchQuery(query: SearchParkingQueryVariables): SaveRecentSearchMutationVariables;
+    startRecentSearch(recentSearch: RecentSearch): void;
+    getSearchQuery(): SearchParkingQueryVariables;
+    sortByPrice(asc?: boolean): void;
+    updateFromPreviousSearches(previousItems: Record<ServiceType, BasketItem>): void;
+    addParkingToBasket(parkingQuote: ParkingQuote, parkingQuery: SearchParkingQueryVariables): Promise<boolean>;
+    updateLowestPrice(results: ParkingQuote[]): ICheapestPrice;
+}

package/dist/obtservices/base/lib/vendor/classes/rail-direction.enum.d.ts

@@ -0,0 +1,4 @@
+export declare enum RailDirection {
+    Outbound = "out",
+    Inbound = "in"
+}

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

@@ -0,0 +1,193 @@
+import moment from 'moment';
+import { Observable, BehaviorSubject } from 'rxjs';
+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, TicketGroups } from '../interfaces/rail-ticket-group.interface';
+import { ValueDisplay } from '../interfaces/value-display';
+import { NgbDateStruct, RailQuoteResultArray, RecentSearch, RecursivePartial } from '../types/types';
+import { BasketItem, RailClass, RailJourneyOption, RailJourneyOptions, RailJourneyType, RailSegment, RailStation, RailTicketOption, ReferenceRailCardQualifier, SaveRecentSearchMutationVariables, SearchRailQueryVariables, ServiceType, RailTicketExtra } from '../types/graphql.types';
+import { BaseRailQuoteFetcher, RailQuoteFetcherType } from '../fetchers/rail-quote-fetcher';
+import { BaseGetRailStationFetcher, GetRailStationFetcherType } from '../fetchers/get-rail-station.fetcher';
+import { EnterpriseBasketServiceInterface } from '../interfaces/Ienterprise-basket.service';
+import { EnterpriseSearchServiceInterface } from '../interfaces/Isearch.service';
+import { RailEnterpriseSearchInterface, RailTempParams } from '../interfaces/Irail-enterprise-search';
+import { ICheapestPrice } from '../interfaces/cheapest-price';
+import { IRailAirportExpressStations } from '../interfaces/rail-airport-express-stations.interface';
+import { TicketExtras } from '../interfaces/rail-basket-item.interface';
+export declare enum RailSearchCriteria {
+    Depart = "Depart After",
+    Arrive = "Arrive Before"
+}
+export declare enum RailTicketOptionType {
+    Return = "Return",
+    Single = "Single"
+}
+export declare class RailEnterpriseSearch<Q extends RailQuoteFetcherType, GRS_Q extends GetRailStationFetcherType> extends BaseEnterpriseSearch<RailTempParams, RailQuoteResultArray, RailQuoteResultArray> implements RailEnterpriseSearchInterface {
+    private Railfetcher;
+    private getRailStationFetcher;
+    private helpers;
+    private basketService;
+    private searchService;
+    static readonly STORAGE_SESSION_PARAMS = "search_rail";
+    static readonly STORAGE_SESSION_RESULTS = "rail_results";
+    static readonly PASSING_POINT = "Passing";
+    private travellers;
+    protected resultsSessionName: string;
+    searchTypes: {
+        display: string;
+        value: RailJourneyType;
+    }[];
+    classTypes: {
+        display: string;
+        value: RailClass;
+    }[];
+    airportExpressStations: IRailAirportExpressStations[];
+    airportExpressStationsCodes: {
+        [key: string]: {
+            dep: string;
+            arr: string;
+        };
+    };
+    railCriteria: RailSearchCriteria[];
+    travelCards: {
+        display: string;
+        value: string;
+    }[];
+    removePassingPointsFromResults: boolean;
+    type: ServiceType;
+    minOutboundDate: NgbDateStruct;
+    minInboundDate: NgbDateStruct;
+    maxDate: NgbDateStruct;
+    private _timeArray;
+    private _canCombine;
+    private _chosenOutboundTicket;
+    private _chosenInboundTicket;
+    private _chosenOutboundJourney;
+    private _chosenInboundJourney;
+    private _chosenTicketGroup;
+    private _viaLocation;
+    private _travellingFrom;
+    private _travellingTo;
+    protected _originalUserSearch: RailTempParams;
+    get chosenTicketGroup(): RailTicketGroup;
+    get chosenTotalPrice(): number;
+    get chosenTickets(): any;
+    get chosenOutboundJourney(): RecursivePartial<RailJourneyOption>;
+    get chosenInboundJourney(): RecursivePartial<RailJourneyOption>;
+    get openReturn(): boolean;
+    set openReturn(newVal: boolean);
+    get chosenSearchType(): RailJourneyType;
+    set chosenSearchType(newType: RailJourneyType);
+    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);
+    get chosenRailClass(): RailClass;
+    set chosenRailClass(newClass: RailClass);
+    get chosenSearchClass(): RailClass;
+    set chosenSearchClass(classR: RailClass);
+    get extraTime(): boolean;
+    set extraTime(extra: boolean);
+    get via(): boolean;
+    set via(via: boolean);
+    get viaLocation(): any;
+    set viaLocation(viaLocation: any);
+    get outBoundDateTime(): moment.Moment;
+    set outBoundDateTime(newDateTime: moment.Moment);
+    get outboundCriteria(): RailSearchCriteria;
+    set outboundCriteria(newCrit: RailSearchCriteria);
+    get inBoundDateTime(): moment.Moment;
+    set inBoundDateTime(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 returnCriteria(): RailSearchCriteria;
+    set returnCriteria(newCrit: RailSearchCriteria);
+    get carnetTicket(): boolean;
+    set carnetTicket(newCarnet: boolean);
+    get disableAutoDiscounts(): boolean;
+    set disableAutoDiscounts(newDis: boolean);
+    get prioritiseByPrice(): boolean;
+    set prioritiseByPrice(newPriority: boolean);
+    get applyRailcards(): boolean;
+    set applyRailcards(apCards: boolean);
+    get railCards(): ReferenceRailCardQualifier[];
+    set railCards(value: ReferenceRailCardQualifier[]);
+    get timeArray(): ValueDisplay[];
+    getAirportExpressStations(): {
+        code: string;
+        name: string;
+    }[];
+    get airportExpressStation(): string;
+    set airportExpressStation(station: string);
+    get isAirportExpress(): boolean;
+    set isAirportExpress(value: boolean);
+    setAirportExpressStationIds(stationIds: {
+        departureLocationId: string;
+        arrivalLocationId: string;
+    }): void;
+    private _cheapestStandard;
+    get cheapestStandard(): RailTicketOption;
+    private _cheapestFirst;
+    get cheapestFirst(): RailTicketOption;
+    constructor(Railfetcher: BaseRailQuoteFetcher<Q>, getRailStationFetcher: BaseGetRailStationFetcher<GRS_Q>, helpers: BaseHelperRoutines, basketService: EnterpriseBasketServiceInterface, storageService: BaseStorageService, searchService: EnterpriseSearchServiceInterface);
+    protected resetQuery(): void;
+    private _setAirportExpressStations;
+    private _isValid;
+    startSearch(): Promise<boolean>;
+    getRecentSearchQuery(query: SearchRailQueryVariables): SaveRecentSearchMutationVariables;
+    startRecentSearch(recentSearch: RecentSearch): void;
+    private _removeCallingPoints;
+    private _updateOutboundDateTime;
+    private _updateReturnDateTime;
+    getSearchQuery(): SearchRailQueryVariables;
+    private getRailStationById;
+    private getCriteria;
+    createTicketGroups(results: RailJourneyOptions[]): RailTicketGroups;
+    combineChildTickets(tickets: RailTicketGroups): RailTicketGroups;
+    setTicketsGroups(results: RailJourneyOption[]): TicketGroups;
+    updateFromPreviousSearches(previousItems: Record<ServiceType, BasketItem>): void;
+    updateCanCombine(tkt: RailTicketOption): void;
+    toggleTicketSelect(ticket: RailTicketGroup, way: 'departs' | 'returns', timeSlotId: string, ticketId: string, fareIdentifier: string, ticketsGroups: RailTicketGroups): RailTicketGroups;
+    /**
+     * @description - determine if a fare can be combined with what we currently have selected
+     */
+    canCombine(journeyIdentifier: string, fareIdentifier: string): boolean;
+    clearUnneededTickets(way: string, group: RailTicketGroup, timeSlotId: string): RailTicketGroup;
+    getRailStation(code: string, isLoading?: BehaviorSubject<boolean>): Observable<RailStation>;
+    getSelectedRailTicketOption(railJourneyOption: RailJourneyOption, railTicketGroup: RailTicketGroup, providerIndex: number): RailTicketOption;
+    getLegsFromRailJourneyOption(railJourneyOption: RailJourneyOption): any[];
+    addSingleJourneyToBasket(serviceId: string, railQuery: SearchRailQueryVariables, railJourneyOption: RailJourneyOption, railTicketGroup: RailTicketGroup): Promise<boolean>;
+    addReturnJourneyToBasket(serviceId: string, railQuery: SearchRailQueryVariables, outbound: RailJourneyOption, inbound: RailJourneyOption, railTicketGroup: RailTicketGroup): Promise<boolean>;
+    createTicketExtrasObject(railTicketExtra: RailTicketExtra): TicketExtras[];
+    sortTicketPrices(tickets: TicketGroups): TicketGroups;
+    sortTicketChildrenPrices(tickets: RailTicketGroups): RailTicketGroups;
+    updateLowestPrice(results: RailJourneyOptions[]): ICheapestPrice;
+    findCheapestTicket(results: RailJourneyOptions[]): number;
+    calculateTimeDifferenceInMins(railJourney: RailJourneyOption | RailSegment): string;
+    /**
+     * @description - determine if a ticket is an eTicket
+     * @param ticket - the ticket we want to to check
+     * @returns - boolean
+     */
+    ticketIsAnETicket(ticket: RailTicketOption): boolean;
+    /**
+     * @description - clear all of our chosen tickets/other rail stuff, call this when kicking off a new search
+     */
+    clearChosenTickets(): void;
+}

package/dist/obtservices/base/lib/vendor/classes/routehappy-request.d.ts

@@ -0,0 +1,126 @@
+export declare namespace UPA {
+    interface Segment {
+        arr: string;
+        cabin_id: number;
+        carrier: string;
+        dep_date: string;
+        dep: string;
+        flt_no: string;
+    }
+    interface Leg {
+        segments: Segment[];
+    }
+    interface Attributes {
+        categories: string[];
+        fare_source: string;
+        legs: Leg[];
+    }
+    interface Data {
+        attributes: Attributes;
+        type: string;
+    }
+    interface UPARequest {
+        data: Data;
+    }
+}
+export declare namespace Amenities {
+    interface Links {
+        segments: string[];
+    }
+    interface Datum {
+        id: string;
+        links: Links;
+    }
+    interface Links2 {
+        aircraft: number;
+        beverage: number;
+        entertainment: number;
+        fresh_food: number;
+        layout: number;
+        power: number;
+        seat: number;
+        wifi: number;
+    }
+    interface Segment {
+        id: string;
+        links: Links2;
+        mk_flt_no: string;
+    }
+    interface AmenitiesBase {
+        display_text: string;
+        id: number;
+        quality: string;
+        type: string;
+        updated_at: string;
+    }
+    interface Seat extends AmenitiesBase {
+        flatness: string;
+        legroom: string;
+        pitch: string;
+        width: string;
+    }
+    interface Wifi extends AmenitiesBase {
+        chance: string;
+        connectivity_type: string;
+        cost: string;
+        coverage: string;
+        exists: string;
+        performance: string;
+    }
+    interface Power extends AmenitiesBase {
+        chance: string;
+        cost: string;
+        distribution: string;
+        exists: string;
+        multiple_at_seat: string;
+        power_outlet: string;
+        usb_port: string;
+    }
+    interface Offerings {
+        delivery_medium: string;
+        content_type: string;
+        selection_type: string;
+    }
+    interface Entertainment extends AmenitiesBase {
+        cost: string;
+        exists: string;
+        offerings: Offerings[];
+    }
+    interface FreshFood extends AmenitiesBase {
+        cost: string;
+        exists: string;
+    }
+    interface Beverage extends AmenitiesBase {
+        alcoholic_cost: string;
+        exists: string;
+        nonalcoholic_cost: string;
+    }
+    interface Layout extends AmenitiesBase {
+        direct_aisle_access: string;
+        row_layout: string;
+    }
+    interface Aircraft extends AmenitiesBase {
+        cabin_pressure: string;
+        model: string;
+        window_size: string;
+    }
+    interface Linked {
+        aircrafts: Aircraft[];
+        beverages: Beverage[];
+        entertainments: Entertainment[];
+        fresh_foods: FreshFood[];
+        layouts: Layout[];
+        powers: Power[];
+        seats: Seat[];
+        segments: Segment[];
+        wifis: Wifi[];
+    }
+    interface Meta {
+        unmatched_keys: any[];
+    }
+    interface AmenitiesResponse {
+        data: Datum[];
+        linked: Linked;
+        meta: Meta;
+    }
+}

package/dist/obtservices/base/lib/vendor/classes/routehappy-response.d.ts

@@ -0,0 +1,107 @@
+export interface Meta {
+    not_matched_leg_indexes: any[];
+}
+export interface Meta2 {
+    index: number;
+}
+export interface Datum {
+    id: string;
+    meta: Meta2;
+    type: string;
+}
+export interface Legs {
+    data: Datum[];
+}
+export interface Relationships {
+    legs: Legs;
+}
+export interface Data {
+    id: string;
+    relationships: Relationships;
+    type: string;
+}
+export interface Datum2 {
+    id: string;
+    type: string;
+}
+export interface LegFares {
+    data: Datum2[];
+}
+export interface Data2 {
+    id: string;
+    type: string;
+}
+export interface Photo {
+    data: Data2;
+}
+export interface Datum3 {
+    id: string;
+    type: string;
+}
+export interface PhotoAttachments {
+    data: Datum3[];
+}
+export interface Datum4 {
+    id: string;
+    type: string;
+}
+export interface Upas {
+    data: Datum4[];
+}
+export interface Data3 {
+    id: string;
+    type: string;
+}
+export interface Fare {
+    data: Data3;
+}
+export interface Datum5 {
+    id: string;
+    type: string;
+}
+export interface LegFareSegments {
+    data: Datum5[];
+}
+export interface Relationships2 {
+    fare: Fare;
+    leg_fare_segments: LegFareSegments;
+    leg_fares: LegFares;
+    photo_attachments: PhotoAttachments;
+    photo: Photo;
+    upas: Upas;
+}
+export interface Attributes {
+    brand_codes: string[];
+    brand_name: string;
+    caption: string;
+    categories: string[];
+    cta_text: string;
+    cta_url: string;
+    description: string;
+    fees: any[];
+    headline: string;
+    large_icon_url: string;
+    large_url: string;
+    medium_square_url: string;
+    mk_flt_no: string;
+    small_icon_url: string;
+    thumb_url: string;
+    url: string;
+}
+export declare enum IncludedType {
+    Leg = "leg",
+    Photo = "photo",
+    PhotoAttachment = "photo_attachment",
+    Upa = "upa"
+}
+export interface Included {
+    attributes: Attributes;
+    id: string;
+    relationships: Relationships2;
+    type: IncludedType;
+}
+export interface RouteHappyResponse {
+    data: Data;
+    included: Included[];
+    meta: Meta;
+}

package/dist/obtservices/base/lib/vendor/classes/supplementary-booking-info-impl.d.ts

@@ -0,0 +1,62 @@
+import { BaseHelperRoutines } from '../classes/helpers';
+import { BehaviorSubject } from 'rxjs';
+import { GetUserAddressResult, GetUserPhoneNumberResult, GetUserResult, Schema, SchemaFormat, SchemaType } from '../types/types';
+import { BaseGetUserFetcher, SearchGetUserFetcherType } from '../fetchers/user-fetcher';
+import { Address, BasketItem, BookingAddress, BookingPhoneNumber, PhoneNumber, SupplementaryBookingInfo, User } from '../types/graphql.types';
+import { SupplementaryBookingInfoInterface } from '../interfaces/Isupplementary-booking-info-impl';
+export declare class AddressImpl {
+    private helpers;
+    private details;
+    bookingAddress: BehaviorSubject<BookingAddress[]>;
+    constructor(helpers: BaseHelperRoutines);
+    updateDetails(values: (BookingAddress | Address | GetUserAddressResult)[]): void;
+}
+export declare class PhoneNumberImpl {
+    private helpers;
+    private details;
+    bookingPhoneNUmber: BehaviorSubject<BookingPhoneNumber[]>;
+    constructor(helpers: BaseHelperRoutines);
+    updateDetails(values: (BookingPhoneNumber | PhoneNumber | GetUserPhoneNumberResult)[]): void;
+}
+export declare class UserInfoImpl<Q extends SearchGetUserFetcherType> {
+    user: User;
+    private getUserFetcher;
+    private helpers;
+    private perPassengerPhoneNumber;
+    private perPassengerAddress;
+    private perPassengerSupplementaryBookingInfoSchema;
+    get id(): string;
+    get userAddress(): AddressImpl;
+    get userPhoneNumber(): PhoneNumberImpl;
+    get userSupplementaryInfo(): any;
+    userInfo: {
+        id: string;
+        address: AddressImpl;
+        phoneNumber: PhoneNumberImpl;
+        supplementaryInfo: Schema;
+    };
+    userDetails: GetUserResult;
+    constructor(user: User, getUserFetcher: BaseGetUserFetcher<Q>, helpers: BaseHelperRoutines, perPassengerPhoneNumber: boolean, perPassengerAddress: boolean, perPassengerSupplementaryBookingInfoSchema: Schema);
+    private setUpUserInfo;
+}
+export declare class SupplementaryBookingInfoImpl<Q extends SearchGetUserFetcherType> implements SupplementaryBookingInfoInterface {
+    private basketItem;
+    private helpers;
+    get perItemAddress(): boolean;
+    get perItemPhoneNumber(): boolean;
+    get perItemSupplementarySchema(): Schema;
+    get perPassengerAddress(): boolean;
+    get perPassengerPhoneNumber(): boolean;
+    get perPassengerSupplementaryBookingInfoSchema(): Schema;
+    address: AddressImpl;
+    phoneNumber: PhoneNumberImpl;
+    userInfo: UserInfoImpl<Q>[];
+    hasDetails: boolean;
+    constructor(basketItem: BasketItem, helpers: BaseHelperRoutines, getUserFetcher: BaseGetUserFetcher<Q>);
+    processSchema(schema: Schema): Schema;
+    schemaWidgetToFormat(widget: string): SchemaFormat;
+    schemaTypeToFormat(type: SchemaType): SchemaFormat;
+    createSupplemtalBookingInformation(values: {
+        [key: string]: any;
+    }): SupplementaryBookingInfo;
+}

package/dist/obtservices/base/lib/vendor/classes/user-favourite.enum.d.ts

@@ -0,0 +1,12 @@
+export declare class UserFavorurite {
+    value: string;
+    static MaxFlightClass: UserFavorurite;
+    static SSO_no_password: UserFavorurite;
+    constructor(value: string);
+}
+export declare class Suppliers {
+    value: string;
+    static non: Suppliers;
+    static EVI: Suppliers;
+    constructor(value: string);
+}

package/dist/obtservices/base/lib/vendor/classes/validator.checker.d.ts

@@ -0,0 +1,6 @@
+import { ValidationErrors } from '../types/types';
+export declare abstract class ValidatorChecker {
+    constructor();
+    abstract isValid(): boolean;
+    abstract hasErrors(value: string): Promise<ValidationErrors>;
+}

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

@@ -0,0 +1,20 @@
+import { ApolloQueryResult } from '@apollo/client/core';
+import { Observable } from 'rxjs';
+import { BaseModalOpenerService } from '../services/modal-opener.service';
+import { GetUserBasketQuery, GetUserBasketQueryVariables } from '../types/graphql.types';
+import { GetUserBasketResult } from '../types/types';
+import { FetchableObject } from './object-fetchable-enterprise';
+declare type R = {
+    getUserBasket: P;
+};
+declare type P = GetUserBasketResult;
+declare type A = GetUserBasketQueryVariables;
+declare type M = GetUserBasketQuery;
+export declare type GetBasketFetcherType = {
+    fetch: (a: A) => Observable<ApolloQueryResult<M>>;
+};
+export declare class BaseGetBasketFetcher<Q extends GetBasketFetcherType> extends FetchableObject<Q, A, R, P, M> {
+    constructor(getBasketGQL: Q, modalService: BaseModalOpenerService);
+    protected getDataFromResult(results: ApolloQueryResult<R>): P;
+}
+export {};

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

@@ -0,0 +1,23 @@
+import { ApolloQueryResult } from '@apollo/client/core';
+import { BaseModalOpenerService } from '../services/modal-opener.service';
+import { BaseHelperRoutines } from '../classes/helpers';
+import { FetchableList } from './list-fetchable-enterprise';
+import { Observable } from 'rxjs';
+import { CabhireQuoteResultArray } from '../types/types';
+import { SearchCabHireQuery, SearchCabHireQueryVariables } from '../types/graphql.types';
+declare type R = {
+    searchCabHire: {
+        results: P;
+    };
+};
+declare type P = CabhireQuoteResultArray;
+declare type A = SearchCabHireQueryVariables;
+declare type M = SearchCabHireQuery;
+export declare type CabhireQuoteFetcherType = {
+    fetch: (a: A) => Observable<ApolloQueryResult<M>>;
+};
+export declare class BaseCabhireQuoteFetcher<Q extends CabhireQuoteFetcherType> extends FetchableList<Q, A, R, P, M> {
+    constructor(gql: Q, helpers: BaseHelperRoutines, modalService: BaseModalOpenerService);
+    protected getDataFromResult(results: ApolloQueryResult<R>): P;
+}
+export {};

package/dist/obtservices/base/lib/vendor/fetchers/carhire-availability-detail.fetcher.d.ts

@@ -0,0 +1,20 @@
+import { ApolloQueryResult } from '@apollo/client/core';
+import { BaseHelperRoutines } from '../classes/helpers';
+import { FetchableList } from './list-fetchable-enterprise';
+import { BaseModalOpenerService } from '../services/modal-opener.service';
+import { Observable } from 'rxjs';
+import { CarHireDetailRequestResponse, CarHireAvailabilityDetailRequestQuery, CarHireAvailabilityDetailRequestQueryVariables } from '../types/graphql.types';
+declare type R = {
+    carHireAvailabilityDetailRequest: P;
+};
+declare type P = CarHireDetailRequestResponse;
+declare type A = CarHireAvailabilityDetailRequestQueryVariables;
+declare type M = CarHireAvailabilityDetailRequestQuery;
+export declare type CarHireAvailabilityDetailFetcherType = {
+    fetch: (a: A) => Observable<ApolloQueryResult<M>>;
+};
+export declare class BaseCarHireAvailabilityDetailFetcher<Q extends CarHireAvailabilityDetailFetcherType> extends FetchableList<Q, A, R, P, M> {
+    constructor(gql: Q, helpers: BaseHelperRoutines, modalService: BaseModalOpenerService);
+    protected getDataFromResult(results: ApolloQueryResult<R>): P;
+}
+export {};