@sabstravtech/obtservices 0.0.3 → 0.0.19020100

package/esm2015/angular/lib/vendor/types/graphql.angular.types.js

@@ -333,9 +333,10 @@ export var FlightCabinClass;
 (function (FlightCabinClass) {
     FlightCabinClass["Any"] = "Any";
     FlightCabinClass["LiteEconomy"] = "LiteEconomy";
+    FlightCabinClass["Economy"] = "Economy";
     FlightCabinClass["EconomyRestricted"] = "EconomyRestricted";
     FlightCabinClass["EconomyNoBags"] = "EconomyNoBags";
-    FlightCabinClass["Economy"] = "Economy";
+    FlightCabinClass["EconomyFlexi"] = "EconomyFlexi";
     FlightCabinClass["PremiumEconomy"] = "PremiumEconomy";
     FlightCabinClass["Business"] = "Business";
     FlightCabinClass["PremiumBusiness"] = "PremiumBusiness";
@@ -371,6 +372,15 @@ export var IrlTravellerStatus;
     IrlTravellerStatus["Placeholder"] = "placeholder";
     IrlTravellerStatus["Complete"] = "complete";
 })(IrlTravellerStatus || (IrlTravellerStatus = {}));
+export var MessageTarget;
+(function (MessageTarget) {
+    MessageTarget["Login"] = "LOGIN";
+    MessageTarget["SearchForm"] = "SEARCH_FORM";
+    MessageTarget["Results"] = "RESULTS";
+    MessageTarget["MiForm"] = "MI_FORM";
+    MessageTarget["BasketBeforeConfirm"] = "BASKET_BEFORE_CONFIRM";
+    MessageTarget["Dashboard"] = "DASHBOARD";
+})(MessageTarget || (MessageTarget = {}));
 export var PassengerType;
 (function (PassengerType) {
     PassengerType["Adult"] = "ADULT";
@@ -456,6 +466,7 @@ export var UiPresentation;
 (function (UiPresentation) {
     UiPresentation["FreeText"] = "FREE_TEXT";
     UiPresentation["AutoSuggest"] = "AUTO_SUGGEST";
+    UiPresentation["Dropdown"] = "DROPDOWN";
     UiPresentation["Hidden"] = "HIDDEN";
 })(UiPresentation || (UiPresentation = {}));
 export const OwnerFieldsFragmentDoc = gql `
@@ -655,15 +666,12 @@ export const GroupedFieldsFragmentDoc = gql `
   minPrice
   maxPrice
   flights {
-    LiteEconomy
     EconomyRestricted
     EconomyNoBags
-    Economy
+    EconomyFlexi
     PremiumEconomy
     Business
-    PremiumBusiness
     First
-    PremiumFirst
   }
 }
     `;
@@ -2100,6 +2108,74 @@ GetCarHireDepotsGQL.decorators = [
 GetCarHireDepotsGQL.ctorParameters = () => [
     { type: Apollo.Apollo }
 ];
+export const GetConfermaOfficeDocument = gql `
+    query getConfermaOffice($officeId: Int!) {
+  getConfermaOffice(officeId: $officeId) {
+    results {
+      id
+      name
+      address {
+        addressName
+        addressLine1
+        addressLine2
+        addressLine3
+        postalCode
+        city
+        countryCode
+        countryName
+        telephoneNumber
+        facsimileNumber
+        emailAddress
+        stateProvince
+        mobileNumber
+      }
+      closestAirport
+      closestTrainStation
+      longitude
+      latitude
+      closestHotels {
+        hotelId
+        hotelName
+        isPreferred
+      }
+    }
+    errors {
+      service {
+        id
+        type
+        name
+        description
+        supplierUrl
+        active
+        apiEndpointUrl
+        basketItemTtl
+        cancellable
+        amendable
+        detailSchema
+        searchQuerySchema
+      }
+      errorMessage
+      errorCode
+    }
+  }
+}
+    `;
+export class GetConfermaOfficeGQL extends Apollo.Query {
+    constructor(apollo) {
+        super(apollo);
+        this.document = GetConfermaOfficeDocument;
+    }
+}
+/** @nocollapse */ GetConfermaOfficeGQL.ɵprov = i0.ɵɵdefineInjectable({ factory: function GetConfermaOfficeGQL_Factory() { return new GetConfermaOfficeGQL(i0.ɵɵinject(i1.Apollo)); }, token: GetConfermaOfficeGQL, providedIn: "root" });
+GetConfermaOfficeGQL.decorators = [
+    { type: Injectable, args: [{
+                providedIn: 'root'
+            },] }
+];
+/** @nocollapse */
+GetConfermaOfficeGQL.ctorParameters = () => [
+    { type: Apollo.Apollo }
+];
 export const GetConfermaOfficeNamesDocument = gql `
     query getConfermaOfficeNames {
   getConfermaOfficeNames {
@@ -2255,6 +2331,52 @@ GetConfermaQuicklistGQL.decorators = [
 GetConfermaQuicklistGQL.ctorParameters = () => [
     { type: Apollo.Apollo }
 ];
+export const GetIrlSupplierStationDocument = gql `
+    query getIRLSupplierStation($id: ID, $supplier: IRLSupplier, $code: String) {
+  getIRLSupplierStation(id: $id, supplier: $supplier, code: $code) {
+    id
+    name
+    supplier
+    stationCode
+    nlcCode
+    trainlineCode
+    trainlineUniqueCode
+    locationDetails {
+      continent
+      country
+      countryCode
+      state
+      city
+      coordinates {
+        latitude
+        longitude
+        altitude
+      }
+      postcode
+      road
+      gridReference
+      northing
+      easting
+    }
+  }
+}
+    `;
+export class GetIrlSupplierStationGQL extends Apollo.Query {
+    constructor(apollo) {
+        super(apollo);
+        this.document = GetIrlSupplierStationDocument;
+    }
+}
+/** @nocollapse */ GetIrlSupplierStationGQL.ɵprov = i0.ɵɵdefineInjectable({ factory: function GetIrlSupplierStationGQL_Factory() { return new GetIrlSupplierStationGQL(i0.ɵɵinject(i1.Apollo)); }, token: GetIrlSupplierStationGQL, providedIn: "root" });
+GetIrlSupplierStationGQL.decorators = [
+    { type: Injectable, args: [{
+                providedIn: 'root'
+            },] }
+];
+/** @nocollapse */
+GetIrlSupplierStationGQL.ctorParameters = () => [
+    { type: Apollo.Apollo }
+];
 export const GetRailStationDocument = gql `
     query getRailStation($id: ID, $code: String) {
   getRailStation(id: $id, code: $code) {
@@ -5206,6 +5328,52 @@ SearchIrlGQL.decorators = [
 SearchIrlGQL.ctorParameters = () => [
     { type: Apollo.Apollo }
 ];
+export const SearchIrlSupplierStationsDocument = gql `
+    query searchIRLSupplierStations($query: String!, $supplier: IRLSupplier) {
+  searchIRLSupplierStations(query: $query, supplier: $supplier) {
+    id
+    name
+    supplier
+    stationCode
+    nlcCode
+    trainlineCode
+    trainlineUniqueCode
+    locationDetails {
+      continent
+      country
+      countryCode
+      state
+      city
+      coordinates {
+        latitude
+        longitude
+        altitude
+      }
+      postcode
+      road
+      gridReference
+      northing
+      easting
+    }
+  }
+}
+    `;
+export class SearchIrlSupplierStationsGQL extends Apollo.Query {
+    constructor(apollo) {
+        super(apollo);
+        this.document = SearchIrlSupplierStationsDocument;
+    }
+}
+/** @nocollapse */ SearchIrlSupplierStationsGQL.ɵprov = i0.ɵɵdefineInjectable({ factory: function SearchIrlSupplierStationsGQL_Factory() { return new SearchIrlSupplierStationsGQL(i0.ɵɵinject(i1.Apollo)); }, token: SearchIrlSupplierStationsGQL, providedIn: "root" });
+SearchIrlSupplierStationsGQL.decorators = [
+    { type: Injectable, args: [{
+                providedIn: 'root'
+            },] }
+];
+/** @nocollapse */
+SearchIrlSupplierStationsGQL.ctorParameters = () => [
+    { type: Apollo.Apollo }
+];
 export const SearchPostcodesDocument = gql `
     query searchPostcodes($postcode: String!) {
   getPostcodeDetails(postcode: $postcode) {
@@ -5659,4 +5827,4 @@ ValidateUserMiFreeValueGQL.decorators = [
 ValidateUserMiFreeValueGQL.ctorParameters = () => [
     { type: Apollo.Apollo }
 ];
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"graphql.angular.types.js","sourceRoot":"","sources":["../../../../../../../projects/obtservices/angular/src/lib/vendor/types/graphql.angular.types.ts"],"names":[],"mappings":"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CAAA;IACX,2BAAW,CAAA;IACX,2BAAW,CAAA;IACX,2BAAW,CAAA;IACX,2BAAW,CAAA;IACX,2BAAW,CAAA;IACX,2BAAW,CAAA;IACX,2BAAW,CAAA;IACX,2BAAW,CAAA;IACX,2BAAW,CAAA;IACX,2BAAW,CAAA;IACX,2BAAW,CAAA;IACX,2BAAW,CAAA;IACX,2BAAW,CAAA;IACX,2BAAW,CAAA;IACX,2BAAW,CAAA;IACX,2BAAW,CAAA;IACX,2BAAW,CAAA;IACX,2BAAW,CAAA;IACX,2BAAW,CAAA;IACX,2BAAW,CAAA;IACX,2BAAW,CAAA;IACX,2BAAW,CAAA;IACX,2BAAW,CAAA;IACX,2BAAW,CAAA;IACX,2BAAW,CAAA;IACX,2BAAW,CAAA;IACX,2BAAW,CAAA;IACX,2BAAW,CAAA;IACX,2BAAW,CAAA;IACX,2BAAW,CAAA;IACX,2BAAW,CAAA;IACX,2BAAW,CAAA;IACX,2BAAW,CAAA;IACX,2BAAW,CAAA;IACX,2BAAW,CAAA;IACX,2BAAW,CAAA;IACX,2BAAW,CAAA;IACX,2BAAW,CAAA;IACX,2BAAW,CAAA;IACX,2BAAW,CAAA;IACX,2BAAW,CAAA;IACX,2BAAW,CAAA;IACX,2BAAW,CAAA;IACX,2BAAW,CAAA;IACX,2BAAW,CAAA;IACX,2BAAW,CAAA;IACX,2BAAW,CAAA;IACX,2BAAW,CAAA;IACX,2BAAW,CAAA;IACX,2BAAW,CAAA;IACX,2BAAW,CAAA;IACX,2BAAW,CAAA;IACX,2BAAW,CAAA;IACX,2BAAW,CAAA;IACX,2BAAW,CAAA;IACX,2BAAW,CAAA;IACX,2BAAW,CAAA;IACX,2BAAW,CAAA;IACX,2BAAW,CAAA;IACX,2BAAW,CAAA;IACX,2BAAW,CAAA;IACX,2BAAW,CAAA;IACX,2BAAW,CAAA;IACX,2BAAW,CAAA;IACX,2BAAW,CAAA;IACX,2BAAW,CAAA;IACX,2BAAW,CAAA;IACX,2BAAW,CAAA;IACX,2BAAW,CAAA;IACX,2BAAW,CAAA;IACX,2BAAW,CAAA;IACX,2BAAW,CAAA;IACX,2BAAW,CAAA;IACX,2BAAW,CAAA;IACX,2BAAW,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","sourcesContent":["import { gql } from 'apollo-angular';\nimport { Injectable } from '@angular/core';\nimport * as Apollo from 'apollo-angular';\nexport type Maybe<T> = T | null;\nexport type Exact<T extends { [key: string]: unknown }> = { [K in keyof T]: T[K] };\nexport type MakeOptional<T, K extends keyof T> = Omit<T, K> & { [SubKey in K]?: Maybe<T[SubKey]> };\nexport type MakeMaybe<T, K extends keyof T> = Omit<T, K> & { [SubKey in K]: Maybe<T[SubKey]> };\nexport type FieldWrapper<T> = T;\n/** All built-in and custom scalars, mapped to their actual values */\nexport type Scalars = {\n  ID: string;\n  String: string;\n  Boolean: boolean;\n  Int: number;\n  Float: number;\n  Date: any;\n  DateTime: any;\n  JSON: any;\n};\n\n\n\nexport type Address = {\n  __typename?: 'Address';\n  id: FieldWrapper<Scalars['ID']>;\n  description?: Maybe<FieldWrapper<Scalars['String']>>;\n  numberOrName?: Maybe<FieldWrapper<Scalars['String']>>;\n  street?: Maybe<FieldWrapper<Scalars['String']>>;\n  town?: Maybe<FieldWrapper<Scalars['String']>>;\n  county?: Maybe<FieldWrapper<Scalars['String']>>;\n  postcode?: Maybe<FieldWrapper<Scalars['String']>>;\n  countryCode?: Maybe<FieldWrapper<Scalars['String']>>;\n  userPrimary?: Maybe<FieldWrapper<Scalars['Boolean']>>;\n  officePrimary?: Maybe<FieldWrapper<Scalars['Boolean']>>;\n};\n\nexport type AfterCancellationInfo = {\n  __typename?: 'AfterCancellationInfo';\n  cancelled: FieldWrapper<Scalars['Boolean']>;\n  cancellationFee: FieldWrapper<Scalars['Float']>;\n};\n\nexport type AirlineResult = {\n  __typename?: 'AirlineResult';\n  id: FieldWrapper<Scalars['ID']>;\n  name?: Maybe<FieldWrapper<Scalars['String']>>;\n  iata?: Maybe<FieldWrapper<Scalars['String']>>;\n  icao?: Maybe<FieldWrapper<Scalars['String']>>;\n  alias?: Maybe<FieldWrapper<Scalars['String']>>;\n  callsign?: Maybe<FieldWrapper<Scalars['String']>>;\n  active?: Maybe<FieldWrapper<Scalars['Boolean']>>;\n  continent?: Maybe<FieldWrapper<Scalars['String']>>;\n  country?: Maybe<FieldWrapper<Scalars['String']>>;\n  countryCode?: Maybe<FieldWrapper<Scalars['String']>>;\n  bannerImage?: Maybe<FieldWrapper<Scalars['String']>>;\n  logoImage?: Maybe<FieldWrapper<Scalars['String']>>;\n};\n\nexport type AirlineResults = {\n  __typename?: 'AirlineResults';\n  iataMatch?: Maybe<FieldWrapper<AirlineResult>>;\n  generalMatches: Array<FieldWrapper<AirlineResult>>;\n};\n\nexport type Airport = {\n  __typename?: 'Airport';\n  id: FieldWrapper<Scalars['ID']>;\n  name: FieldWrapper<Scalars['String']>;\n  iata?: Maybe<FieldWrapper<Scalars['String']>>;\n  icao?: Maybe<FieldWrapper<Scalars['String']>>;\n  terminals: Array<FieldWrapper<Scalars['String']>>;\n  hasLounge?: Maybe<FieldWrapper<Scalars['Boolean']>>;\n  hasParking?: Maybe<FieldWrapper<Scalars['Boolean']>>;\n  hasFastTrack?: Maybe<FieldWrapper<Scalars['Boolean']>>;\n  hasPublicTravel?: Maybe<FieldWrapper<Scalars['Boolean']>>;\n  locationDetails?: Maybe<FieldWrapper<LocationDetail>>;\n};\n\nexport type AirportDetail = {\n  __typename?: 'AirportDetail';\n  iata?: Maybe<FieldWrapper<Scalars['String']>>;\n  icao?: Maybe<FieldWrapper<Scalars['String']>>;\n  latitude?: Maybe<FieldWrapper<Scalars['Float']>>;\n  longitude?: Maybe<FieldWrapper<Scalars['Float']>>;\n  altitude?: Maybe<FieldWrapper<Scalars['Float']>>;\n  state?: Maybe<FieldWrapper<Scalars['String']>>;\n  city?: Maybe<FieldWrapper<Scalars['String']>>;\n  road?: Maybe<FieldWrapper<Scalars['String']>>;\n  popularity?: Maybe<FieldWrapper<Scalars['Int']>>;\n  area?: Maybe<FieldWrapper<Scalars['String']>>;\n  location?: Maybe<FieldWrapper<Scalars['String']>>;\n  offset?: Maybe<FieldWrapper<Scalars['String']>>;\n  airportName?: Maybe<FieldWrapper<Scalars['String']>>;\n  countryName?: Maybe<FieldWrapper<Scalars['String']>>;\n  countryCode?: Maybe<FieldWrapper<Scalars['String']>>;\n  postcode?: Maybe<FieldWrapper<Scalars['String']>>;\n};\n\nexport type AirportResults = {\n  __typename?: 'AirportResults';\n  iataMatch?: Maybe<FieldWrapper<Airport>>;\n  generalMatches: Array<FieldWrapper<Airport>>;\n};\n\nexport enum ApplicationStage {\n  BeforeSearch = 'BEFORE_SEARCH',\n  AfterSearch = 'AFTER_SEARCH'\n}\n\nexport type Approvee = {\n  __typename?: 'Approvee';\n  approvee: FieldWrapper<User>;\n  active: FieldWrapper<Scalars['Boolean']>;\n  priority: FieldWrapper<Scalars['Int']>;\n};\n\nexport type Approver = {\n  __typename?: 'Approver';\n  approver: FieldWrapper<User>;\n  active: FieldWrapper<Scalars['Boolean']>;\n  priority: FieldWrapper<Scalars['Int']>;\n};\n\nexport type BaggageAllowance = {\n  __typename?: 'BaggageAllowance';\n  type: FieldWrapper<BaggageType>;\n  qty: FieldWrapper<Scalars['Int']>;\n  maxKG?: Maybe<FieldWrapper<Scalars['Float']>>;\n  maxLBS?: Maybe<FieldWrapper<Scalars['Float']>>;\n};\n\nexport enum BaggageType {\n  CheckIn = 'CheckIn',\n  HandCarry = 'HandCarry'\n}\n\nexport type Basket = {\n  __typename?: 'Basket';\n  id: FieldWrapper<Scalars['ID']>;\n  owner: FieldWrapper<User>;\n  reference: FieldWrapper<Scalars['String']>;\n  title: FieldWrapper<Scalars['String']>;\n  notes?: Maybe<FieldWrapper<Scalars['String']>>;\n  createdAt: FieldWrapper<Scalars['DateTime']>;\n  updatedAt: FieldWrapper<Scalars['DateTime']>;\n  basketItems: Array<FieldWrapper<BasketItem>>;\n  status: FieldWrapper<BasketStatus>;\n  companyGroup?: Maybe<FieldWrapper<CompanyGroup>>;\n  validated: FieldWrapper<Scalars['Boolean']>;\n  bookedAt?: Maybe<FieldWrapper<Scalars['DateTime']>>;\n};\n\nexport type BasketItem = {\n  __typename?: 'BasketItem';\n  id: FieldWrapper<Scalars['ID']>;\n  basket: FieldWrapper<Basket>;\n  adults: FieldWrapper<Scalars['Int']>;\n  children: FieldWrapper<Scalars['Int']>;\n  infants: FieldWrapper<Scalars['Int']>;\n  detail: FieldWrapper<Scalars['JSON']>;\n  detailHash: FieldWrapper<Scalars['String']>;\n  createdAt: FieldWrapper<Scalars['DateTime']>;\n  updatedAt: FieldWrapper<Scalars['DateTime']>;\n  expiry: FieldWrapper<Scalars['DateTime']>;\n  expired: FieldWrapper<Scalars['Boolean']>;\n  users: Array<FieldWrapper<User>>;\n  userPassengerTypes: Array<FieldWrapper<UserPassengerType>>;\n  leadPassenger?: Maybe<FieldWrapper<User>>;\n  service: FieldWrapper<Service>;\n  searchQuery: FieldWrapper<Scalars['JSON']>;\n  price: FieldWrapper<Scalars['Float']>;\n  currency: FieldWrapper<CurrencyCode>;\n  miGroupsAvailable: Array<FieldWrapper<Scalars['String']>>;\n  miGroupSelected?: Maybe<FieldWrapper<Scalars['String']>>;\n  managementInfo: Array<FieldWrapper<ManagementInfo>>;\n  validated: FieldWrapper<Scalars['Boolean']>;\n  latestValidation?: Maybe<FieldWrapper<Scalars['DateTime']>>;\n  latestValidationPrice?: Maybe<FieldWrapper<Scalars['Int']>>;\n  latestValidationPriceDifference?: Maybe<FieldWrapper<Scalars['Int']>>;\n  latestValidationAvailable?: Maybe<FieldWrapper<Scalars['Boolean']>>;\n  bookingThirdPartyReference?: Maybe<FieldWrapper<Scalars['String']>>;\n  pnrLocator?: Maybe<FieldWrapper<Scalars['String']>>;\n  status: FieldWrapper<BasketItemStatus>;\n  availablePaymentMethods: Array<FieldWrapper<PaymentMethod>>;\n  selectedPaymentMethod?: Maybe<FieldWrapper<PaymentMethod>>;\n  perItemSupplementaryBookingInfoSchema: FieldWrapper<Scalars['JSON']>;\n  perPassengerSupplementaryBookingInfoSchema: FieldWrapper<Scalars['JSON']>;\n  perItemAddress: FieldWrapper<Scalars['Boolean']>;\n  perItemPhoneNumber: FieldWrapper<Scalars['Boolean']>;\n  perPassengerAddress: FieldWrapper<Scalars['Boolean']>;\n  perPassengerPhoneNumber: FieldWrapper<Scalars['Boolean']>;\n  cancellable: FieldWrapper<Scalars['Boolean']>;\n  amendable: FieldWrapper<Scalars['Boolean']>;\n  co2PerPassenger: FieldWrapper<Scalars['Float']>;\n  co2PerItem: FieldWrapper<Scalars['Float']>;\n  outboundDate: FieldWrapper<Scalars['DateTime']>;\n  inboundDate?: Maybe<FieldWrapper<Scalars['DateTime']>>;\n};\n\nexport enum BasketItemStatus {\n  Open = 'OPEN',\n  Booked = 'BOOKED',\n  BookingFailed = 'BOOKING_FAILED'\n}\n\nexport enum BasketStatus {\n  Open = 'OPEN',\n  Booked = 'BOOKED',\n  AwaitingApproval = 'AWAITING_APPROVAL',\n  Approved = 'APPROVED',\n  Disapproved = 'DISAPPROVED',\n  PartiallyBooked = 'PARTIALLY_BOOKED',\n  BookingFailed = 'BOOKING_FAILED'\n}\n\nexport type BeforeCancellationInfo = {\n  __typename?: 'BeforeCancellationInfo';\n  cancellable: FieldWrapper<Scalars['Boolean']>;\n  info?: Maybe<FieldWrapper<Scalars['String']>>;\n  cancellationFee?: Maybe<FieldWrapper<Scalars['Float']>>;\n};\n\nexport enum BookerType {\n  Root = 'ROOT',\n  Tmc = 'TMC',\n  Company = 'COMPANY',\n  Office = 'OFFICE',\n  CompanyGroup = 'COMPANY_GROUP',\n  SelfBook = 'SELF_BOOK',\n  Booker = 'BOOKER',\n  Traveller = 'TRAVELLER',\n  BookerWithSelf = 'BOOKER_WITH_SELF'\n}\n\nexport type BookingAddress = {\n  numberOrName: Scalars['String'];\n  street: Scalars['String'];\n  town: Scalars['String'];\n  county: Scalars['String'];\n  postcode: Scalars['String'];\n  countryCode: Scalars['String'];\n};\n\nexport type BookingPhoneNumber = {\n  countryCode: Scalars['String'];\n  areaCode: Scalars['String'];\n  number: Scalars['String'];\n  extension?: Maybe<Scalars['String']>;\n};\n\nexport type CabHireLocation = {\n  __typename?: 'CabHireLocation';\n  address: FieldWrapper<Scalars['String']>;\n  postcode: FieldWrapper<Scalars['String']>;\n  latitude?: Maybe<FieldWrapper<Scalars['Float']>>;\n  longitude?: Maybe<FieldWrapper<Scalars['Float']>>;\n};\n\nexport type CabHireLocationInput = {\n  address: Scalars['String'];\n  postcode: Scalars['String'];\n};\n\nexport type CabHireQuote = {\n  __typename?: 'CabHireQuote';\n  id: FieldWrapper<Scalars['ID']>;\n  source: FieldWrapper<Scalars['String']>;\n  sourceId: FieldWrapper<Scalars['Int']>;\n  supplierName: FieldWrapper<Scalars['String']>;\n  estimatedCO2: FieldWrapper<Scalars['Float']>;\n  co2PerPassenger: FieldWrapper<Scalars['Float']>;\n  co2PerItem: FieldWrapper<Scalars['Float']>;\n  price: FieldWrapper<Scalars['Float']>;\n  currency: FieldWrapper<CurrencyCode>;\n  vehicleType: FieldWrapper<CabHireVehicleType>;\n  tripDistanceMetres?: Maybe<FieldWrapper<Scalars['Int']>>;\n  tripDurationSeconds?: Maybe<FieldWrapper<Scalars['Int']>>;\n  departs: FieldWrapper<Scalars['DateTime']>;\n  tmcPreferred: FieldWrapper<Scalars['Boolean']>;\n  companyPreferred: FieldWrapper<Scalars['Boolean']>;\n  officePreferred: FieldWrapper<Scalars['Boolean']>;\n  tmcPreferredMessage?: Maybe<FieldWrapper<Scalars['String']>>;\n  companyPreferredMessage?: Maybe<FieldWrapper<Scalars['String']>>;\n  officePreferredMessage?: Maybe<FieldWrapper<Scalars['String']>>;\n  unavailable: FieldWrapper<Scalars['Boolean']>;\n  unavailableMessage?: Maybe<FieldWrapper<Scalars['String']>>;\n  fromLocation: FieldWrapper<CabHireLocation>;\n  toLocation: FieldWrapper<CabHireLocation>;\n  vias: Array<FieldWrapper<CabHireLocation>>;\n};\n\nexport type CabHireResult = {\n  __typename?: 'CabHireResult';\n  results: Array<FieldWrapper<CabHireQuote>>;\n  errors: Array<FieldWrapper<SearchError>>;\n};\n\nexport enum CabHireVehicleType {\n  Any = 'Any',\n  DdaCar = 'DDACar',\n  CoachLarge = 'CoachLarge',\n  CoachSmall = 'CoachSmall',\n  Economy = 'Economy',\n  EconomyCoach = 'EconomyCoach',\n  EconomyMpvSmall = 'EconomyMPVSmall',\n  EconomyMpvLarge = 'EconomyMPVLarge',\n  EconomySuv = 'EconomySUV',\n  ExecutiveCar = 'ExecutiveCar',\n  ExecutiveSuv = 'ExecutiveSUV',\n  GreenCar = 'GreenCar',\n  GreenExecutive = 'GreenExecutive',\n  GreenSuv = 'GreenSUV',\n  SmallMpv = 'SmallMPV',\n  MediumMpv = 'MediumMPV',\n  LargeMpv = 'LargeMPV',\n  StandardCar = 'StandardCar',\n  Suv = 'SUV',\n  BlackCab = 'BlackCab',\n  TaxiSuv = 'TaxiSUV'\n}\n\nexport type CarHireAdditionalInfoItem = {\n  __typename?: 'CarHireAdditionalInfoItem';\n  name?: Maybe<FieldWrapper<Scalars['String']>>;\n  text?: Maybe<Array<Maybe<FieldWrapper<Scalars['String']>>>>;\n  json?: Maybe<FieldWrapper<Scalars['String']>>;\n  custom?: Maybe<Array<Maybe<FieldWrapper<CarHireCustom>>>>;\n};\n\nexport type CarHireAddress = {\n  __typename?: 'CarHireAddress';\n  name?: Maybe<FieldWrapper<Scalars['String']>>;\n  topLine?: Maybe<FieldWrapper<Scalars['String']>>;\n  city?: Maybe<FieldWrapper<Scalars['String']>>;\n  region?: Maybe<FieldWrapper<Scalars['String']>>;\n  postCode?: Maybe<FieldWrapper<Scalars['String']>>;\n  country?: Maybe<FieldWrapper<Scalars['String']>>;\n  countryCode?: Maybe<FieldWrapper<Scalars['String']>>;\n  stateCode?: Maybe<FieldWrapper<Scalars['String']>>;\n  latitude?: Maybe<FieldWrapper<Scalars['Float']>>;\n  longitude?: Maybe<FieldWrapper<Scalars['Float']>>;\n};\n\nexport type CarHireAirportInput = {\n  pickupCode?: Maybe<Scalars['String']>;\n  dropoffCode?: Maybe<Scalars['String']>;\n};\n\nexport type CarHireCharge = {\n  __typename?: 'CarHireCharge';\n  label?: Maybe<FieldWrapper<Scalars['String']>>;\n  amount?: Maybe<FieldWrapper<Scalars['String']>>;\n  currencyCode?: Maybe<FieldWrapper<Scalars['String']>>;\n};\n\nexport type CarHireCityInput = {\n  pickupCountryCode?: Maybe<Scalars['String']>;\n  pickupCity?: Maybe<Scalars['String']>;\n  dropoffCountryCode?: Maybe<Scalars['String']>;\n  dropoffCity?: Maybe<Scalars['String']>;\n};\n\nexport enum CarHireClass {\n  Mini = 'Mini',\n  MiniElite = 'MiniElite',\n  Economy = 'Economy',\n  EconomyElite = 'EconomyElite',\n  Compact = 'Compact',\n  CompactElite = 'CompactElite',\n  Intermediate = 'Intermediate',\n  IntermediateElite = 'IntermediateElite',\n  Standard = 'Standard',\n  StandardElite = 'StandardElite',\n  Fullsize = 'Fullsize',\n  FullsizeElite = 'FullsizeElite',\n  Premium = 'Premium',\n  PremiumElite = 'PremiumElite',\n  Luxury = 'Luxury',\n  LuxuryElite = 'LuxuryElite',\n  Oversize = 'Oversize',\n  Special = 'Special'\n}\n\nexport type CarHireCustom = {\n  __typename?: 'CarHireCustom';\n  name?: Maybe<FieldWrapper<Scalars['String']>>;\n  text?: Maybe<Array<Maybe<FieldWrapper<Scalars['String']>>>>;\n};\n\nexport type CarHireDepot = {\n  __typename?: 'CarHireDepot';\n  countryCode?: Maybe<FieldWrapper<Scalars['String']>>;\n  locationCode?: Maybe<FieldWrapper<Scalars['String']>>;\n  extendedLocationCode?: Maybe<FieldWrapper<Scalars['String']>>;\n  vendorCode?: Maybe<FieldWrapper<Scalars['String']>>;\n  latitude?: Maybe<FieldWrapper<Scalars['Float']>>;\n  longitude?: Maybe<FieldWrapper<Scalars['Float']>>;\n  vendor?: Maybe<FieldWrapper<Scalars['String']>>;\n  addressLines?: Maybe<Array<Maybe<FieldWrapper<Scalars['String']>>>>;\n  cityName?: Maybe<FieldWrapper<Scalars['String']>>;\n};\n\nexport type CarHireDepotResult = {\n  __typename?: 'CarHireDepotResult';\n  results: Array<FieldWrapper<CarHireDepot>>;\n  errors: Array<FieldWrapper<SearchError>>;\n};\n\nexport type CarHireDetailRequestResponse = {\n  __typename?: 'CarHireDetailRequestResponse';\n  identifiers?: Maybe<FieldWrapper<CarHireIdentifiers>>;\n  vendor?: Maybe<FieldWrapper<CarHireVendor>>;\n  address?: Maybe<FieldWrapper<CarHireAddress>>;\n  additionalInfo?: Maybe<Array<FieldWrapper<CarHireAdditionalInfoItem>>>;\n};\n\nexport type CarHireDisplayRecord = {\n  __typename?: 'CarHireDisplayRecord';\n  status?: Maybe<FieldWrapper<Scalars['String']>>;\n  pickup?: Maybe<FieldWrapper<Scalars['String']>>;\n  dropoff?: Maybe<FieldWrapper<Scalars['String']>>;\n  vendor?: Maybe<FieldWrapper<CarHireVendor>>;\n  vehicle?: Maybe<FieldWrapper<CarHireVehicle>>;\n  charges?: Maybe<Array<Maybe<FieldWrapper<CarHireCharge>>>>;\n  pickupLocation?: Maybe<FieldWrapper<CarHireAddress>>;\n  returnLocation?: Maybe<FieldWrapper<CarHireAddress>>;\n  additionalInfo?: Maybe<Array<Maybe<FieldWrapper<CarHireAdditionalInfoItem>>>>;\n};\n\nexport type CarHireIdentifiers = {\n  __typename?: 'CarHireIdentifiers';\n  locator?: Maybe<FieldWrapper<Scalars['String']>>;\n  rph?: Maybe<FieldWrapper<Scalars['String']>>;\n  status?: Maybe<FieldWrapper<Scalars['String']>>;\n  vehType?: Maybe<FieldWrapper<Scalars['String']>>;\n  locationCode?: Maybe<FieldWrapper<Scalars['String']>>;\n  extendedLocationCode?: Maybe<FieldWrapper<Scalars['String']>>;\n  locationName?: Maybe<FieldWrapper<Scalars['String']>>;\n  dropOffLocation?: Maybe<FieldWrapper<Scalars['String']>>;\n  pickupDateTime?: Maybe<FieldWrapper<Scalars['DateTime']>>;\n  dropoffDateTime?: Maybe<FieldWrapper<Scalars['DateTime']>>;\n  vendor?: Maybe<FieldWrapper<Scalars['String']>>;\n};\n\nexport type CarHireInputIdentifiers = {\n  locator?: Maybe<Scalars['String']>;\n  rph?: Maybe<Scalars['String']>;\n  status?: Maybe<Scalars['String']>;\n  vehType?: Maybe<Scalars['String']>;\n  locationCode?: Maybe<Scalars['String']>;\n  extendedLocationCode?: Maybe<Scalars['String']>;\n  locationName?: Maybe<Scalars['String']>;\n  dropOffLocation?: Maybe<Scalars['String']>;\n  pickupDateTime?: Maybe<Scalars['DateTime']>;\n  dropoffDateTime?: Maybe<Scalars['DateTime']>;\n  vendor?: Maybe<Scalars['String']>;\n};\n\nexport type CarHireLocationInput = {\n  pickupCountryCode?: Maybe<Scalars['String']>;\n  pickupPostalCode?: Maybe<Scalars['String']>;\n  dropoffCountryCode?: Maybe<Scalars['String']>;\n  dropoffPostalCode?: Maybe<Scalars['String']>;\n};\n\nexport type CarHireResult = {\n  __typename?: 'CarHireResult';\n  results: Array<FieldWrapper<CarHireVehicleAvailibility>>;\n  errors: Array<FieldWrapper<SearchError>>;\n};\n\nexport enum CarHireTransmission {\n  Manual = 'Manual',\n  Auto = 'Auto'\n}\n\nexport enum CarHireType {\n  TwoToThreeDoor = 'TwoToThreeDoor',\n  TwoOrFourDoor = 'TwoOrFourDoor',\n  FourToFiveDoor = 'FourToFiveDoor',\n  WagonOrEstate = 'WagonOrEstate',\n  PassengerVan = 'PassengerVan',\n  Limousine = 'Limousine',\n  Sport = 'Sport',\n  Convertible = 'Convertible',\n  Suv = 'SUV',\n  OpenAirAllTerrain = 'OpenAirAllTerrain',\n  Special = 'Special',\n  PickUpRegularCab = 'PickUpRegularCab',\n  PickUpExtendedCab = 'PickUpExtendedCab',\n  SpecialOfferCar = 'SpecialOfferCar',\n  Coupe = 'Coupe',\n  MonospaceEuropeanUse = 'MonospaceEuropeanUse',\n  MotorHome = 'MotorHome',\n  TwoWheelVehicle = 'TwoWheelVehicle',\n  Roadster = 'Roadster'\n}\n\nexport type CarHireVehicle = {\n  __typename?: 'CarHireVehicle';\n  class?: Maybe<FieldWrapper<Scalars['String']>>;\n  type?: Maybe<FieldWrapper<Scalars['String']>>;\n  transmission?: Maybe<FieldWrapper<Scalars['String']>>;\n  aircon?: Maybe<FieldWrapper<Scalars['Boolean']>>;\n  description?: Maybe<FieldWrapper<Scalars['String']>>;\n  images?: Maybe<Array<Maybe<FieldWrapper<Scalars['String']>>>>;\n};\n\nexport type CarHireVehicleAvailibility = {\n  __typename?: 'CarHireVehicleAvailibility';\n  source: FieldWrapper<Scalars['String']>;\n  sourceId: FieldWrapper<Scalars['Int']>;\n  identifiers?: Maybe<FieldWrapper<CarHireIdentifiers>>;\n  displayRecord?: Maybe<FieldWrapper<CarHireDisplayRecord>>;\n  tmcPreferred: FieldWrapper<Scalars['Boolean']>;\n  companyPreferred: FieldWrapper<Scalars['Boolean']>;\n  officePreferred: FieldWrapper<Scalars['Boolean']>;\n  tmcPreferredMessage?: Maybe<FieldWrapper<Scalars['String']>>;\n  companyPreferredMessage?: Maybe<FieldWrapper<Scalars['String']>>;\n  officePreferredMessage?: Maybe<FieldWrapper<Scalars['String']>>;\n  unavailable: FieldWrapper<Scalars['Boolean']>;\n  unavailableMessage?: Maybe<FieldWrapper<Scalars['String']>>;\n  co2PerPassenger: FieldWrapper<Scalars['Float']>;\n  co2PerItem: FieldWrapper<Scalars['Float']>;\n};\n\nexport type CarHireVendor = {\n  __typename?: 'CarHireVendor';\n  name?: Maybe<FieldWrapper<Scalars['String']>>;\n  logo?: Maybe<FieldWrapper<Scalars['String']>>;\n};\n\nexport type CarbonAllowance = {\n  __typename?: 'CarbonAllowance';\n  id: FieldWrapper<Scalars['ID']>;\n  startOfPeriod: FieldWrapper<Scalars['DateTime']>;\n  endOfPeriod: FieldWrapper<Scalars['DateTime']>;\n  remainingCo2: FieldWrapper<Scalars['Float']>;\n  totalCo2: FieldWrapper<Scalars['Float']>;\n  carbonPolicySource: FieldWrapper<CarbonPolicySource>;\n  periodConsumption: Array<FieldWrapper<CarbonConsumption>>;\n  company?: Maybe<FieldWrapper<Company>>;\n  office?: Maybe<FieldWrapper<Office>>;\n  user: FieldWrapper<User>;\n};\n\nexport type CarbonConsumption = {\n  __typename?: 'CarbonConsumption';\n  id: FieldWrapper<Scalars['ID']>;\n  consumed: FieldWrapper<Scalars['Float']>;\n  datetime: FieldWrapper<Scalars['DateTime']>;\n};\n\nexport enum CarbonPolicySource {\n  Company = 'COMPANY',\n  Office = 'OFFICE',\n  User = 'USER'\n}\n\nexport type City = {\n  __typename?: 'City';\n  id: FieldWrapper<Scalars['ID']>;\n  name: FieldWrapper<Scalars['String']>;\n  country: FieldWrapper<Scalars['String']>;\n  countryCode: FieldWrapper<Scalars['String']>;\n  coordinates: FieldWrapper<GeoCoordinates>;\n  continentName: FieldWrapper<Scalars['String']>;\n};\n\nexport type Company = {\n  __typename?: 'Company';\n  id: FieldWrapper<Scalars['ID']>;\n  name: FieldWrapper<Scalars['String']>;\n  tmc: FieldWrapper<Tmc>;\n  offices: Array<FieldWrapper<Office>>;\n  companyGroups: Array<FieldWrapper<CompanyGroup>>;\n  addresses: Array<FieldWrapper<Address>>;\n  phoneNumbers: Array<FieldWrapper<PhoneNumber>>;\n  supportPhoneNumber?: Maybe<FieldWrapper<PhoneNumber>>;\n  createdAt: FieldWrapper<Scalars['DateTime']>;\n  updatedAt: FieldWrapper<Scalars['DateTime']>;\n  supportEmail: FieldWrapper<Scalars['String']>;\n  co2ConsumptionPolicy?: Maybe<FieldWrapper<Scalars['String']>>;\n  co2AllowancePeriod?: Maybe<FieldWrapper<Scalars['String']>>;\n  co2AllowancePerPeriod?: Maybe<FieldWrapper<Scalars['String']>>;\n};\n\nexport type CompanyGroup = {\n  __typename?: 'CompanyGroup';\n  id: FieldWrapper<Scalars['ID']>;\n  name: FieldWrapper<Scalars['String']>;\n  description: FieldWrapper<Scalars['String']>;\n  company: FieldWrapper<Company>;\n  createdAt: FieldWrapper<Scalars['DateTime']>;\n  updatedAt: FieldWrapper<Scalars['DateTime']>;\n};\n\nexport type ConfermaBlockedHotelsResult = {\n  __typename?: 'ConfermaBlockedHotelsResult';\n  results: FieldWrapper<Scalars['Boolean']>;\n  errors: Array<FieldWrapper<SearchError>>;\n};\n\nexport type ConfermaCard = {\n  __typename?: 'ConfermaCard';\n  id: FieldWrapper<Scalars['ID']>;\n  label?: Maybe<FieldWrapper<Scalars['String']>>;\n  token?: Maybe<FieldWrapper<Scalars['String']>>;\n  webInstanceId?: Maybe<FieldWrapper<Scalars['String']>>;\n  company?: Maybe<FieldWrapper<Scalars['ID']>>;\n  office?: Maybe<FieldWrapper<Scalars['ID']>>;\n  user?: Maybe<FieldWrapper<Scalars['ID']>>;\n  status: FieldWrapper<ConfermaCardStatus>;\n  expires?: Maybe<FieldWrapper<Scalars['String']>>;\n  cardHolderName?: Maybe<FieldWrapper<Scalars['String']>>;\n  cardType?: Maybe<FieldWrapper<Scalars['String']>>;\n};\n\nexport type ConfermaCardResults = {\n  __typename?: 'ConfermaCardResults';\n  id: FieldWrapper<Scalars['ID']>;\n  label?: Maybe<FieldWrapper<Scalars['String']>>;\n  token?: Maybe<FieldWrapper<Scalars['String']>>;\n  cardHolderName?: Maybe<FieldWrapper<Scalars['String']>>;\n  cardType?: Maybe<FieldWrapper<Scalars['String']>>;\n  expires?: Maybe<FieldWrapper<Scalars['Date']>>;\n  status: FieldWrapper<ConfermaCardStatus>;\n};\n\nexport enum ConfermaCardStatus {\n  Pending = 'Pending',\n  Enabled = 'Enabled',\n  Disabled = 'Disabled'\n}\n\nexport type ConfermaCityLocation = {\n  __typename?: 'ConfermaCityLocation';\n  foundExact: FieldWrapper<Scalars['Boolean']>;\n  suggestions?: Maybe<Array<Maybe<FieldWrapper<ConfermaCityLocationOptions>>>>;\n};\n\nexport type ConfermaCityLocationOptions = {\n  __typename?: 'ConfermaCityLocationOptions';\n  name: FieldWrapper<Scalars['String']>;\n  countryCode: FieldWrapper<Scalars['String']>;\n  latitude?: Maybe<FieldWrapper<Scalars['Float']>>;\n  longitude?: Maybe<FieldWrapper<Scalars['Float']>>;\n};\n\nexport type ConfermaCreateCardResult = {\n  __typename?: 'ConfermaCreateCardResult';\n  results?: Maybe<FieldWrapper<Scalars['String']>>;\n  errors: Array<FieldWrapper<SearchError>>;\n};\n\nexport type ConfermaOfficeAddress = {\n  __typename?: 'ConfermaOfficeAddress';\n  addressName?: Maybe<FieldWrapper<Scalars['String']>>;\n  addressLine1?: Maybe<FieldWrapper<Scalars['String']>>;\n  addressLine2?: Maybe<FieldWrapper<Scalars['String']>>;\n  addressLine3?: Maybe<FieldWrapper<Scalars['String']>>;\n  postalCode?: Maybe<FieldWrapper<Scalars['String']>>;\n  city?: Maybe<FieldWrapper<Scalars['String']>>;\n  countryCode?: Maybe<FieldWrapper<Scalars['String']>>;\n  countryName?: Maybe<FieldWrapper<Scalars['String']>>;\n  telephoneNumber?: Maybe<FieldWrapper<Scalars['String']>>;\n  facsimileNumber?: Maybe<FieldWrapper<Scalars['String']>>;\n  emailAddress?: Maybe<FieldWrapper<Scalars['String']>>;\n  stateProvince?: Maybe<FieldWrapper<Scalars['String']>>;\n  mobileNumber?: Maybe<FieldWrapper<Scalars['String']>>;\n};\n\nexport type ConfermaOfficeHotels = {\n  __typename?: 'ConfermaOfficeHotels';\n  hotelId?: Maybe<FieldWrapper<Scalars['Int']>>;\n  hotelName?: Maybe<FieldWrapper<Scalars['String']>>;\n  isPreferred?: Maybe<FieldWrapper<Scalars['Boolean']>>;\n};\n\nexport type ConfermaOfficeInfo = {\n  __typename?: 'ConfermaOfficeInfo';\n  id: FieldWrapper<Scalars['Int']>;\n  name?: Maybe<FieldWrapper<Scalars['String']>>;\n  address?: Maybe<FieldWrapper<ConfermaOfficeAddress>>;\n  closestAirport?: Maybe<FieldWrapper<Scalars['String']>>;\n  closestTrainStation?: Maybe<FieldWrapper<Scalars['String']>>;\n  longitude?: Maybe<FieldWrapper<Scalars['String']>>;\n  latitude?: Maybe<FieldWrapper<Scalars['String']>>;\n  closestHotels?: Maybe<Array<Maybe<FieldWrapper<ConfermaOfficeHotels>>>>;\n};\n\nexport type ConfermaOfficeNames = {\n  __typename?: 'ConfermaOfficeNames';\n  id: FieldWrapper<Scalars['Int']>;\n  name: FieldWrapper<Scalars['String']>;\n};\n\nexport type ConfermaOfficeNamesResult = {\n  __typename?: 'ConfermaOfficeNamesResult';\n  results?: Maybe<Array<Maybe<FieldWrapper<ConfermaOfficeNames>>>>;\n  errors: Array<FieldWrapper<SearchError>>;\n};\n\nexport type ConfermaOfficeResult = {\n  __typename?: 'ConfermaOfficeResult';\n  results?: Maybe<FieldWrapper<ConfermaOfficeInfo>>;\n  errors: Array<FieldWrapper<SearchError>>;\n};\n\nexport type Country = {\n  __typename?: 'Country';\n  id: FieldWrapper<Scalars['ID']>;\n  name: FieldWrapper<Scalars['String']>;\n  code: FieldWrapper<Scalars['String']>;\n  dialCode?: Maybe<FieldWrapper<Scalars['String']>>;\n};\n\nexport enum CurrencyCode {\n  Aed = 'AED',\n  Afn = 'AFN',\n  All = 'ALL',\n  Amd = 'AMD',\n  Ang = 'ANG',\n  Aoa = 'AOA',\n  Ars = 'ARS',\n  Aud = 'AUD',\n  Awg = 'AWG',\n  Azn = 'AZN',\n  Bam = 'BAM',\n  Bbd = 'BBD',\n  Bdt = 'BDT',\n  Bgn = 'BGN',\n  Bhd = 'BHD',\n  Bif = 'BIF',\n  Bmd = 'BMD',\n  Bnd = 'BND',\n  Bob = 'BOB',\n  Bov = 'BOV',\n  Brl = 'BRL',\n  Bsd = 'BSD',\n  Btn = 'BTN',\n  Bwp = 'BWP',\n  Byn = 'BYN',\n  Bzd = 'BZD',\n  Cad = 'CAD',\n  Cdf = 'CDF',\n  Che = 'CHE',\n  Chf = 'CHF',\n  Chw = 'CHW',\n  Clf = 'CLF',\n  Clp = 'CLP',\n  Cny = 'CNY',\n  Cop = 'COP',\n  Cou = 'COU',\n  Crc = 'CRC',\n  Cuc = 'CUC',\n  Cup = 'CUP',\n  Cve = 'CVE',\n  Czk = 'CZK',\n  Djf = 'DJF',\n  Dkk = 'DKK',\n  Dop = 'DOP',\n  Dzd = 'DZD',\n  Egp = 'EGP',\n  Ern = 'ERN',\n  Etb = 'ETB',\n  Eur = 'EUR',\n  Fjd = 'FJD',\n  Fkp = 'FKP',\n  Gbp = 'GBP',\n  Gel = 'GEL',\n  Ghs = 'GHS',\n  Gip = 'GIP',\n  Gmd = 'GMD',\n  Gnf = 'GNF',\n  Gtq = 'GTQ',\n  Gyd = 'GYD',\n  Hkd = 'HKD',\n  Hnl = 'HNL',\n  Hrk = 'HRK',\n  Htg = 'HTG',\n  Huf = 'HUF',\n  Idr = 'IDR',\n  Ils = 'ILS',\n  Inr = 'INR',\n  Iqd = 'IQD',\n  Irr = 'IRR',\n  Isk = 'ISK',\n  Jmd = 'JMD',\n  Jod = 'JOD',\n  Jpy = 'JPY',\n  Kes = 'KES',\n  Kgs = 'KGS',\n  Khr = 'KHR',\n  Kmf = 'KMF',\n  Kpw = 'KPW',\n  Krw = 'KRW',\n  Kwd = 'KWD',\n  Kyd = 'KYD',\n  Kzt = 'KZT',\n  Lak = 'LAK',\n  Lbp = 'LBP',\n  Lkr = 'LKR',\n  Lrd = 'LRD',\n  Lsl = 'LSL',\n  Lyd = 'LYD',\n  Mad = 'MAD',\n  Mdl = 'MDL',\n  Mga = 'MGA',\n  Mkd = 'MKD',\n  Mmk = 'MMK',\n  Mnt = 'MNT',\n  Mop = 'MOP',\n  Mru = 'MRU',\n  Mur = 'MUR',\n  Mvr = 'MVR',\n  Mwk = 'MWK',\n  Mxn = 'MXN',\n  Mxv = 'MXV',\n  Myr = 'MYR',\n  Mzn = 'MZN',\n  Nad = 'NAD',\n  Ngn = 'NGN',\n  Nio = 'NIO',\n  Nok = 'NOK',\n  Npr = 'NPR',\n  Nzd = 'NZD',\n  Omr = 'OMR',\n  Pab = 'PAB',\n  Pen = 'PEN',\n  Pgk = 'PGK',\n  Php = 'PHP',\n  Pkr = 'PKR',\n  Pln = 'PLN',\n  Pyg = 'PYG',\n  Qar = 'QAR',\n  Ron = 'RON',\n  Rsd = 'RSD',\n  Rub = 'RUB',\n  Rwf = 'RWF',\n  Sar = 'SAR',\n  Sbd = 'SBD',\n  Scr = 'SCR',\n  Sdg = 'SDG',\n  Sek = 'SEK',\n  Sgd = 'SGD',\n  Shp = 'SHP',\n  Sll = 'SLL',\n  Sos = 'SOS',\n  Srd = 'SRD',\n  Ssp = 'SSP',\n  Stn = 'STN',\n  Svc = 'SVC',\n  Syp = 'SYP',\n  Szl = 'SZL',\n  Thb = 'THB',\n  Tjs = 'TJS',\n  Tmt = 'TMT',\n  Tnd = 'TND',\n  Top = 'TOP',\n  Try = 'TRY',\n  Ttd = 'TTD',\n  Twd = 'TWD',\n  Tzs = 'TZS',\n  Uah = 'UAH',\n  Ugx = 'UGX',\n  Usd = 'USD',\n  Usn = 'USN',\n  Uyi = 'UYI',\n  Uyu = 'UYU',\n  Uzs = 'UZS',\n  Vef = 'VEF',\n  Vnd = 'VND',\n  Vuv = 'VUV',\n  Wst = 'WST',\n  Xaf = 'XAF',\n  Xag = 'XAG',\n  Xau = 'XAU',\n  Xba = 'XBA',\n  Xbb = 'XBB',\n  Xbc = 'XBC',\n  Xbd = 'XBD',\n  Xcd = 'XCD',\n  Xdr = 'XDR',\n  Xof = 'XOF',\n  Xpd = 'XPD',\n  Xpf = 'XPF',\n  Xpt = 'XPT',\n  Xsu = 'XSU',\n  Xts = 'XTS',\n  Xua = 'XUA',\n  Xxx = 'XXX',\n  Yer = 'YER',\n  Zar = 'ZAR',\n  Zmw = 'ZMW',\n  Zwl = 'ZWL'\n}\n\n\n\nexport type DestinationEntry = {\n  orig: Scalars['String'];\n  dest: Scalars['String'];\n  date: Scalars['Date'];\n};\n\nexport enum DistanceTypes {\n  K = 'K',\n  M = 'M'\n}\n\nexport type DynamicCondition = {\n  __typename?: 'DynamicCondition';\n  name?: Maybe<FieldWrapper<Scalars['String']>>;\n  description?: Maybe<FieldWrapper<Scalars['String']>>;\n};\n\nexport type FeFlightSearchResults = {\n  __typename?: 'FEFlightSearchResults';\n  journeys: Array<FieldWrapper<FlightItinerary>>;\n  multi: Array<FieldWrapper<ItinerarySummary>>;\n  grouped?: Maybe<Array<FieldWrapper<GroupFlights>>>;\n};\n\nexport type FareConditionEntry = {\n  __typename?: 'FareConditionEntry';\n  name: FieldWrapper<Scalars['String']>;\n  type: FieldWrapper<FareRuleType>;\n  currency: FieldWrapper<Scalars['String']>;\n  amount: FieldWrapper<Scalars['Float']>;\n  remark?: Maybe<FieldWrapper<Scalars['String']>>;\n  changeFeeInd: FieldWrapper<Scalars['Boolean']>;\n  cancelFeeInd: FieldWrapper<Scalars['Boolean']>;\n  refundableInd: FieldWrapper<Scalars['Boolean']>;\n};\n\nexport type FareConditions = {\n  __typename?: 'FareConditions';\n  cancellation?: Maybe<Array<Maybe<FieldWrapper<FareConditionEntry>>>>;\n  change?: Maybe<Array<Maybe<FieldWrapper<FareConditionEntry>>>>;\n  noShow?: Maybe<Array<Maybe<FieldWrapper<FareConditionEntry>>>>;\n  upgrade?: Maybe<Array<Maybe<FieldWrapper<FareConditionEntry>>>>;\n  other?: Maybe<Array<Maybe<FieldWrapper<FareConditionEntry>>>>;\n};\n\nexport enum FareRuleType {\n  Cancellation = 'Cancellation',\n  Change = 'Change',\n  NoShow = 'NoShow',\n  Upgrade = 'Upgrade',\n  Other = 'Other'\n}\n\nexport enum FareType {\n  Flexible = 'Flexible',\n  Lowest = 'Lowest',\n  Negotiated = 'Negotiated',\n  NonNegotiated = 'NonNegotiated',\n  Leisure = 'Leisure',\n  RequestFareRules = 'RequestFareRules',\n  SelectAndPro = 'SelectAndPro'\n}\n\nexport type FastTrackQuote = {\n  __typename?: 'FastTrackQuote';\n  source: FieldWrapper<Scalars['String']>;\n  sourceId: FieldWrapper<Scalars['Int']>;\n  name: FieldWrapper<Scalars['String']>;\n  code: FieldWrapper<Scalars['String']>;\n  price: FieldWrapper<Scalars['Float']>;\n  currency: FieldWrapper<Scalars['String']>;\n  refundable: FieldWrapper<Scalars['Boolean']>;\n  terminal?: Maybe<FieldWrapper<Scalars['Int']>>;\n  images: Array<FieldWrapper<Scalars['String']>>;\n  logo?: Maybe<FieldWrapper<Scalars['String']>>;\n  description?: Maybe<FieldWrapper<Scalars['String']>>;\n  importantInfo?: Maybe<FieldWrapper<Scalars['String']>>;\n  tmcPreferred: FieldWrapper<Scalars['Boolean']>;\n  companyPreferred: FieldWrapper<Scalars['Boolean']>;\n  officePreferred: FieldWrapper<Scalars['Boolean']>;\n  tmcPreferredMessage?: Maybe<FieldWrapper<Scalars['String']>>;\n  companyPreferredMessage?: Maybe<FieldWrapper<Scalars['String']>>;\n  officePreferredMessage?: Maybe<FieldWrapper<Scalars['String']>>;\n  unavailable: FieldWrapper<Scalars['Boolean']>;\n  unavailableMessage?: Maybe<FieldWrapper<Scalars['String']>>;\n  co2PerPassenger: FieldWrapper<Scalars['Float']>;\n  co2PerItem: FieldWrapper<Scalars['Float']>;\n};\n\nexport type FastTrackResult = {\n  __typename?: 'FastTrackResult';\n  results: Array<FieldWrapper<FastTrackQuote>>;\n  errors: Array<FieldWrapper<SearchError>>;\n};\n\nexport type FlightAmount = {\n  __typename?: 'FlightAmount';\n  description: FieldWrapper<Scalars['String']>;\n  amount: FieldWrapper<Scalars['Float']>;\n  currency: FieldWrapper<Scalars['String']>;\n};\n\nexport enum FlightCabinClass {\n  Any = 'Any',\n  LiteEconomy = 'LiteEconomy',\n  EconomyRestricted = 'EconomyRestricted',\n  EconomyNoBags = 'EconomyNoBags',\n  Economy = 'Economy',\n  PremiumEconomy = 'PremiumEconomy',\n  Business = 'Business',\n  PremiumBusiness = 'PremiumBusiness',\n  First = 'First',\n  PremiumFirst = 'PremiumFirst'\n}\n\nexport type FlightCarbonEmissions = {\n  __typename?: 'FlightCarbonEmissions';\n  amount?: Maybe<FieldWrapper<Scalars['Float']>>;\n  unit: FieldWrapper<Scalars['String']>;\n};\n\nexport type FlightCarrierDetail = {\n  __typename?: 'FlightCarrierDetail';\n  name?: Maybe<FieldWrapper<Scalars['String']>>;\n  alias?: Maybe<FieldWrapper<Scalars['String']>>;\n  callsign?: Maybe<FieldWrapper<Scalars['String']>>;\n  iata?: Maybe<FieldWrapper<Scalars['String']>>;\n  icao?: Maybe<FieldWrapper<Scalars['String']>>;\n  logo?: Maybe<FieldWrapper<Scalars['String']>>;\n  banner?: Maybe<FieldWrapper<Scalars['String']>>;\n  popularity?: Maybe<FieldWrapper<Scalars['Int']>>;\n};\n\nexport type FlightFareTotal = {\n  __typename?: 'FlightFareTotal';\n  price: FieldWrapper<Scalars['Float']>;\n  tax?: Maybe<FieldWrapper<Scalars['Float']>>;\n  discount?: Maybe<FieldWrapper<Scalars['Float']>>;\n  currency: FieldWrapper<CurrencyCode>;\n};\n\nexport type FlightItinerary = {\n  __typename?: 'FlightItinerary';\n  uid: FieldWrapper<Scalars['Int']>;\n  passengerCount: FieldWrapper<Scalars['Int']>;\n  outboundFlights: Array<FieldWrapper<FlightJourney>>;\n  inboundFlights?: Maybe<Array<Maybe<FieldWrapper<FlightJourney>>>>;\n  outboundTotalDuration: FieldWrapper<Scalars['Int']>;\n  outboundCarbonEmissions?: Maybe<FieldWrapper<FlightCarbonEmissions>>;\n  inboundTotalDuration?: Maybe<FieldWrapper<Scalars['Int']>>;\n  inboundCarbonEmissions?: Maybe<FieldWrapper<FlightCarbonEmissions>>;\n  taxes?: Maybe<Array<Maybe<FieldWrapper<FlightAmount>>>>;\n  discounts?: Maybe<Array<Maybe<FieldWrapper<FlightAmount>>>>;\n  total: FieldWrapper<FlightFareTotal>;\n  fareConditions?: Maybe<FieldWrapper<FareConditions>>;\n  baggageAllowance?: Maybe<Array<Maybe<FieldWrapper<BaggageAllowance>>>>;\n  additional?: Maybe<FieldWrapper<Scalars['JSON']>>;\n  source: FieldWrapper<Scalars['String']>;\n  sourceId: FieldWrapper<Scalars['Int']>;\n  version: FieldWrapper<Scalars['String']>;\n  tmcPreferred: FieldWrapper<Scalars['Boolean']>;\n  companyPreferred: FieldWrapper<Scalars['Boolean']>;\n  officePreferred: FieldWrapper<Scalars['Boolean']>;\n  tmcPreferredMessage?: Maybe<FieldWrapper<Scalars['String']>>;\n  companyPreferredMessage?: Maybe<FieldWrapper<Scalars['String']>>;\n  officePreferredMessage?: Maybe<FieldWrapper<Scalars['String']>>;\n  unavailable: FieldWrapper<Scalars['Boolean']>;\n  unavailableMessage?: Maybe<FieldWrapper<Scalars['String']>>;\n  co2PerItem: FieldWrapper<Scalars['Float']>;\n  co2PerPassenger: FieldWrapper<Scalars['Float']>;\n};\n\nexport type FlightJourney = {\n  __typename?: 'FlightJourney';\n  fareInfo?: Maybe<FieldWrapper<FlightSpecialFareInfo>>;\n  originAirport: FieldWrapper<Scalars['String']>;\n  originTerminal?: Maybe<FieldWrapper<Scalars['String']>>;\n  originAirportName?: Maybe<FieldWrapper<Scalars['String']>>;\n  originAirportDetail: FieldWrapper<AirportDetail>;\n  destinationAirport: FieldWrapper<Scalars['String']>;\n  destinationTerminal?: Maybe<FieldWrapper<Scalars['String']>>;\n  destinationAirportName?: Maybe<FieldWrapper<Scalars['String']>>;\n  destinationAirportDetail: FieldWrapper<AirportDetail>;\n  dateTimeDeparting: FieldWrapper<Scalars['String']>;\n  dateTimeDepartingUTC: FieldWrapper<Scalars['String']>;\n  dateTimeArriving: FieldWrapper<Scalars['String']>;\n  dateTimeArrivingUTC: FieldWrapper<Scalars['String']>;\n  marketingCarrier: FieldWrapper<Scalars['String']>;\n  marketingCarrierName?: Maybe<FieldWrapper<Scalars['String']>>;\n  marketingCarrierDetail: FieldWrapper<FlightCarrierDetail>;\n  marketingFlightNumber: FieldWrapper<Scalars['String']>;\n  operatingCarrier: FieldWrapper<Scalars['String']>;\n  operatingCarrierName?: Maybe<FieldWrapper<Scalars['String']>>;\n  operatingCarrierDetail: FieldWrapper<FlightCarrierDetail>;\n  operatingFlightNumber: FieldWrapper<Scalars['String']>;\n  equipmentCode: FieldWrapper<Scalars['String']>;\n  equipmentName: FieldWrapper<Scalars['String']>;\n  totalDuration: FieldWrapper<Scalars['Int']>;\n  seatsAvailable?: Maybe<FieldWrapper<Scalars['Int']>>;\n  cabinCode?: Maybe<FieldWrapper<Scalars['String']>>;\n  cabinClass?: Maybe<FieldWrapper<Scalars['String']>>;\n  marketingNames?: Maybe<Array<Maybe<FieldWrapper<Scalars['String']>>>>;\n  fareConditions: FieldWrapper<FareConditions>;\n  vendorCode?: Maybe<FieldWrapper<Scalars['String']>>;\n  stops?: Maybe<FieldWrapper<Scalars['String']>>;\n  bookingCode?: Maybe<FieldWrapper<Scalars['String']>>;\n  marriageGroup?: Maybe<FieldWrapper<Scalars['Boolean']>>;\n  fareBasisCode?: Maybe<FieldWrapper<Scalars['String']>>;\n  additional?: Maybe<FieldWrapper<Scalars['JSON']>>;\n};\n\nexport type FlightPassengerObject = {\n  type: FlightPassengerType;\n  firstName?: Maybe<Scalars['String']>;\n  middleName?: Maybe<Scalars['String']>;\n  surname?: Maybe<Scalars['String']>;\n  dob?: Maybe<Scalars['Date']>;\n};\n\nexport enum FlightPassengerType {\n  Infant = 'Infant',\n  Child = 'Child',\n  Adult = 'Adult',\n  Senior = 'Senior'\n}\n\nexport type FlightRevalidateResponse = {\n  __typename?: 'FlightRevalidateResponse';\n  valid: FieldWrapper<Scalars['Boolean']>;\n  available: FieldWrapper<Scalars['Boolean']>;\n  price?: Maybe<FieldWrapper<Scalars['Float']>>;\n  priceDifference?: Maybe<FieldWrapper<Scalars['Float']>>;\n  currency?: Maybe<FieldWrapper<Scalars['String']>>;\n};\n\nexport type FlightSearchResult = {\n  __typename?: 'FlightSearchResult';\n  results: Array<FieldWrapper<SearchResult>>;\n  errors: Array<FieldWrapper<SearchError>>;\n};\n\nexport type FlightSearchResultV2 = {\n  __typename?: 'FlightSearchResultV2';\n  results: FieldWrapper<FeFlightSearchResults>;\n  errors: Array<FieldWrapper<SearchError>>;\n};\n\nexport type FlightSpecialFareInfo = {\n  __typename?: 'FlightSpecialFareInfo';\n  title: FieldWrapper<Scalars['String']>;\n  type: FieldWrapper<Scalars['String']>;\n  code?: Maybe<FieldWrapper<Scalars['String']>>;\n  supplierCode?: Maybe<FieldWrapper<Scalars['String']>>;\n};\n\nexport type GeoCoordinates = {\n  __typename?: 'GeoCoordinates';\n  latitude?: Maybe<FieldWrapper<Scalars['Float']>>;\n  longitude?: Maybe<FieldWrapper<Scalars['Float']>>;\n  altitude?: Maybe<FieldWrapper<Scalars['Float']>>;\n};\n\nexport type GroupFlights = {\n  __typename?: 'GroupFlights';\n  referenceID: FieldWrapper<Scalars['Int']>;\n  flightID: FieldWrapper<Scalars['String']>;\n  boundIndicator: FieldWrapper<Scalars['Int']>;\n  minPrice: FieldWrapper<Scalars['Float']>;\n  maxPrice: FieldWrapper<Scalars['Float']>;\n  flights: FieldWrapper<MatchingFlights>;\n};\n\nexport type HotelAddress = {\n  __typename?: 'HotelAddress';\n  addressLine1?: Maybe<FieldWrapper<Scalars['String']>>;\n  addressLine2?: Maybe<FieldWrapper<Scalars['String']>>;\n  addressLine3?: Maybe<FieldWrapper<Scalars['String']>>;\n  postOrZipCode?: Maybe<FieldWrapper<Scalars['String']>>;\n  countryCode?: Maybe<FieldWrapper<Scalars['String']>>;\n  telephone?: Maybe<FieldWrapper<Scalars['String']>>;\n  facsimile?: Maybe<FieldWrapper<Scalars['String']>>;\n};\n\nexport type HotelAvailability = {\n  __typename?: 'HotelAvailability';\n  hotelId: FieldWrapper<Scalars['String']>;\n  imageUrl: FieldWrapper<Scalars['String']>;\n  rooms?: Maybe<Array<Maybe<FieldWrapper<HotelRoom>>>>;\n  prpn?: Maybe<FieldWrapper<Scalars['Float']>>;\n  currencyCode?: Maybe<FieldWrapper<Scalars['String']>>;\n  isBusy?: Maybe<FieldWrapper<Scalars['Boolean']>>;\n  source: FieldWrapper<Scalars['String']>;\n  version: FieldWrapper<Scalars['String']>;\n};\n\nexport type HotelAvailabilityResult = {\n  __typename?: 'HotelAvailabilityResult';\n  results?: Maybe<FieldWrapper<HotelAvailability>>;\n  errors: Array<FieldWrapper<SearchError>>;\n};\n\nexport type HotelCard = {\n  __typename?: 'HotelCard';\n  id: FieldWrapper<Scalars['String']>;\n  name: FieldWrapper<Scalars['String']>;\n};\n\nexport type HotelConversion = {\n  __typename?: 'HotelConversion';\n  rate: FieldWrapper<Scalars['Float']>;\n  localCode: FieldWrapper<Scalars['String']>;\n  localTotal: FieldWrapper<Scalars['Float']>;\n  convertedCode: FieldWrapper<Scalars['String']>;\n  convertedTotal: FieldWrapper<Scalars['Float']>;\n};\n\nexport type HotelDeposit = {\n  __typename?: 'HotelDeposit';\n  amount: FieldWrapper<Scalars['Float']>;\n  policy?: Maybe<FieldWrapper<Scalars['String']>>;\n  required: FieldWrapper<Scalars['Boolean']>;\n};\n\nexport type HotelItinerary = {\n  __typename?: 'HotelItinerary';\n  id: FieldWrapper<Scalars['String']>;\n  name: FieldWrapper<Scalars['String']>;\n  imageUrl: FieldWrapper<Scalars['String']>;\n  group: FieldWrapper<Scalars['String']>;\n  location: FieldWrapper<HotelLocation>;\n  address: FieldWrapper<HotelAddress>;\n  transports?: Maybe<Array<Maybe<FieldWrapper<HotelTransport>>>>;\n  preferred: FieldWrapper<HotelPreferred>;\n  tags?: Maybe<Array<Maybe<FieldWrapper<HotelTag>>>>;\n  availableRates?: Maybe<FieldWrapper<HotelAvailability>>;\n  co2PerPassenger: FieldWrapper<Scalars['Float']>;\n  co2PerItem: FieldWrapper<Scalars['Float']>;\n  source: FieldWrapper<Scalars['String']>;\n  sourceId: FieldWrapper<Scalars['Int']>;\n  version: FieldWrapper<Scalars['String']>;\n  tmcPreferred: FieldWrapper<Scalars['Boolean']>;\n  companyPreferred: FieldWrapper<Scalars['Boolean']>;\n  officePreferred: FieldWrapper<Scalars['Boolean']>;\n  tmcPreferredMessage?: Maybe<FieldWrapper<Scalars['String']>>;\n  companyPreferredMessage?: Maybe<FieldWrapper<Scalars['String']>>;\n  officePreferredMessage?: Maybe<FieldWrapper<Scalars['String']>>;\n  unavailable: FieldWrapper<Scalars['Boolean']>;\n  unavailableMessage?: Maybe<FieldWrapper<Scalars['String']>>;\n};\n\nexport type HotelLocation = {\n  __typename?: 'HotelLocation';\n  distance: FieldWrapper<Scalars['Float']>;\n  distanceType: FieldWrapper<Scalars['String']>;\n  longitude: FieldWrapper<Scalars['Float']>;\n  latitude: FieldWrapper<Scalars['Float']>;\n};\n\nexport type HotelMultiAvailabilityResult = {\n  __typename?: 'HotelMultiAvailabilityResult';\n  results?: Maybe<Array<Maybe<FieldWrapper<HotelAvailability>>>>;\n  errors: Array<FieldWrapper<SearchError>>;\n};\n\nexport type HotelNight = {\n  __typename?: 'HotelNight';\n  night: FieldWrapper<Scalars['Int']>;\n  rate: FieldWrapper<Scalars['Float']>;\n  info?: Maybe<FieldWrapper<Scalars['String']>>;\n  date: FieldWrapper<Scalars['Date']>;\n};\n\nexport type HotelPaymentType = {\n  __typename?: 'HotelPaymentType';\n  type: FieldWrapper<Scalars['String']>;\n  name?: Maybe<FieldWrapper<Scalars['String']>>;\n};\n\nexport type HotelPolicy = {\n  __typename?: 'HotelPolicy';\n  cancellation?: Maybe<FieldWrapper<Scalars['String']>>;\n  deposit?: Maybe<FieldWrapper<Scalars['String']>>;\n  disabledAccess?: Maybe<FieldWrapper<Scalars['Boolean']>>;\n  general?: Maybe<FieldWrapper<Scalars['String']>>;\n  guarantee?: Maybe<FieldWrapper<Scalars['String']>>;\n  refundAvailable?: Maybe<FieldWrapper<Scalars['Boolean']>>;\n};\n\nexport type HotelPreferred = {\n  __typename?: 'HotelPreferred';\n  client: FieldWrapper<Scalars['Boolean']>;\n  consumer: FieldWrapper<Scalars['Boolean']>;\n};\n\nexport type HotelRoom = {\n  __typename?: 'HotelRoom';\n  roomId: FieldWrapper<Scalars['String']>;\n  roomType?: Maybe<FieldWrapper<Scalars['String']>>;\n  roomDescription?: Maybe<FieldWrapper<Scalars['String']>>;\n  rateCode?: Maybe<FieldWrapper<Scalars['String']>>;\n  rateDescription?: Maybe<FieldWrapper<Scalars['String']>>;\n  total: FieldWrapper<Scalars['Float']>;\n  currencyCode: FieldWrapper<Scalars['String']>;\n  currencyConversion?: Maybe<FieldWrapper<HotelConversion>>;\n  deposit?: Maybe<FieldWrapper<HotelDeposit>>;\n  nights: Array<FieldWrapper<HotelNight>>;\n  policies: FieldWrapper<HotelPolicy>;\n  tax: FieldWrapper<HotelTax>;\n  acceptedCards?: Maybe<Array<Maybe<FieldWrapper<HotelCard>>>>;\n  paymentTypes?: Maybe<Array<Maybe<FieldWrapper<HotelPaymentType>>>>;\n};\n\nexport type HotelSearchResult = {\n  __typename?: 'HotelSearchResult';\n  results?: Maybe<Array<Maybe<FieldWrapper<HotelItinerary>>>>;\n  errors: Array<FieldWrapper<SearchError>>;\n};\n\nexport type HotelTag = {\n  __typename?: 'HotelTag';\n  name: FieldWrapper<Scalars['String']>;\n  display?: Maybe<FieldWrapper<Scalars['String']>>;\n  type: FieldWrapper<Scalars['String']>;\n  icon: FieldWrapper<Scalars['String']>;\n};\n\nexport type HotelTax = {\n  __typename?: 'HotelTax';\n  included: FieldWrapper<Scalars['Boolean']>;\n  rate: FieldWrapper<Scalars['Float']>;\n};\n\nexport type HotelTransport = {\n  __typename?: 'HotelTransport';\n  type: FieldWrapper<Scalars['String']>;\n  name: FieldWrapper<Scalars['String']>;\n  code?: Maybe<FieldWrapper<Scalars['String']>>;\n  distance: FieldWrapper<Scalars['Float']>;\n  distanceType: FieldWrapper<Scalars['String']>;\n  longitude?: Maybe<FieldWrapper<Scalars['Float']>>;\n  latitude?: Maybe<FieldWrapper<Scalars['Float']>>;\n};\n\nexport enum IrlClass {\n  All = 'All',\n  First = 'First',\n  Standard = 'Standard'\n}\n\nexport type IrlDynamicCondition = {\n  __typename?: 'IRLDynamicCondition';\n  name?: Maybe<FieldWrapper<Scalars['String']>>;\n  description?: Maybe<FieldWrapper<Scalars['String']>>;\n};\n\nexport type IrlIdentifiers = {\n  __typename?: 'IRLIdentifiers';\n  transactionIdentifier?: Maybe<FieldWrapper<Scalars['String']>>;\n  signature?: Maybe<FieldWrapper<Scalars['String']>>;\n  journeyIdentifier?: Maybe<FieldWrapper<Scalars['String']>>;\n  provider?: Maybe<FieldWrapper<Scalars['String']>>;\n  fareIdentifier?: Maybe<FieldWrapper<Scalars['String']>>;\n  direction?: Maybe<FieldWrapper<Scalars['String']>>;\n  allowedWith: Array<FieldWrapper<IrlIdentifiers>>;\n  singleOrReturn?: Maybe<FieldWrapper<Scalars['String']>>;\n  bookingRef?: Maybe<FieldWrapper<Scalars['String']>>;\n};\n\nexport type IrlJourneyOption = {\n  __typename?: 'IRLJourneyOption';\n  identifiers?: Maybe<FieldWrapper<IrlIdentifiers>>;\n  travellers?: Maybe<Array<FieldWrapper<IrlTraveller>>>;\n  from?: Maybe<FieldWrapper<Scalars['String']>>;\n  fromCode?: Maybe<FieldWrapper<Scalars['String']>>;\n  to?: Maybe<FieldWrapper<Scalars['String']>>;\n  toCode?: Maybe<FieldWrapper<Scalars['String']>>;\n  departDateTime?: Maybe<FieldWrapper<Scalars['DateTime']>>;\n  arriveDateTime?: Maybe<FieldWrapper<Scalars['DateTime']>>;\n  changes?: Maybe<FieldWrapper<Scalars['String']>>;\n  segments?: Maybe<Array<FieldWrapper<IrlSegment>>>;\n  providers?: Maybe<Array<FieldWrapper<IrlProvider>>>;\n  unsellable?: Maybe<FieldWrapper<Scalars['String']>>;\n  ticketExtras?: Maybe<Array<FieldWrapper<IrlTicketExtra>>>;\n  plusBus?: Maybe<FieldWrapper<IrlPlusBus>>;\n};\n\nexport type IrlJourneyOptions = {\n  __typename?: 'IRLJourneyOptions';\n  source: FieldWrapper<Scalars['String']>;\n  sourceId: FieldWrapper<Scalars['Int']>;\n  outbound?: Maybe<Array<FieldWrapper<IrlJourneyOption>>>;\n  return?: Maybe<Array<FieldWrapper<IrlJourneyOption>>>;\n};\n\nexport enum IrlJourneyType {\n  ReturnJourney = 'ReturnJourney',\n  SingleJourney = 'SingleJourney'\n}\n\nexport type IrlPlusBus = {\n  __typename?: 'IRLPlusBus';\n  originPlusBusNLC?: Maybe<FieldWrapper<Scalars['String']>>;\n  originStationNLC?: Maybe<FieldWrapper<Scalars['String']>>;\n  destinationPlusBusNLC?: Maybe<FieldWrapper<Scalars['String']>>;\n  destinationStationNLC?: Maybe<FieldWrapper<Scalars['String']>>;\n};\n\nexport type IrlProvider = {\n  __typename?: 'IRLProvider';\n  providerId?: Maybe<FieldWrapper<Scalars['String']>>;\n  name?: Maybe<FieldWrapper<Scalars['String']>>;\n  cheapestTicket?: Maybe<FieldWrapper<IrlTicketOption>>;\n  ticketOptions?: Maybe<Array<Maybe<FieldWrapper<IrlTicketOption>>>>;\n  bookedTicket?: Maybe<FieldWrapper<IrlTicketOption>>;\n};\n\nexport type IrlSearchResult = {\n  __typename?: 'IRLSearchResult';\n  results: Array<FieldWrapper<IrlJourneyOptions>>;\n  errors: Array<FieldWrapper<SearchError>>;\n};\n\nexport type IrlSeat = {\n  __typename?: 'IRLSeat';\n  location?: Maybe<FieldWrapper<Scalars['String']>>;\n  coach?: Maybe<FieldWrapper<Scalars['String']>>;\n  number?: Maybe<FieldWrapper<Scalars['String']>>;\n  direction?: Maybe<FieldWrapper<Scalars['String']>>;\n  position?: Maybe<FieldWrapper<Scalars['String']>>;\n  deck?: Maybe<FieldWrapper<Scalars['String']>>;\n  seatType?: Maybe<FieldWrapper<Scalars['String']>>;\n  seatSelection?: Maybe<FieldWrapper<Scalars['String']>>;\n  facilities?: Maybe<Array<Maybe<FieldWrapper<Scalars['String']>>>>;\n  note: FieldWrapper<Scalars['String']>;\n};\n\nexport type IrlSeatPreferenceType = {\n  __typename?: 'IRLSeatPreferenceType';\n  name?: Maybe<FieldWrapper<Scalars['String']>>;\n  allowedValues?: Maybe<Array<Maybe<FieldWrapper<Scalars['String']>>>>;\n};\n\nexport type IrlSegment = {\n  __typename?: 'IRLSegment';\n  id?: Maybe<FieldWrapper<Scalars['String']>>;\n  operator?: Maybe<FieldWrapper<Scalars['String']>>;\n  depart?: Maybe<FieldWrapper<Scalars['String']>>;\n  departDateTime?: Maybe<FieldWrapper<Scalars['DateTime']>>;\n  arrive?: Maybe<FieldWrapper<Scalars['String']>>;\n  arriveDateTime?: Maybe<FieldWrapper<Scalars['DateTime']>>;\n  reservableStatus?: Maybe<FieldWrapper<Scalars['String']>>;\n  seatPreferenceTypes?: Maybe<Array<FieldWrapper<IrlSeatPreferenceType>>>;\n  seatPreferenceGroup?: Maybe<FieldWrapper<Scalars['String']>>;\n  seats?: Maybe<Array<FieldWrapper<IrlSeat>>>;\n};\n\nexport enum IrlSupplier {\n  Renfe = 'Renfe',\n  BeNe = 'BeNe',\n  Ntv = 'Ntv'\n}\n\nexport type IrlSupplierStation = {\n  __typename?: 'IRLSupplierStation';\n  id: FieldWrapper<Scalars['ID']>;\n  name: FieldWrapper<Scalars['String']>;\n  supplier: FieldWrapper<Scalars['String']>;\n  stationCode: FieldWrapper<Scalars['String']>;\n  nlcCode?: Maybe<FieldWrapper<Scalars['Int']>>;\n  trainlineCode?: Maybe<FieldWrapper<Scalars['String']>>;\n  trainlineUniqueCode?: Maybe<FieldWrapper<Scalars['String']>>;\n  locationDetails?: Maybe<FieldWrapper<LocationDetail>>;\n};\n\nexport type IrlTextValuePair = {\n  __typename?: 'IRLTextValuePair';\n  text: FieldWrapper<Scalars['String']>;\n  value?: Maybe<FieldWrapper<Scalars['String']>>;\n};\n\nexport type IrlTicket = {\n  __typename?: 'IRLTicket';\n  price?: Maybe<FieldWrapper<Scalars['Float']>>;\n  type?: Maybe<FieldWrapper<Scalars['String']>>;\n  route?: Maybe<FieldWrapper<Scalars['String']>>;\n  segments?: Maybe<Array<FieldWrapper<IrlSegment>>>;\n  numChildren?: Maybe<FieldWrapper<Scalars['Int']>>;\n  numAdults?: Maybe<FieldWrapper<Scalars['Int']>>;\n};\n\nexport type IrlTicketExtra = {\n  __typename?: 'IRLTicketExtra';\n  identifiers?: Maybe<FieldWrapper<IrlTicketExtraIdentifiers>>;\n  type?: Maybe<FieldWrapper<Scalars['String']>>;\n  location?: Maybe<FieldWrapper<Scalars['String']>>;\n  date?: Maybe<FieldWrapper<Scalars['Date']>>;\n  description?: Maybe<FieldWrapper<Scalars['String']>>;\n  amount?: Maybe<FieldWrapper<Scalars['Float']>>;\n  adultAmount?: Maybe<FieldWrapper<Scalars['Float']>>;\n  childAmount?: Maybe<FieldWrapper<Scalars['Float']>>;\n  currency?: Maybe<FieldWrapper<Scalars['String']>>;\n};\n\nexport type IrlTicketExtraIdentifiers = {\n  __typename?: 'IRLTicketExtraIdentifiers';\n  type?: Maybe<FieldWrapper<Scalars['String']>>;\n  location?: Maybe<FieldWrapper<Scalars['String']>>;\n  date?: Maybe<FieldWrapper<Scalars['Date']>>;\n  journeyId?: Maybe<FieldWrapper<Scalars['String']>>;\n  isOrigin?: Maybe<FieldWrapper<Scalars['Boolean']>>;\n};\n\nexport type IrlTicketOption = {\n  __typename?: 'IRLTicketOption';\n  identifiers?: Maybe<FieldWrapper<IrlIdentifiers>>;\n  type?: Maybe<FieldWrapper<Scalars['String']>>;\n  class?: Maybe<FieldWrapper<Scalars['String']>>;\n  singleOrReturn?: Maybe<FieldWrapper<Scalars['String']>>;\n  price?: Maybe<FieldWrapper<Scalars['Float']>>;\n  reservableStatus?: Maybe<FieldWrapper<Scalars['String']>>;\n  currency?: Maybe<FieldWrapper<Scalars['String']>>;\n  route?: Maybe<FieldWrapper<Scalars['String']>>;\n  routeCode?: Maybe<FieldWrapper<Scalars['String']>>;\n  tickets?: Maybe<Array<Maybe<FieldWrapper<IrlTicket>>>>;\n};\n\nexport type IrlTraveller = {\n  __typename?: 'IRLTraveller';\n  status?: Maybe<FieldWrapper<IrlTravellerStatus>>;\n  id?: Maybe<FieldWrapper<Scalars['String']>>;\n  dob?: Maybe<FieldWrapper<Scalars['Date']>>;\n  railcard?: Maybe<FieldWrapper<Scalars['String']>>;\n  givenName?: Maybe<FieldWrapper<Scalars['String']>>;\n  surname?: Maybe<FieldWrapper<Scalars['String']>>;\n  nameTitle?: Maybe<FieldWrapper<Scalars['String']>>;\n  contactInfo?: Maybe<FieldWrapper<Scalars['String']>>;\n  deliveryEmailAddress?: Maybe<FieldWrapper<Scalars['String']>>;\n  fare?: Maybe<FieldWrapper<Scalars['String']>>;\n};\n\nexport enum IrlTravellerStatus {\n  Placeholder = 'placeholder',\n  Complete = 'complete'\n}\n\nexport type InputCarHireDepot = {\n  vendorCode?: Maybe<Scalars['String']>;\n  pickupLocationCode?: Maybe<Scalars['String']>;\n  pickupExtendedLocationCode?: Maybe<Scalars['String']>;\n  dropOffLocationCode?: Maybe<Scalars['String']>;\n  dropOffExtendedLocationCode?: Maybe<Scalars['String']>;\n};\n\nexport type ItinerarySummary = {\n  __typename?: 'ItinerarySummary';\n  order: FieldWrapper<Scalars['Int']>;\n  origin: FieldWrapper<Scalars['String']>;\n  destination: FieldWrapper<Scalars['String']>;\n  results: Array<FieldWrapper<FlightItinerary>>;\n  minPrice: FieldWrapper<Scalars['Float']>;\n  maxPrice: FieldWrapper<Scalars['Float']>;\n};\n\n\nexport type Language = {\n  __typename?: 'Language';\n  id: FieldWrapper<Scalars['ID']>;\n  name: FieldWrapper<Scalars['String']>;\n  isoCode: FieldWrapper<Scalars['String']>;\n};\n\nexport type LocationDetail = {\n  __typename?: 'LocationDetail';\n  continent?: Maybe<FieldWrapper<Scalars['String']>>;\n  country?: Maybe<FieldWrapper<Scalars['String']>>;\n  countryCode?: Maybe<FieldWrapper<Scalars['String']>>;\n  state?: Maybe<FieldWrapper<Scalars['String']>>;\n  city?: Maybe<FieldWrapper<Scalars['String']>>;\n  coordinates?: Maybe<FieldWrapper<GeoCoordinates>>;\n  postcode?: Maybe<FieldWrapper<Scalars['String']>>;\n  road?: Maybe<FieldWrapper<Scalars['String']>>;\n  gridReference?: Maybe<FieldWrapper<Scalars['String']>>;\n  northing?: Maybe<FieldWrapper<Scalars['String']>>;\n  easting?: Maybe<FieldWrapper<Scalars['String']>>;\n};\n\nexport type LoungeLocation = {\n  __typename?: 'LoungeLocation';\n  code: FieldWrapper<Scalars['String']>;\n  name: FieldWrapper<Scalars['String']>;\n  airport: FieldWrapper<Scalars['String']>;\n  terminal?: Maybe<FieldWrapper<Scalars['Int']>>;\n  address?: Maybe<FieldWrapper<Scalars['String']>>;\n  telephone?: Maybe<FieldWrapper<Scalars['String']>>;\n  fax?: Maybe<FieldWrapper<Scalars['String']>>;\n  directions?: Maybe<FieldWrapper<Scalars['String']>>;\n  introduction?: Maybe<FieldWrapper<Scalars['String']>>;\n  logo?: Maybe<FieldWrapper<Scalars['String']>>;\n  mobileImage?: Maybe<FieldWrapper<Scalars['String']>>;\n  furtherImages?: Maybe<Array<Maybe<FieldWrapper<Scalars['String']>>>>;\n  adultAge?: Maybe<FieldWrapper<Scalars['Int']>>;\n  childAge?: Maybe<FieldWrapper<Scalars['Int']>>;\n  infantAge?: Maybe<FieldWrapper<Scalars['Int']>>;\n  landside: FieldWrapper<Scalars['Boolean']>;\n  airside: FieldWrapper<Scalars['Boolean']>;\n  facilities?: Maybe<Array<Maybe<FieldWrapper<Scalars['String']>>>>;\n  openTime?: Maybe<FieldWrapper<Scalars['String']>>;\n  closeTime?: Maybe<FieldWrapper<Scalars['String']>>;\n  wifi?: Maybe<FieldWrapper<Scalars['Boolean']>>;\n  tv?: Maybe<FieldWrapper<Scalars['Boolean']>>;\n  snacks?: Maybe<FieldWrapper<Scalars['Boolean']>>;\n  phone?: Maybe<FieldWrapper<Scalars['Boolean']>>;\n  internet?: Maybe<FieldWrapper<Scalars['Boolean']>>;\n  childrenAllowed?: Maybe<FieldWrapper<Scalars['Boolean']>>;\n  disabledAccess?: Maybe<FieldWrapper<Scalars['Boolean']>>;\n  drinks?: Maybe<FieldWrapper<Scalars['Boolean']>>;\n  freeDrinks?: Maybe<FieldWrapper<Scalars['Boolean']>>;\n  freeFood?: Maybe<FieldWrapper<Scalars['Boolean']>>;\n  smokingPermitted?: Maybe<FieldWrapper<Scalars['Boolean']>>;\n  magazines?: Maybe<FieldWrapper<Scalars['Boolean']>>;\n  includedDrinks?: Maybe<Array<Maybe<FieldWrapper<Scalars['String']>>>>;\n  menuFood?: Maybe<FieldWrapper<Scalars['String']>>;\n  menuDrinks?: Maybe<FieldWrapper<Scalars['String']>>;\n  menuExtras?: Maybe<FieldWrapper<Scalars['String']>>;\n  whatsIncludedDrinks?: Maybe<FieldWrapper<Scalars['String']>>;\n  whatsIncludedExtras?: Maybe<FieldWrapper<Scalars['String']>>;\n  whatsIncludedFood?: Maybe<FieldWrapper<Scalars['String']>>;\n  groupInfo?: Maybe<FieldWrapper<Scalars['String']>>;\n  checkInInfo?: Maybe<FieldWrapper<Scalars['String']>>;\n  dressCode?: Maybe<FieldWrapper<Scalars['String']>>;\n  facilitiesInfo?: Maybe<FieldWrapper<Scalars['String']>>;\n  foodAndBeverage?: Maybe<FieldWrapper<Scalars['String']>>;\n  cancellationInfo?: Maybe<FieldWrapper<Scalars['String']>>;\n  amendmentsInfo?: Maybe<FieldWrapper<Scalars['String']>>;\n  misc?: Maybe<FieldWrapper<Scalars['JSON']>>;\n};\n\nexport type LoungeQuote = {\n  __typename?: 'LoungeQuote';\n  source: FieldWrapper<Scalars['String']>;\n  sourceId: FieldWrapper<Scalars['Int']>;\n  name: FieldWrapper<Scalars['String']>;\n  code: FieldWrapper<Scalars['String']>;\n  price: FieldWrapper<Scalars['Float']>;\n  currency: FieldWrapper<CurrencyCode>;\n  lounge: FieldWrapper<LoungeLocation>;\n  tmcPreferred: FieldWrapper<Scalars['Boolean']>;\n  companyPreferred: FieldWrapper<Scalars['Boolean']>;\n  officePreferred: FieldWrapper<Scalars['Boolean']>;\n  tmcPreferredMessage?: Maybe<FieldWrapper<Scalars['String']>>;\n  companyPreferredMessage?: Maybe<FieldWrapper<Scalars['String']>>;\n  officePreferredMessage?: Maybe<FieldWrapper<Scalars['String']>>;\n  unavailable: FieldWrapper<Scalars['Boolean']>;\n  unavailableMessage?: Maybe<FieldWrapper<Scalars['String']>>;\n  co2PerPassenger: FieldWrapper<Scalars['Float']>;\n  co2PerItem: FieldWrapper<Scalars['Float']>;\n};\n\nexport type LoungeSearchResult = {\n  __typename?: 'LoungeSearchResult';\n  results: Array<FieldWrapper<LoungeQuote>>;\n  errors: Array<FieldWrapper<SearchError>>;\n};\n\nexport type ManagementInfo = {\n  __typename?: 'ManagementInfo';\n  id: FieldWrapper<Scalars['ID']>;\n  dbId: FieldWrapper<Scalars['Int']>;\n  name: FieldWrapper<Scalars['String']>;\n  description?: Maybe<FieldWrapper<Scalars['String']>>;\n  handoff: FieldWrapper<Scalars['String']>;\n  valueMask?: Maybe<FieldWrapper<Scalars['String']>>;\n  service: FieldWrapper<Service>;\n  uiPresentation: FieldWrapper<UiPresentation>;\n  mandatory: FieldWrapper<Scalars['Boolean']>;\n  perPassenger: FieldWrapper<Scalars['Boolean']>;\n  perBooking: FieldWrapper<Scalars['Boolean']>;\n  agentOnly: FieldWrapper<Scalars['Boolean']>;\n  createdAt: FieldWrapper<Scalars['DateTime']>;\n  updatedAt: FieldWrapper<Scalars['DateTime']>;\n  fixed: FieldWrapper<Scalars['Boolean']>;\n  fixedValue?: Maybe<FieldWrapper<ManagementInfoValue>>;\n  defaultValue?: Maybe<FieldWrapper<ManagementInfoValue>>;\n  values: Array<FieldWrapper<ManagementInfoValue>>;\n  group?: Maybe<Array<Maybe<FieldWrapper<Scalars['String']>>>>;\n  selectedValues: Array<FieldWrapper<SelectedManagementInfoValue>>;\n};\n\nexport type ManagementInfoValue = {\n  __typename?: 'ManagementInfoValue';\n  id: FieldWrapper<Scalars['ID']>;\n  label: FieldWrapper<Scalars['String']>;\n  value: FieldWrapper<Scalars['String']>;\n  default: FieldWrapper<Scalars['Boolean']>;\n  fixed: FieldWrapper<Scalars['Boolean']>;\n  agentOnly: FieldWrapper<Scalars['Boolean']>;\n};\n\nexport type MatchingFlights = {\n  __typename?: 'MatchingFlights';\n  LiteEconomy?: Maybe<Array<Maybe<FieldWrapper<Scalars['Int']>>>>;\n  EconomyRestricted?: Maybe<Array<Maybe<FieldWrapper<Scalars['Int']>>>>;\n  EconomyNoBags?: Maybe<Array<Maybe<FieldWrapper<Scalars['Int']>>>>;\n  Economy?: Maybe<Array<Maybe<FieldWrapper<Scalars['Int']>>>>;\n  PremiumEconomy?: Maybe<Array<Maybe<FieldWrapper<Scalars['Int']>>>>;\n  Business?: Maybe<Array<Maybe<FieldWrapper<Scalars['Int']>>>>;\n  PremiumBusiness?: Maybe<Array<Maybe<FieldWrapper<Scalars['Int']>>>>;\n  First?: Maybe<Array<Maybe<FieldWrapper<Scalars['Int']>>>>;\n  PremiumFirst?: Maybe<Array<Maybe<FieldWrapper<Scalars['Int']>>>>;\n};\n\nexport type Message = {\n  __typename?: 'Message';\n  id: FieldWrapper<Scalars['ID']>;\n  name: FieldWrapper<Scalars['String']>;\n  description?: Maybe<FieldWrapper<Scalars['String']>>;\n  config: FieldWrapper<Scalars['JSON']>;\n  target: FieldWrapper<Scalars['String']>;\n  key: FieldWrapper<Scalars['String']>;\n};\n\nexport type Mutation = {\n  __typename?: 'Mutation';\n  saveUserAddress: FieldWrapper<Address>;\n  deleteUserAddress: FieldWrapper<Scalars['Boolean']>;\n  setAddressAsUserPrimary: FieldWrapper<Address>;\n  sendBasketForApproval: FieldWrapper<Basket>;\n  createBasket: FieldWrapper<Basket>;\n  deleteBasket: FieldWrapper<Scalars['Boolean']>;\n  updateBasketTitle: FieldWrapper<Basket>;\n  updateBasketNotes: FieldWrapper<Basket>;\n  addItemToBasket: FieldWrapper<Basket>;\n  removeItemFromBasket: FieldWrapper<Basket>;\n  removeItemsFromBasket: FieldWrapper<Basket>;\n  moveItemToADifferentBasket: FieldWrapper<Basket>;\n  addUsersToBasketItem: FieldWrapper<Basket>;\n  removeUserFromBasketItem: FieldWrapper<Basket>;\n  reopenBasket: FieldWrapper<Basket>;\n  setBasketItemLeadPassenger: FieldWrapper<Basket>;\n  bookBasket: FieldWrapper<Basket>;\n  cancelBooking: FieldWrapper<AfterCancellationInfo>;\n  confermaCreateCard: FieldWrapper<ConfermaCreateCardResult>;\n  confermaDeleteCard: FieldWrapper<Scalars['Boolean']>;\n  setBasketItemMIGroup: FieldWrapper<Basket>;\n  setMIDefaultValue: FieldWrapper<Scalars['Boolean']>;\n  setBasketItemMIValue: FieldWrapper<Basket>;\n  setBasketItemPaymentMethod: FieldWrapper<Basket>;\n  revalidateBasket: FieldWrapper<Basket>;\n  revalidateBasketItem: FieldWrapper<Basket>;\n  acceptNewPrice: FieldWrapper<Basket>;\n  saveFavouriteSearch: Array<FieldWrapper<Search>>;\n  saveRecentSearch: Array<FieldWrapper<Search>>;\n  deleteFavouriteSearch: FieldWrapper<Scalars['Boolean']>;\n  deleteRecentSearch: FieldWrapper<Scalars['Boolean']>;\n  setUserLanguage: FieldWrapper<User>;\n};\n\n\nexport type MutationSaveUserAddressArgs = {\n  description: Scalars['String'];\n  numberOrName?: Maybe<Scalars['String']>;\n  street?: Maybe<Scalars['String']>;\n  town?: Maybe<Scalars['String']>;\n  county?: Maybe<Scalars['String']>;\n  postcode?: Maybe<Scalars['String']>;\n  countryCode?: Maybe<Scalars['String']>;\n  userPrimary?: Maybe<Scalars['Boolean']>;\n};\n\n\nexport type MutationDeleteUserAddressArgs = {\n  id: Scalars['ID'];\n};\n\n\nexport type MutationSetAddressAsUserPrimaryArgs = {\n  id: Scalars['ID'];\n};\n\n\nexport type MutationSendBasketForApprovalArgs = {\n  basket: Scalars['ID'];\n};\n\n\nexport type MutationCreateBasketArgs = {\n  title?: Maybe<Scalars['String']>;\n};\n\n\nexport type MutationDeleteBasketArgs = {\n  id?: Maybe<Scalars['ID']>;\n  reference?: Maybe<Scalars['String']>;\n};\n\n\nexport type MutationUpdateBasketTitleArgs = {\n  id?: Maybe<Scalars['ID']>;\n  reference?: Maybe<Scalars['String']>;\n  newTitle: Scalars['String'];\n};\n\n\nexport type MutationUpdateBasketNotesArgs = {\n  id?: Maybe<Scalars['ID']>;\n  reference?: Maybe<Scalars['String']>;\n  notes: Scalars['String'];\n};\n\n\nexport type MutationAddItemToBasketArgs = {\n  basket?: Maybe<Scalars['ID']>;\n  service: Scalars['ID'];\n  detail: Scalars['JSON'];\n  adults: Scalars['Int'];\n  children?: Maybe<Scalars['Int']>;\n  infants?: Maybe<Scalars['Int']>;\n  price: Scalars['Float'];\n  currency: CurrencyCode;\n  searchQuery: Scalars['JSON'];\n  quickAdd?: Maybe<Scalars['Boolean']>;\n  users?: Maybe<Array<Maybe<UserPassengerTypeInput>>>;\n  leadPassenger?: Maybe<Scalars['ID']>;\n  co2PerItem?: Maybe<Scalars['Float']>;\n  co2PerPassenger?: Maybe<Scalars['Float']>;\n  outboundDate: Scalars['DateTime'];\n  inboundDate?: Maybe<Scalars['DateTime']>;\n};\n\n\nexport type MutationRemoveItemFromBasketArgs = {\n  basketItem: Scalars['ID'];\n};\n\n\nexport type MutationRemoveItemsFromBasketArgs = {\n  basketId: Scalars['ID'];\n  basketItems: Array<Scalars['ID']>;\n};\n\n\nexport type MutationMoveItemToADifferentBasketArgs = {\n  basketItem: Scalars['ID'];\n  newBasket: Scalars['ID'];\n};\n\n\nexport type MutationAddUsersToBasketItemArgs = {\n  basketItem: Scalars['ID'];\n  users: Array<UserPassengerTypeInput>;\n};\n\n\nexport type MutationRemoveUserFromBasketItemArgs = {\n  basketItem: Scalars['ID'];\n  user: Scalars['ID'];\n};\n\n\nexport type MutationReopenBasketArgs = {\n  id: Scalars['ID'];\n};\n\n\nexport type MutationSetBasketItemLeadPassengerArgs = {\n  id: Scalars['ID'];\n  user: Scalars['ID'];\n};\n\n\nexport type MutationBookBasketArgs = {\n  id: Scalars['ID'];\n  supplementaryInfo: Array<SupplementaryBookingInfo>;\n};\n\n\nexport type MutationCancelBookingArgs = {\n  basketItem: Scalars['ID'];\n};\n\n\nexport type MutationConfermaCreateCardArgs = {\n  label: Scalars['String'];\n};\n\n\nexport type MutationConfermaDeleteCardArgs = {\n  id: Scalars['ID'];\n};\n\n\nexport type MutationSetBasketItemMiGroupArgs = {\n  basketItem: Scalars['ID'];\n  group?: Maybe<Scalars['String']>;\n};\n\n\nexport type MutationSetMiDefaultValueArgs = {\n  mi: Scalars['ID'];\n  value: Scalars['ID'];\n};\n\n\nexport type MutationSetBasketItemMiValueArgs = {\n  mi: Scalars['ID'];\n  miValue?: Maybe<Scalars['ID']>;\n  miFreeValue?: Maybe<Scalars['String']>;\n  user?: Maybe<Scalars['ID']>;\n};\n\n\nexport type MutationSetBasketItemPaymentMethodArgs = {\n  basketItem: Scalars['ID'];\n  paymentMethod: Scalars['ID'];\n};\n\n\nexport type MutationRevalidateBasketArgs = {\n  id: Scalars['ID'];\n};\n\n\nexport type MutationRevalidateBasketItemArgs = {\n  id: Scalars['ID'];\n};\n\n\nexport type MutationAcceptNewPriceArgs = {\n  id: Scalars['ID'];\n};\n\n\nexport type MutationSaveFavouriteSearchArgs = {\n  name: Scalars['String'];\n  serviceType: ServiceType;\n  searchArgs: Scalars['JSON'];\n};\n\n\nexport type MutationSaveRecentSearchArgs = {\n  serviceType: ServiceType;\n  searchArgs: Scalars['JSON'];\n  travelDate: Scalars['DateTime'];\n  travellers?: Maybe<Array<Maybe<Scalars['ID']>>>;\n};\n\n\nexport type MutationDeleteFavouriteSearchArgs = {\n  id: Scalars['ID'];\n};\n\n\nexport type MutationDeleteRecentSearchArgs = {\n  id: Scalars['ID'];\n};\n\n\nexport type MutationSetUserLanguageArgs = {\n  language?: Maybe<Scalars['ID']>;\n};\n\nexport type Office = {\n  __typename?: 'Office';\n  id: FieldWrapper<Scalars['ID']>;\n  name: FieldWrapper<Scalars['String']>;\n  createdAt: FieldWrapper<Scalars['DateTime']>;\n  updatedAt: FieldWrapper<Scalars['DateTime']>;\n  company: FieldWrapper<Company>;\n  addresses: Array<FieldWrapper<Address>>;\n  phoneNumbers: Array<FieldWrapper<PhoneNumber>>;\n  co2AllowancePeriod?: Maybe<FieldWrapper<Scalars['String']>>;\n  co2AllowancePerPeriod?: Maybe<FieldWrapper<Scalars['String']>>;\n};\n\nexport type ParkingLocation = {\n  __typename?: 'ParkingLocation';\n  code: FieldWrapper<Scalars['String']>;\n  name: FieldWrapper<Scalars['String']>;\n  airport: FieldWrapper<Scalars['String']>;\n  terminal?: Maybe<FieldWrapper<Scalars['Int']>>;\n  latitude?: Maybe<FieldWrapper<Scalars['Float']>>;\n  longitude?: Maybe<FieldWrapper<Scalars['Float']>>;\n  address?: Maybe<FieldWrapper<Scalars['String']>>;\n  distanceToAirport?: Maybe<FieldWrapper<Scalars['Float']>>;\n  onAirport?: Maybe<FieldWrapper<Scalars['Boolean']>>;\n  carParkedForYou?: Maybe<FieldWrapper<Scalars['Boolean']>>;\n  meetAndGreet?: Maybe<FieldWrapper<Scalars['Boolean']>>;\n  telephone?: Maybe<FieldWrapper<Scalars['String']>>;\n  fax?: Maybe<FieldWrapper<Scalars['String']>>;\n  directions?: Maybe<FieldWrapper<Scalars['String']>>;\n  arrivalProcedure?: Maybe<FieldWrapper<Scalars['String']>>;\n  departureProcedure?: Maybe<FieldWrapper<Scalars['String']>>;\n  maximumCarSize?: Maybe<FieldWrapper<Scalars['String']>>;\n  introduction?: Maybe<FieldWrapper<Scalars['String']>>;\n  information?: Maybe<FieldWrapper<Scalars['String']>>;\n  transferInformation?: Maybe<FieldWrapper<Scalars['String']>>;\n  transferOperatingTimes?: Maybe<FieldWrapper<Scalars['String']>>;\n  transferTime?: Maybe<FieldWrapper<Scalars['Float']>>;\n  logo?: Maybe<FieldWrapper<Scalars['String']>>;\n  defaultImage?: Maybe<FieldWrapper<Scalars['String']>>;\n  brandImage?: Maybe<FieldWrapper<Scalars['String']>>;\n  mobileImage?: Maybe<FieldWrapper<Scalars['String']>>;\n  furtherImages?: Maybe<Array<Maybe<FieldWrapper<Scalars['String']>>>>;\n  misc?: Maybe<FieldWrapper<Scalars['JSON']>>;\n};\n\nexport type ParkingQuote = {\n  __typename?: 'ParkingQuote';\n  source: FieldWrapper<Scalars['String']>;\n  sourceId: FieldWrapper<Scalars['Int']>;\n  carPark: FieldWrapper<ParkingLocation>;\n  requiredInfo: Array<FieldWrapper<Scalars['String']>>;\n  price: FieldWrapper<Scalars['Float']>;\n  currency: FieldWrapper<CurrencyCode>;\n  misc?: Maybe<FieldWrapper<Scalars['JSON']>>;\n  tmcPreferred: FieldWrapper<Scalars['Boolean']>;\n  companyPreferred: FieldWrapper<Scalars['Boolean']>;\n  officePreferred: FieldWrapper<Scalars['Boolean']>;\n  tmcPreferredMessage?: Maybe<FieldWrapper<Scalars['String']>>;\n  companyPreferredMessage?: Maybe<FieldWrapper<Scalars['String']>>;\n  officePreferredMessage?: Maybe<FieldWrapper<Scalars['String']>>;\n  unavailable: FieldWrapper<Scalars['Boolean']>;\n  unavailableMessage?: Maybe<FieldWrapper<Scalars['String']>>;\n  co2PerPassenger: FieldWrapper<Scalars['Float']>;\n  co2PerItem: FieldWrapper<Scalars['Float']>;\n};\n\nexport type ParkingSearchResult = {\n  __typename?: 'ParkingSearchResult';\n  results: Array<FieldWrapper<ParkingQuote>>;\n  errors: Array<FieldWrapper<SearchError>>;\n};\n\nexport enum PassengerType {\n  Adult = 'ADULT',\n  Child = 'CHILD',\n  Infant = 'INFANT'\n}\n\nexport type Passport = {\n  __typename?: 'Passport';\n  id: FieldWrapper<Scalars['ID']>;\n  number: FieldWrapper<Scalars['String']>;\n  codeOfIssuingState: FieldWrapper<Scalars['String']>;\n  nationality: FieldWrapper<Scalars['String']>;\n  sex: FieldWrapper<PassportSex>;\n  dob: FieldWrapper<Scalars['DateTime']>;\n  surname: FieldWrapper<Scalars['String']>;\n  givenNames: FieldWrapper<Scalars['String']>;\n  dateOfIssue: FieldWrapper<Scalars['DateTime']>;\n  user: FieldWrapper<User>;\n  createdAt: FieldWrapper<Scalars['DateTime']>;\n  updatedAt: FieldWrapper<Scalars['DateTime']>;\n};\n\nexport enum PassportSex {\n  M = 'M',\n  F = 'F'\n}\n\nexport type PaymentConfig = {\n  cspUrl?: Maybe<Scalars['String']>;\n  agentId?: Maybe<Scalars['String']>;\n  bookerId?: Maybe<Scalars['String']>;\n  apiKey?: Maybe<Scalars['String']>;\n  password?: Maybe<Scalars['String']>;\n  server?: Maybe<Scalars['String']>;\n  consumer?: Maybe<Scalars['String']>;\n  clientId?: Maybe<Scalars['String']>;\n  accountType?: Maybe<Scalars['String']>;\n  accountValue?: Maybe<Scalars['String']>;\n  tokenUrl?: Maybe<Scalars['String']>;\n  tokenId?: Maybe<Scalars['String']>;\n  consumerId?: Maybe<Scalars['String']>;\n  tokenUsername?: Maybe<Scalars['String']>;\n  tokenPassword?: Maybe<Scalars['String']>;\n};\n\nexport type PaymentMethod = {\n  __typename?: 'PaymentMethod';\n  id: FieldWrapper<Scalars['ID']>;\n  name: FieldWrapper<Scalars['String']>;\n  description?: Maybe<FieldWrapper<Scalars['String']>>;\n};\n\nexport type PaymentMethodInput = {\n  config?: Maybe<PaymentConfig>;\n};\n\nexport type PhoneNumber = {\n  __typename?: 'PhoneNumber';\n  id: FieldWrapper<Scalars['ID']>;\n  description?: Maybe<FieldWrapper<Scalars['String']>>;\n  countryCode?: Maybe<FieldWrapper<Scalars['String']>>;\n  areaCode?: Maybe<FieldWrapper<Scalars['String']>>;\n  number?: Maybe<FieldWrapper<Scalars['String']>>;\n  extension?: Maybe<FieldWrapper<Scalars['String']>>;\n  type?: Maybe<FieldWrapper<PhoneType>>;\n  officePrimary?: Maybe<FieldWrapper<Scalars['Boolean']>>;\n  userPrimary?: Maybe<FieldWrapper<Scalars['Boolean']>>;\n};\n\nexport enum PhoneType {\n  Mobile = 'MOBILE',\n  Landline = 'LANDLINE',\n  Fax = 'FAX',\n  Other = 'OTHER'\n}\n\nexport type PostcodeDetails = {\n  __typename?: 'PostcodeDetails';\n  postcode: FieldWrapper<Scalars['String']>;\n  latitude?: Maybe<FieldWrapper<Scalars['Float']>>;\n  longitude?: Maybe<FieldWrapper<Scalars['Float']>>;\n  eastings?: Maybe<FieldWrapper<Scalars['Int']>>;\n  northings?: Maybe<FieldWrapper<Scalars['Int']>>;\n  country?: Maybe<FieldWrapper<Scalars['String']>>;\n  europeanElectoralRegion?: Maybe<FieldWrapper<Scalars['String']>>;\n  primaryCareTrust?: Maybe<FieldWrapper<Scalars['String']>>;\n  region?: Maybe<FieldWrapper<Scalars['String']>>;\n  lsoa?: Maybe<FieldWrapper<Scalars['String']>>;\n  msoa?: Maybe<FieldWrapper<Scalars['String']>>;\n  incode?: Maybe<FieldWrapper<Scalars['String']>>;\n  outcode?: Maybe<FieldWrapper<Scalars['String']>>;\n  parliamentaryConstituency?: Maybe<FieldWrapper<Scalars['String']>>;\n  adminDistrict?: Maybe<FieldWrapper<Scalars['String']>>;\n  parish?: Maybe<FieldWrapper<Scalars['String']>>;\n  adminCounty?: Maybe<FieldWrapper<Scalars['String']>>;\n  adminWard?: Maybe<FieldWrapper<Scalars['String']>>;\n  ced?: Maybe<FieldWrapper<Scalars['String']>>;\n  ccg?: Maybe<FieldWrapper<Scalars['String']>>;\n  nuts?: Maybe<FieldWrapper<Scalars['String']>>;\n};\n\nexport type Query = {\n  __typename?: 'Query';\n  getUserAddresses: Array<FieldWrapper<Address>>;\n  searchAirlines: FieldWrapper<AirlineResults>;\n  searchAirports: FieldWrapper<AirportResults>;\n  getUserBasket: FieldWrapper<Basket>;\n  getUserBaskets: Array<FieldWrapper<Basket>>;\n  searchCabHire: FieldWrapper<CabHireResult>;\n  searchUserCanBookFor: Array<FieldWrapper<User>>;\n  getCancellationInfo: FieldWrapper<BeforeCancellationInfo>;\n  searchCarHire: FieldWrapper<CarHireResult>;\n  getCarHireDepots: Array<FieldWrapper<CarHireDepot>>;\n  carHireAvailabilityDetailRequest: FieldWrapper<CarHireDetailRequestResponse>;\n  getUserCurrentCarbonAllowance?: Maybe<FieldWrapper<CarbonAllowance>>;\n  searchCities: Array<FieldWrapper<City>>;\n  confermaBlockClientHotels: FieldWrapper<ConfermaBlockedHotelsResult>;\n  confermaUnblockClientHotels: FieldWrapper<ConfermaBlockedHotelsResult>;\n  confermaBlockConsumerHotels: FieldWrapper<ConfermaBlockedHotelsResult>;\n  confermaUnblockConsumerHotels: FieldWrapper<ConfermaBlockedHotelsResult>;\n  confermaListCards: Array<FieldWrapper<ConfermaCardResults>>;\n  searchConfermaCities: FieldWrapper<ConfermaCityLocation>;\n  getConfermaOffice: FieldWrapper<ConfermaOfficeResult>;\n  getConfermaOfficeNames: FieldWrapper<ConfermaOfficeNamesResult>;\n  getConfermaQuicklist: FieldWrapper<HotelSearchResult>;\n  getCountries: Array<FieldWrapper<Country>>;\n  getCOVIDMicrositeToken: FieldWrapper<Scalars['String']>;\n  searchFastTrack: FieldWrapper<FastTrackResult>;\n  searchFlights: FieldWrapper<FlightSearchResult>;\n  searchFlightsV2: FieldWrapper<FlightSearchResultV2>;\n  searchEurostar: FieldWrapper<FlightSearchResultV2>;\n  alive: FieldWrapper<Scalars['Boolean']>;\n  getHotelChains: Array<FieldWrapper<Scalars['String']>>;\n  searchHotelChains: Array<FieldWrapper<Scalars['String']>>;\n  searchHotels: FieldWrapper<HotelSearchResult>;\n  getHotelAvailability: FieldWrapper<HotelAvailabilityResult>;\n  getMultipleHotelsAvailability: FieldWrapper<HotelMultiAvailabilityResult>;\n  getIRLSupplierStation?: Maybe<FieldWrapper<IrlSupplierStation>>;\n  searchIRLSupplierStations: Array<FieldWrapper<IrlSupplierStation>>;\n  searchIRL: FieldWrapper<IrlSearchResult>;\n  searchLounges: FieldWrapper<LoungeSearchResult>;\n  getUserMIAutoSuggestValues: Array<FieldWrapper<ManagementInfoValue>>;\n  validateUserMIFreeValue: FieldWrapper<Scalars['Boolean']>;\n  validateBasketItemMI: FieldWrapper<Scalars['Boolean']>;\n  getUserMessages: Array<FieldWrapper<Message>>;\n  getUserCompanyOffices: Array<FieldWrapper<Office>>;\n  searchParking: FieldWrapper<ParkingSearchResult>;\n  getUserPhoneNumbers: Array<FieldWrapper<PhoneNumber>>;\n  getPostcodeDetails: FieldWrapper<PostcodeDetails>;\n  postcodeAutoSuggest: Array<FieldWrapper<Scalars['String']>>;\n  searchPostcodes: Array<FieldWrapper<PostcodeDetails>>;\n  isPostcodeValid: FieldWrapper<Scalars['Boolean']>;\n  getRailStation: FieldWrapper<RailStation>;\n  searchRailStations: Array<FieldWrapper<RailStation>>;\n  searchRail: FieldWrapper<RailSearchResult>;\n  getRailcards: Array<FieldWrapper<ReferenceRailCardQualifier>>;\n  getRiskAlerts: Array<FieldWrapper<RiskAlert>>;\n  getUserTravelRules: FieldWrapper<TravelRulesCollection>;\n  getUserRecentSearches: Array<FieldWrapper<Search>>;\n  getUserFavouriteSearches: Array<FieldWrapper<Search>>;\n  getUserServices: Array<FieldWrapper<Service>>;\n  getUserUIConfigs: FieldWrapper<UiConfigCollection>;\n  getUser: FieldWrapper<User>;\n};\n\n\nexport type QuerySearchAirlinesArgs = {\n  query: Scalars['String'];\n};\n\n\nexport type QuerySearchAirportsArgs = {\n  query: Scalars['String'];\n  countryCode?: Maybe<Scalars['String']>;\n  hasLounge?: Maybe<Scalars['Boolean']>;\n  hasParking?: Maybe<Scalars['Boolean']>;\n  hasFastTrack?: Maybe<Scalars['Boolean']>;\n  excludeNonPublic?: Maybe<Scalars['Boolean']>;\n};\n\n\nexport type QueryGetUserBasketArgs = {\n  id: Scalars['ID'];\n};\n\n\nexport type QueryGetUserBasketsArgs = {\n  user?: Maybe<Scalars['ID']>;\n  traveller?: Maybe<Scalars['ID']>;\n  basketStatus?: Maybe<BasketStatus>;\n  createdAfter?: Maybe<Scalars['DateTime']>;\n  createdBefore?: Maybe<Scalars['DateTime']>;\n  bookedAfter?: Maybe<Scalars['DateTime']>;\n  bookedBefore?: Maybe<Scalars['DateTime']>;\n  dateOfTravelBefore?: Maybe<Scalars['DateTime']>;\n  dateOfTravelAfter?: Maybe<Scalars['DateTime']>;\n  basketItemBookingReference?: Maybe<Scalars['String']>;\n  basketReference?: Maybe<Scalars['String']>;\n  basketTitle?: Maybe<Scalars['String']>;\n};\n\n\nexport type QuerySearchCabHireArgs = {\n  departs: Scalars['DateTime'];\n  fromLocation: CabHireLocationInput;\n  toLocation: CabHireLocationInput;\n  adults: Scalars['Int'];\n  children?: Maybe<Scalars['Int']>;\n  infants?: Maybe<Scalars['Int']>;\n  vias?: Maybe<Array<Maybe<CabHireLocationInput>>>;\n  vehicleType?: Maybe<CabHireVehicleType>;\n};\n\n\nexport type QuerySearchUserCanBookForArgs = {\n  email?: Maybe<Scalars['String']>;\n  userName?: Maybe<Scalars['String']>;\n  employeeId?: Maybe<Scalars['String']>;\n};\n\n\nexport type QueryGetCancellationInfoArgs = {\n  basketItem: Scalars['ID'];\n};\n\n\nexport type QuerySearchCarHireArgs = {\n  airport?: Maybe<CarHireAirportInput>;\n  city?: Maybe<CarHireCityInput>;\n  location?: Maybe<CarHireLocationInput>;\n  depot?: Maybe<InputCarHireDepot>;\n  pickupDateTime: Scalars['DateTime'];\n  dropoffDateTime: Scalars['DateTime'];\n  vendor?: Maybe<Scalars['String']>;\n  class?: Maybe<CarHireClass>;\n  type?: Maybe<CarHireType>;\n  transmission?: Maybe<CarHireTransmission>;\n  aircon?: Maybe<Scalars['Boolean']>;\n  estimatedDailyDistance?: Maybe<Scalars['Float']>;\n  estimatedDailyDistanceUnits?: Maybe<DistanceTypes>;\n};\n\n\nexport type QueryGetCarHireDepotsArgs = {\n  latitude: Scalars['Float'];\n  longitude: Scalars['Float'];\n  vendorCode?: Maybe<Scalars['String']>;\n};\n\n\nexport type QueryCarHireAvailabilityDetailRequestArgs = {\n  locationDetails: CarHireInputIdentifiers;\n};\n\n\nexport type QueryGetUserCurrentCarbonAllowanceArgs = {\n  user?: Maybe<Scalars['ID']>;\n};\n\n\nexport type QuerySearchCitiesArgs = {\n  query: Scalars['String'];\n  countryCode?: Maybe<Scalars['String']>;\n};\n\n\nexport type QueryConfermaBlockClientHotelsArgs = {\n  hotelIds: Array<Scalars['String']>;\n  groupIds: Array<Scalars['String']>;\n};\n\n\nexport type QueryConfermaUnblockClientHotelsArgs = {\n  hotelIds: Array<Scalars['String']>;\n  groupIds: Array<Scalars['String']>;\n};\n\n\nexport type QueryConfermaBlockConsumerHotelsArgs = {\n  hotelIds: Array<Scalars['String']>;\n  groupIds: Array<Scalars['String']>;\n};\n\n\nexport type QueryConfermaUnblockConsumerHotelsArgs = {\n  hotelIds: Array<Scalars['String']>;\n  groupIds: Array<Scalars['String']>;\n};\n\n\nexport type QueryConfermaListCardsArgs = {\n  companyId?: Maybe<Scalars['ID']>;\n  officeId?: Maybe<Scalars['ID']>;\n};\n\n\nexport type QuerySearchConfermaCitiesArgs = {\n  cityName: Scalars['String'];\n  countryCode: Scalars['String'];\n};\n\n\nexport type QueryGetConfermaOfficeArgs = {\n  officeId: Scalars['Int'];\n};\n\n\nexport type QueryGetConfermaQuicklistArgs = {\n  countryCode: Scalars['String'];\n};\n\n\nexport type QuerySearchFastTrackArgs = {\n  arrivalDatetime: Scalars['DateTime'];\n  locationCode: Scalars['String'];\n  adults: Scalars['Int'];\n  children?: Maybe<Scalars['Int']>;\n};\n\n\nexport type QuerySearchFlightsArgs = {\n  passengers: Array<FlightPassengerObject>;\n  originAirport?: Maybe<Scalars['String']>;\n  destinationAirport?: Maybe<Scalars['String']>;\n  multiDestination?: Maybe<Array<Maybe<DestinationEntry>>>;\n  outboundDate?: Maybe<Scalars['Date']>;\n  outboundDepartureTimeWindow?: Maybe<Scalars['String']>;\n  outboundArrivalTimeWindow?: Maybe<Scalars['String']>;\n  outboundCabinClass?: Maybe<Array<Maybe<FlightCabinClass>>>;\n  returnTrip: Scalars['Boolean'];\n  returnDate?: Maybe<Scalars['Date']>;\n  returnDepartureTimeWindow?: Maybe<Scalars['String']>;\n  returnArrivalTimeWindow?: Maybe<Scalars['String']>;\n  returnCabinClass?: Maybe<Array<Maybe<FlightCabinClass>>>;\n  fareType: FareType;\n  requireFreeBag?: Maybe<Scalars['Boolean']>;\n  maxConnections?: Maybe<Scalars['Int']>;\n  preferredCarriers?: Maybe<Array<Maybe<Scalars['String']>>>;\n  includeNearbyAirports?: Maybe<Scalars['Boolean']>;\n  asSingles?: Maybe<Scalars['Boolean']>;\n};\n\n\nexport type QuerySearchFlightsV2Args = {\n  passengers: Array<FlightPassengerObject>;\n  originAirport?: Maybe<Scalars['String']>;\n  destinationAirport?: Maybe<Scalars['String']>;\n  multiDestination?: Maybe<Array<Maybe<DestinationEntry>>>;\n  outboundDate?: Maybe<Scalars['Date']>;\n  outboundDepartureTimeWindow?: Maybe<Scalars['String']>;\n  outboundArrivalTimeWindow?: Maybe<Scalars['String']>;\n  outboundCabinClass?: Maybe<Array<Maybe<FlightCabinClass>>>;\n  returnTrip: Scalars['Boolean'];\n  returnDate?: Maybe<Scalars['Date']>;\n  returnDepartureTimeWindow?: Maybe<Scalars['String']>;\n  returnArrivalTimeWindow?: Maybe<Scalars['String']>;\n  returnCabinClass?: Maybe<Array<Maybe<FlightCabinClass>>>;\n  fareType: FareType;\n  requireFreeBag?: Maybe<Scalars['Boolean']>;\n  maxConnections?: Maybe<Scalars['Int']>;\n  preferredCarriers?: Maybe<Array<Maybe<Scalars['String']>>>;\n  includeNearbyAirports?: Maybe<Scalars['Boolean']>;\n  asSingles?: Maybe<Scalars['Boolean']>;\n};\n\n\nexport type QuerySearchEurostarArgs = {\n  passengers: Array<FlightPassengerObject>;\n  originAirport?: Maybe<Scalars['String']>;\n  destinationAirport?: Maybe<Scalars['String']>;\n  multiDestination?: Maybe<Array<Maybe<DestinationEntry>>>;\n  outboundDate?: Maybe<Scalars['Date']>;\n  outboundDepartureTimeWindow?: Maybe<Scalars['String']>;\n  outboundArrivalTimeWindow?: Maybe<Scalars['String']>;\n  outboundCabinClass?: Maybe<Array<Maybe<FlightCabinClass>>>;\n  returnTrip: Scalars['Boolean'];\n  returnDate?: Maybe<Scalars['Date']>;\n  returnDepartureTimeWindow?: Maybe<Scalars['String']>;\n  returnArrivalTimeWindow?: Maybe<Scalars['String']>;\n  returnCabinClass?: Maybe<Array<Maybe<FlightCabinClass>>>;\n  fareType: FareType;\n  requireFreeBag?: Maybe<Scalars['Boolean']>;\n  maxConnections?: Maybe<Scalars['Int']>;\n  preferredCarriers?: Maybe<Array<Maybe<Scalars['String']>>>;\n  includeNearbyAirports?: Maybe<Scalars['Boolean']>;\n  asSingles?: Maybe<Scalars['Boolean']>;\n};\n\n\nexport type QuerySearchHotelChainsArgs = {\n  query: Scalars['String'];\n};\n\n\nexport type QuerySearchHotelsArgs = {\n  startDate: Scalars['Date'];\n  endDate: Scalars['Date'];\n  cityName?: Maybe<Scalars['String']>;\n  postOrZipCode?: Maybe<Scalars['String']>;\n  countryCode?: Maybe<Scalars['String']>;\n  latitude?: Maybe<Scalars['Float']>;\n  longitude?: Maybe<Scalars['Float']>;\n  trainStationCode?: Maybe<Scalars['String']>;\n  iata?: Maybe<Scalars['String']>;\n  officeId?: Maybe<Scalars['Int']>;\n  rooms: Scalars['Int'];\n  adults: Scalars['Int'];\n  children?: Maybe<Scalars['Int']>;\n  currency: Scalars['String'];\n  distanceType: DistanceTypes;\n  distance: Scalars['Int'];\n  maxResults?: Maybe<Scalars['Int']>;\n  hotelName?: Maybe<Scalars['String']>;\n  groupName?: Maybe<Scalars['String']>;\n};\n\n\nexport type QueryGetHotelAvailabilityArgs = {\n  hotel: Scalars['String'];\n  startDate: Scalars['Date'];\n  endDate: Scalars['Date'];\n  currency: Scalars['String'];\n  occupants: Scalars['Int'];\n  rooms?: Maybe<Scalars['Int']>;\n};\n\n\nexport type QueryGetMultipleHotelsAvailabilityArgs = {\n  hotel: Array<Scalars['String']>;\n  startDate: Scalars['Date'];\n  endDate: Scalars['Date'];\n  currency: Scalars['String'];\n  occupants: Scalars['Int'];\n  rooms?: Maybe<Scalars['Int']>;\n};\n\n\nexport type QueryGetIrlSupplierStationArgs = {\n  id?: Maybe<Scalars['ID']>;\n  supplier?: Maybe<IrlSupplier>;\n  code?: Maybe<Scalars['String']>;\n};\n\n\nexport type QuerySearchIrlSupplierStationsArgs = {\n  query: Scalars['String'];\n  supplier: IrlSupplier;\n};\n\n\nexport type QuerySearchIrlArgs = {\n  supplier: IrlSupplier;\n  countryCode: Scalars['String'];\n  journeyType: IrlJourneyType;\n  class?: Maybe<IrlClass>;\n  outboundDepartureDateTime: Scalars['DateTime'];\n  departureLocationId: Scalars['ID'];\n  arrivalLocationId: Scalars['ID'];\n  adults: Scalars['Int'];\n  children?: Maybe<Scalars['Int']>;\n  returnDepartureDateTime?: Maybe<Scalars['DateTime']>;\n};\n\n\nexport type QuerySearchLoungesArgs = {\n  locationCode: Scalars['String'];\n  arrivalDatetime: Scalars['DateTime'];\n  adults: Scalars['Int'];\n  children?: Maybe<Scalars['Int']>;\n  infants?: Maybe<Scalars['Int']>;\n  terminal?: Maybe<Scalars['String']>;\n};\n\n\nexport type QueryGetUserMiAutoSuggestValuesArgs = {\n  mi: Scalars['ID'];\n  partialLabel: Scalars['String'];\n};\n\n\nexport type QueryValidateUserMiFreeValueArgs = {\n  mi: Scalars['ID'];\n  freeValue: Scalars['String'];\n};\n\n\nexport type QueryValidateBasketItemMiArgs = {\n  basketItem: Scalars['ID'];\n};\n\n\nexport type QueryGetUserMessagesArgs = {\n  target?: Maybe<Scalars['String']>;\n};\n\n\nexport type QuerySearchParkingArgs = {\n  arrivalDatetime: Scalars['DateTime'];\n  departDatetime: Scalars['DateTime'];\n  locationCode: Scalars['String'];\n  outFlightNumber?: Maybe<Scalars['String']>;\n  recommended?: Maybe<Scalars['Boolean']>;\n  onAirport?: Maybe<Scalars['Boolean']>;\n  meetAndGreet?: Maybe<Scalars['Boolean']>;\n  parkAndRide?: Maybe<Scalars['Boolean']>;\n  parkAndStroll?: Maybe<Scalars['Boolean']>;\n  carParkedForYou?: Maybe<Scalars['Boolean']>;\n  terminal?: Maybe<Scalars['String']>;\n};\n\n\nexport type QueryGetPostcodeDetailsArgs = {\n  postcode: Scalars['String'];\n};\n\n\nexport type QueryPostcodeAutoSuggestArgs = {\n  postcode: Scalars['String'];\n};\n\n\nexport type QuerySearchPostcodesArgs = {\n  query: Scalars['String'];\n};\n\n\nexport type QueryIsPostcodeValidArgs = {\n  postcode: Scalars['String'];\n};\n\n\nexport type QueryGetRailStationArgs = {\n  id?: Maybe<Scalars['ID']>;\n  code?: Maybe<Scalars['String']>;\n};\n\n\nexport type QuerySearchRailStationsArgs = {\n  query: Scalars['String'];\n  countryCode?: Maybe<Scalars['String']>;\n};\n\n\nexport type QuerySearchRailArgs = {\n  countryCode: Scalars['String'];\n  journeyType: RailJourneyType;\n  class?: Maybe<RailClass>;\n  outboundArrivalDateTime?: Maybe<Scalars['DateTime']>;\n  outboundDepartureDateTime?: Maybe<Scalars['DateTime']>;\n  departureLocationId: Scalars['ID'];\n  arrivalLocationId: Scalars['ID'];\n  adults: Scalars['Int'];\n  children?: Maybe<Scalars['Int']>;\n  returnArrivalDateTime?: Maybe<Scalars['DateTime']>;\n  returnDepartureDateTime?: Maybe<Scalars['DateTime']>;\n  railCardQualifiers?: Maybe<Array<Scalars['String']>>;\n  viaLocationId?: Maybe<Scalars['ID']>;\n  extraTimeToChange?: Maybe<Scalars['Boolean']>;\n  plusBusOut?: Maybe<RailPlusBusAvail>;\n  plusBusReturn?: Maybe<RailPlusBusAvail>;\n};\n\n\nexport type QueryGetRiskAlertsArgs = {\n  minLevel?: Maybe<RiskLevel>;\n  maxLevel?: Maybe<RiskLevel>;\n  countryIsoCode?: Maybe<Scalars['String']>;\n  airport?: Maybe<Scalars['ID']>;\n  railStation?: Maybe<Scalars['ID']>;\n  airportIata?: Maybe<Scalars['String']>;\n};\n\n\nexport type QueryGetUserRecentSearchesArgs = {\n  serviceType?: Maybe<ServiceType>;\n};\n\n\nexport type QueryGetUserFavouriteSearchesArgs = {\n  serviceType?: Maybe<ServiceType>;\n};\n\n\nexport type QueryGetUserUiConfigsArgs = {\n  target?: Maybe<Scalars['String']>;\n};\n\n\nexport type QueryGetUserArgs = {\n  id?: Maybe<Scalars['ID']>;\n};\n\nexport type RailAccount = {\n  __typename?: 'RailAccount';\n  id?: Maybe<FieldWrapper<Scalars['String']>>;\n  reference?: Maybe<FieldWrapper<Scalars['String']>>;\n  description?: Maybe<FieldWrapper<Scalars['String']>>;\n  isDefault?: Maybe<FieldWrapper<Scalars['Boolean']>>;\n  type?: Maybe<FieldWrapper<Scalars['String']>>;\n};\n\nexport type RailCallingPoint = {\n  __typename?: 'RailCallingPoint';\n  stationName?: Maybe<FieldWrapper<Scalars['String']>>;\n  stationCode?: Maybe<FieldWrapper<Scalars['String']>>;\n  arrivalDateTime?: Maybe<FieldWrapper<Scalars['DateTime']>>;\n  departureDateTime?: Maybe<FieldWrapper<Scalars['DateTime']>>;\n  scheduledPlatform?: Maybe<FieldWrapper<Scalars['String']>>;\n  stationClassification?: Maybe<FieldWrapper<RailStationClassification>>;\n  stoppingPattern?: Maybe<FieldWrapper<RailStoppingPattern>>;\n};\n\nexport enum RailClass {\n  All = 'All',\n  First = 'First',\n  Standard = 'Standard'\n}\n\nexport type RailIdentifiers = {\n  __typename?: 'RailIdentifiers';\n  transactionIdentifier?: Maybe<FieldWrapper<Scalars['String']>>;\n  journeyIdentifier?: Maybe<FieldWrapper<Scalars['String']>>;\n  provider?: Maybe<FieldWrapper<Scalars['String']>>;\n  fareIdentifier?: Maybe<FieldWrapper<Scalars['String']>>;\n  direction?: Maybe<FieldWrapper<Scalars['String']>>;\n  allowedWith: Array<FieldWrapper<RailIdentifiers>>;\n  singleOrReturn?: Maybe<FieldWrapper<Scalars['String']>>;\n  bookingRef?: Maybe<FieldWrapper<Scalars['String']>>;\n};\n\nexport type RailJourneyOption = {\n  __typename?: 'RailJourneyOption';\n  identifiers?: Maybe<FieldWrapper<RailIdentifiers>>;\n  travellers?: Maybe<Array<FieldWrapper<RailTraveller>>>;\n  co2PerItem?: Maybe<FieldWrapper<Scalars['Float']>>;\n  co2PerPassenger?: Maybe<FieldWrapper<Scalars['Float']>>;\n  from?: Maybe<FieldWrapper<Scalars['String']>>;\n  fromCode?: Maybe<FieldWrapper<Scalars['String']>>;\n  to?: Maybe<FieldWrapper<Scalars['String']>>;\n  toCode?: Maybe<FieldWrapper<Scalars['String']>>;\n  departDateTime?: Maybe<FieldWrapper<Scalars['DateTime']>>;\n  arriveDateTime?: Maybe<FieldWrapper<Scalars['DateTime']>>;\n  changes?: Maybe<FieldWrapper<Scalars['String']>>;\n  segments?: Maybe<Array<FieldWrapper<RailSegment>>>;\n  providers?: Maybe<Array<FieldWrapper<RailProvider>>>;\n  unsellable?: Maybe<FieldWrapper<Scalars['String']>>;\n  ticketExtras?: Maybe<Array<FieldWrapper<RailTicketExtra>>>;\n  plusBus?: Maybe<FieldWrapper<RailPlusBus>>;\n};\n\nexport type RailJourneyOptions = {\n  __typename?: 'RailJourneyOptions';\n  source: FieldWrapper<Scalars['String']>;\n  sourceId: FieldWrapper<Scalars['Int']>;\n  outbound?: Maybe<Array<FieldWrapper<RailJourneyOption>>>;\n  return?: Maybe<Array<FieldWrapper<RailJourneyOption>>>;\n};\n\nexport enum RailJourneyType {\n  ReturnJourney = 'ReturnJourney',\n  SingleJourney = 'SingleJourney',\n  DualSingleJourney = 'DualSingleJourney',\n  OpenReturnJourney = 'OpenReturnJourney'\n}\n\nexport type RailPlusBus = {\n  __typename?: 'RailPlusBus';\n  originPlusBusNLC?: Maybe<FieldWrapper<Scalars['String']>>;\n  originStationNLC?: Maybe<FieldWrapper<Scalars['String']>>;\n  destinationPlusBusNLC?: Maybe<FieldWrapper<Scalars['String']>>;\n  destinationStationNLC?: Maybe<FieldWrapper<Scalars['String']>>;\n};\n\nexport type RailPlusBusAvail = {\n  origin?: Maybe<Scalars['Boolean']>;\n  destination?: Maybe<Scalars['Boolean']>;\n};\n\nexport type RailProvider = {\n  __typename?: 'RailProvider';\n  providerId?: Maybe<FieldWrapper<Scalars['String']>>;\n  name?: Maybe<FieldWrapper<Scalars['String']>>;\n  cheapestTicket?: Maybe<FieldWrapper<RailTicketOption>>;\n  ticketOptions?: Maybe<Array<Maybe<FieldWrapper<RailTicketOption>>>>;\n  bookedTicket?: Maybe<FieldWrapper<RailTicketOption>>;\n};\n\nexport type RailSearchResult = {\n  __typename?: 'RailSearchResult';\n  results: Array<FieldWrapper<RailJourneyOptions>>;\n  errors: Array<FieldWrapper<SearchError>>;\n};\n\nexport type RailSeat = {\n  __typename?: 'RailSeat';\n  location?: Maybe<FieldWrapper<Scalars['String']>>;\n  coach?: Maybe<FieldWrapper<Scalars['String']>>;\n  number?: Maybe<FieldWrapper<Scalars['String']>>;\n  direction?: Maybe<FieldWrapper<Scalars['String']>>;\n  position?: Maybe<FieldWrapper<Scalars['String']>>;\n  deck?: Maybe<FieldWrapper<Scalars['String']>>;\n  seatType?: Maybe<FieldWrapper<Scalars['String']>>;\n  seatSelection?: Maybe<FieldWrapper<Scalars['String']>>;\n  facilities?: Maybe<Array<Maybe<FieldWrapper<Scalars['String']>>>>;\n  note: FieldWrapper<Scalars['String']>;\n};\n\nexport type RailSeatPreferenceType = {\n  __typename?: 'RailSeatPreferenceType';\n  name?: Maybe<FieldWrapper<Scalars['String']>>;\n  allowedValues?: Maybe<Array<Maybe<FieldWrapper<Scalars['String']>>>>;\n};\n\nexport type RailSegment = {\n  __typename?: 'RailSegment';\n  id?: Maybe<FieldWrapper<Scalars['String']>>;\n  operator?: Maybe<FieldWrapper<Scalars['String']>>;\n  depart?: Maybe<FieldWrapper<Scalars['String']>>;\n  departDateTime?: Maybe<FieldWrapper<Scalars['DateTime']>>;\n  arrive?: Maybe<FieldWrapper<Scalars['String']>>;\n  arriveDateTime?: Maybe<FieldWrapper<Scalars['DateTime']>>;\n  reservableStatus?: Maybe<FieldWrapper<Scalars['String']>>;\n  seatPreferenceTypes?: Maybe<Array<FieldWrapper<RailSeatPreferenceType>>>;\n  seatPreferenceGroup?: Maybe<FieldWrapper<Scalars['String']>>;\n  seats?: Maybe<Array<FieldWrapper<RailSeat>>>;\n  callingPoints?: Maybe<Array<FieldWrapper<RailCallingPoint>>>;\n};\n\nexport type RailStation = {\n  __typename?: 'RailStation';\n  id: FieldWrapper<Scalars['ID']>;\n  name: FieldWrapper<Scalars['String']>;\n  stationCode: FieldWrapper<Scalars['String']>;\n  nlcCode?: Maybe<FieldWrapper<Scalars['Int']>>;\n  trainlineCode?: Maybe<FieldWrapper<Scalars['String']>>;\n  trainlineUniqueCode?: Maybe<FieldWrapper<Scalars['String']>>;\n  locationDetails?: Maybe<FieldWrapper<LocationDetail>>;\n};\n\nexport enum RailStationClassification {\n  Origin = 'Origin',\n  Intermediate = 'Intermediate',\n  Destination = 'Destination',\n  Unknown = 'Unknown'\n}\n\nexport enum RailStoppingPattern {\n  RequestStop = 'RequestStop',\n  PickUpOnly = 'PickUpOnly',\n  SetDownOnly = 'SetDownOnly',\n  Normal = 'Normal',\n  Passing = 'Passing',\n  Unknown = 'Unknown'\n}\n\nexport type RailTextValuePair = {\n  __typename?: 'RailTextValuePair';\n  text: FieldWrapper<Scalars['String']>;\n  value?: Maybe<FieldWrapper<Scalars['String']>>;\n};\n\nexport type RailTicket = {\n  __typename?: 'RailTicket';\n  price?: Maybe<FieldWrapper<Scalars['Float']>>;\n  type?: Maybe<FieldWrapper<Scalars['String']>>;\n  route?: Maybe<FieldWrapper<Scalars['String']>>;\n  segments?: Maybe<Array<FieldWrapper<RailSegment>>>;\n  numChildren?: Maybe<FieldWrapper<Scalars['Int']>>;\n  numAdults?: Maybe<FieldWrapper<Scalars['Int']>>;\n};\n\nexport type RailTicketExtra = {\n  __typename?: 'RailTicketExtra';\n  identifiers?: Maybe<FieldWrapper<RailTicketExtraIdentifiers>>;\n  type?: Maybe<FieldWrapper<Scalars['String']>>;\n  location?: Maybe<FieldWrapper<Scalars['String']>>;\n  date?: Maybe<FieldWrapper<Scalars['Date']>>;\n  description?: Maybe<FieldWrapper<Scalars['String']>>;\n  amount?: Maybe<FieldWrapper<Scalars['Float']>>;\n  adultAmount?: Maybe<FieldWrapper<Scalars['Float']>>;\n  childAmount?: Maybe<FieldWrapper<Scalars['Float']>>;\n  currency?: Maybe<FieldWrapper<Scalars['String']>>;\n};\n\nexport type RailTicketExtraIdentifiers = {\n  __typename?: 'RailTicketExtraIdentifiers';\n  type?: Maybe<FieldWrapper<Scalars['String']>>;\n  location?: Maybe<FieldWrapper<Scalars['String']>>;\n  date?: Maybe<FieldWrapper<Scalars['Date']>>;\n  journeyId?: Maybe<FieldWrapper<Scalars['String']>>;\n  isOrigin?: Maybe<FieldWrapper<Scalars['Boolean']>>;\n};\n\nexport type RailTicketOption = {\n  __typename?: 'RailTicketOption';\n  identifiers?: Maybe<FieldWrapper<RailIdentifiers>>;\n  type?: Maybe<FieldWrapper<Scalars['String']>>;\n  terms?: Maybe<FieldWrapper<RailTicketTerms>>;\n  class?: Maybe<FieldWrapper<Scalars['String']>>;\n  singleOrReturn?: Maybe<FieldWrapper<Scalars['String']>>;\n  price?: Maybe<FieldWrapper<Scalars['Float']>>;\n  reservableStatus?: Maybe<FieldWrapper<Scalars['String']>>;\n  currency?: Maybe<FieldWrapper<Scalars['String']>>;\n  route?: Maybe<FieldWrapper<Scalars['String']>>;\n  routeCode?: Maybe<FieldWrapper<Scalars['String']>>;\n  availableSeats?: Maybe<FieldWrapper<Scalars['Int']>>;\n  tickets?: Maybe<Array<Maybe<FieldWrapper<RailTicket>>>>;\n  ticketQueueList?: Maybe<Array<Maybe<FieldWrapper<RailTicketQueue>>>>;\n  accountsList?: Maybe<Array<Maybe<FieldWrapper<RailAccount>>>>;\n};\n\nexport type RailTicketQueue = {\n  __typename?: 'RailTicketQueue';\n  id?: Maybe<FieldWrapper<Scalars['String']>>;\n  name?: Maybe<FieldWrapper<Scalars['String']>>;\n  type?: Maybe<FieldWrapper<Scalars['String']>>;\n};\n\nexport type RailTicketTerms = {\n  __typename?: 'RailTicketTerms';\n  error?: Maybe<FieldWrapper<Scalars['String']>>;\n  ticketTypeCode?: Maybe<FieldWrapper<Scalars['String']>>;\n  trainOperatingCompanyCode?: Maybe<FieldWrapper<Scalars['String']>>;\n  ticketTypeName?: Maybe<FieldWrapper<Scalars['String']>>;\n  ticketTypeAltName?: Maybe<FieldWrapper<Scalars['String']>>;\n  ticketTypeClass?: Maybe<FieldWrapper<Scalars['String']>>;\n  reservationRule?: Maybe<FieldWrapper<Scalars['String']>>;\n  journeyType?: Maybe<FieldWrapper<Scalars['String']>>;\n  preBookingRequirement?: Maybe<FieldWrapper<Scalars['String']>>;\n  generalValidity?: Maybe<FieldWrapper<Scalars['String']>>;\n  validOutRule?: Maybe<FieldWrapper<Scalars['String']>>;\n  validReturnRule?: Maybe<FieldWrapper<Scalars['String']>>;\n  generalDiscount?: Maybe<FieldWrapper<Scalars['String']>>;\n  childDiscount?: Maybe<FieldWrapper<Scalars['String']>>;\n  railcardDiscount?: Maybe<FieldWrapper<Scalars['String']>>;\n  refundCancellationRule?: Maybe<FieldWrapper<Scalars['String']>>;\n  changeRule?: Maybe<FieldWrapper<Scalars['String']>>;\n  ticketTypeConditionsDescription?: Maybe<FieldWrapper<Scalars['String']>>;\n  journeyBreakRule?: Maybe<FieldWrapper<Scalars['String']>>;\n  availabilityRule?: Maybe<FieldWrapper<Scalars['String']>>;\n  todAvailable?: Maybe<FieldWrapper<Scalars['String']>>;\n  kioskAvailable?: Maybe<FieldWrapper<Scalars['String']>>;\n  startDate?: Maybe<FieldWrapper<Scalars['String']>>;\n  endDate?: Maybe<FieldWrapper<Scalars['String']>>;\n  dynamicConditions?: Maybe<Array<Maybe<FieldWrapper<DynamicCondition>>>>;\n};\n\nexport type RailTraveller = {\n  __typename?: 'RailTraveller';\n  status?: Maybe<FieldWrapper<RailTravellerStatus>>;\n  id?: Maybe<FieldWrapper<Scalars['String']>>;\n  dob?: Maybe<FieldWrapper<Scalars['Date']>>;\n  railcard?: Maybe<FieldWrapper<Scalars['String']>>;\n  givenName?: Maybe<FieldWrapper<Scalars['String']>>;\n  surname?: Maybe<FieldWrapper<Scalars['String']>>;\n  nameTitle?: Maybe<FieldWrapper<Scalars['String']>>;\n  contactInfo?: Maybe<FieldWrapper<Scalars['String']>>;\n  deliveryEmailAddress?: Maybe<FieldWrapper<Scalars['String']>>;\n  fare?: Maybe<FieldWrapper<Scalars['String']>>;\n};\n\nexport enum RailTravellerStatus {\n  Placeholder = 'placeholder',\n  Complete = 'complete'\n}\n\nexport type ReferenceRailCardQualifier = {\n  __typename?: 'ReferenceRailCardQualifier';\n  name: FieldWrapper<Scalars['String']>;\n  code: FieldWrapper<Scalars['String']>;\n};\n\nexport type RiskAlert = {\n  __typename?: 'RiskAlert';\n  id: FieldWrapper<Scalars['ID']>;\n  title: FieldWrapper<Scalars['String']>;\n  description: FieldWrapper<Scalars['String']>;\n  breaking: FieldWrapper<Scalars['Boolean']>;\n  risk: FieldWrapper<RiskLevel>;\n  category: FieldWrapper<Scalars['String']>;\n  country: FieldWrapper<Scalars['String']>;\n  location?: Maybe<FieldWrapper<Scalars['String']>>;\n  latitude?: Maybe<FieldWrapper<Scalars['Float']>>;\n  longitude?: Maybe<FieldWrapper<Scalars['Float']>>;\n  startDate: FieldWrapper<Scalars['DateTime']>;\n  endDate: FieldWrapper<Scalars['DateTime']>;\n  receivedDate: FieldWrapper<Scalars['DateTime']>;\n};\n\nexport enum RiskLevel {\n  Low = 'Low',\n  Moderate = 'Moderate',\n  Medium = 'Medium',\n  High = 'High',\n  Extreme = 'Extreme'\n}\n\nexport type Search = {\n  __typename?: 'Search';\n  id: FieldWrapper<Scalars['ID']>;\n  name?: Maybe<FieldWrapper<Scalars['String']>>;\n  serviceType: FieldWrapper<ServiceType>;\n  searchArgs: FieldWrapper<Scalars['JSON']>;\n  createdAt: FieldWrapper<Scalars['DateTime']>;\n  updatedAt: FieldWrapper<Scalars['DateTime']>;\n  travelDate?: Maybe<FieldWrapper<Scalars['DateTime']>>;\n  travellers?: Maybe<Array<FieldWrapper<User>>>;\n};\n\nexport type SearchError = {\n  __typename?: 'SearchError';\n  service: FieldWrapper<Service>;\n  errorMessage: FieldWrapper<Scalars['String']>;\n  errorCode: FieldWrapper<Scalars['String']>;\n};\n\nexport type SearchResult = FlightItinerary | ItinerarySummary;\n\nexport type SelectedManagementInfoValue = {\n  __typename?: 'SelectedManagementInfoValue';\n  value?: Maybe<FieldWrapper<ManagementInfoValue>>;\n  freeValue?: Maybe<FieldWrapper<Scalars['String']>>;\n  basketLevelValue: FieldWrapper<Scalars['Boolean']>;\n  userLevelValue: FieldWrapper<Scalars['Boolean']>;\n  user?: Maybe<FieldWrapper<User>>;\n};\n\nexport type Service = {\n  __typename?: 'Service';\n  id: FieldWrapper<Scalars['ID']>;\n  type: FieldWrapper<ServiceType>;\n  name: FieldWrapper<Scalars['String']>;\n  description: FieldWrapper<Scalars['String']>;\n  supplierUrl: FieldWrapper<Scalars['String']>;\n  active: FieldWrapper<Scalars['Boolean']>;\n  apiEndpointUrl: FieldWrapper<Scalars['String']>;\n  basketItemTtl: FieldWrapper<Scalars['Float']>;\n  cancellable: FieldWrapper<Scalars['Boolean']>;\n  amendable: FieldWrapper<Scalars['Boolean']>;\n  detailSchema: FieldWrapper<Scalars['JSON']>;\n  searchQuerySchema: FieldWrapper<Scalars['JSON']>;\n};\n\nexport enum ServiceType {\n  Flight = 'FLIGHT',\n  Eurostar = 'EUROSTAR',\n  InternationalRail = 'INTERNATIONAL_RAIL',\n  Rail = 'RAIL',\n  Hotel = 'HOTEL',\n  Car = 'CAR',\n  Lounge = 'LOUNGE',\n  FastTrack = 'FAST_TRACK',\n  Parking = 'PARKING',\n  Cab = 'CAB',\n  Coach = 'COACH'\n}\n\nexport type StationSearchRequestResponse = {\n  __typename?: 'StationSearchRequestResponse';\n  text: FieldWrapper<Scalars['String']>;\n  value: FieldWrapper<Scalars['String']>;\n};\n\nexport type SupplementaryBookingInfo = {\n  basketItem: Scalars['ID'];\n  userInfo: Array<UserInfo>;\n  address?: Maybe<BookingAddress>;\n  phoneNumber?: Maybe<BookingPhoneNumber>;\n  supplementaryInfo: Scalars['JSON'];\n  paymentMethodDetails: Scalars['JSON'];\n};\n\nexport type Tmc = {\n  __typename?: 'TMC';\n  id: FieldWrapper<Scalars['ID']>;\n  name: FieldWrapper<Scalars['String']>;\n};\n\nexport type TravelRule = {\n  __typename?: 'TravelRule';\n  id: FieldWrapper<Scalars['ID']>;\n  name: FieldWrapper<Scalars['String']>;\n  description: FieldWrapper<Scalars['String']>;\n  appliesTo: FieldWrapper<ServiceType>;\n  applicationStage: FieldWrapper<ApplicationStage>;\n};\n\nexport type TravelRuleAppliesTo = {\n  __typename?: 'TravelRuleAppliesTo';\n  flight?: Maybe<Array<Maybe<FieldWrapper<TravelRule>>>>;\n  rail?: Maybe<Array<Maybe<FieldWrapper<TravelRule>>>>;\n  hotel?: Maybe<Array<Maybe<FieldWrapper<TravelRule>>>>;\n  car?: Maybe<Array<Maybe<FieldWrapper<TravelRule>>>>;\n  lounge?: Maybe<Array<Maybe<FieldWrapper<TravelRule>>>>;\n  fastTrack?: Maybe<Array<Maybe<FieldWrapper<TravelRule>>>>;\n  parking?: Maybe<Array<Maybe<FieldWrapper<TravelRule>>>>;\n  cab?: Maybe<Array<Maybe<FieldWrapper<TravelRule>>>>;\n  coach?: Maybe<Array<Maybe<FieldWrapper<TravelRule>>>>;\n};\n\nexport type TravelRulesCollection = {\n  __typename?: 'TravelRulesCollection';\n  tmc: Array<FieldWrapper<TravelRule>>;\n  company: Array<FieldWrapper<TravelRule>>;\n  offices: Array<FieldWrapper<TravelRule>>;\n  companyGroups: Array<FieldWrapper<TravelRule>>;\n  user: Array<FieldWrapper<TravelRule>>;\n  all: Array<FieldWrapper<TravelRule>>;\n  appliesTo?: Maybe<FieldWrapper<TravelRuleAppliesTo>>;\n};\n\nexport type UiConfig = {\n  __typename?: 'UIConfig';\n  id: FieldWrapper<Scalars['ID']>;\n  name: FieldWrapper<Scalars['String']>;\n  target: FieldWrapper<UiConfigTarget>;\n  description?: Maybe<FieldWrapper<Scalars['String']>>;\n  config?: Maybe<FieldWrapper<Scalars['JSON']>>;\n  key: FieldWrapper<Scalars['String']>;\n};\n\nexport type UiConfigCollection = {\n  __typename?: 'UIConfigCollection';\n  tmc: Array<FieldWrapper<UiConfig>>;\n  company: Array<FieldWrapper<UiConfig>>;\n  office: Array<FieldWrapper<UiConfig>>;\n  companyGroup: Array<FieldWrapper<UiConfig>>;\n  user: Array<FieldWrapper<UiConfig>>;\n  all: Array<FieldWrapper<UiConfig>>;\n};\n\nexport enum UiConfigTarget {\n  All = 'ALL',\n  Mock = 'MOCK',\n  Lightning = 'LIGHTNING',\n  App = 'APP'\n}\n\nexport enum UiPresentation {\n  FreeText = 'FREE_TEXT',\n  AutoSuggest = 'AUTO_SUGGEST',\n  Hidden = 'HIDDEN'\n}\n\nexport type User = {\n  __typename?: 'User';\n  id: FieldWrapper<Scalars['ID']>;\n  title: FieldWrapper<Scalars['String']>;\n  forename: FieldWrapper<Scalars['String']>;\n  surname: FieldWrapper<Scalars['String']>;\n  email: FieldWrapper<Scalars['String']>;\n  username: FieldWrapper<Scalars['String']>;\n  employeeId?: Maybe<FieldWrapper<Scalars['String']>>;\n  createdAt: FieldWrapper<Scalars['DateTime']>;\n  updatedAt: FieldWrapper<Scalars['DateTime']>;\n  dob: FieldWrapper<Scalars['Date']>;\n  admin?: Maybe<FieldWrapper<Scalars['Boolean']>>;\n  tmcAdmin?: Maybe<FieldWrapper<Scalars['Boolean']>>;\n  companyAdmin?: Maybe<FieldWrapper<Scalars['Boolean']>>;\n  bookerType: FieldWrapper<BookerType>;\n  authMethods: Array<FieldWrapper<Scalars['String']>>;\n  active: FieldWrapper<Scalars['Boolean']>;\n  passwordLastUpdated?: Maybe<FieldWrapper<Scalars['DateTime']>>;\n  selectedLanguage: FieldWrapper<Language>;\n  availableLanguages: Array<FieldWrapper<Language>>;\n  passports: Array<FieldWrapper<Passport>>;\n  tmc: FieldWrapper<Tmc>;\n  company: FieldWrapper<Company>;\n  office: FieldWrapper<Office>;\n  companyGroups: Array<FieldWrapper<CompanyGroup>>;\n  addresses: Array<FieldWrapper<Address>>;\n  phoneNumbers: Array<FieldWrapper<PhoneNumber>>;\n  approvers: Array<FieldWrapper<Approver>>;\n  approverFor: Array<FieldWrapper<Approvee>>;\n  bookers: Array<FieldWrapper<User>>;\n  canBookFor: Array<FieldWrapper<User>>;\n  co2AllowancePeriod?: Maybe<FieldWrapper<Scalars['String']>>;\n  co2AllowancePerPeriod?: Maybe<FieldWrapper<Scalars['String']>>;\n};\n\nexport type UserInfo = {\n  id: Scalars['ID'];\n  address?: Maybe<BookingAddress>;\n  phoneNumber?: Maybe<BookingPhoneNumber>;\n  supplementaryInfo: Scalars['JSON'];\n};\n\nexport type UserPassengerType = {\n  __typename?: 'UserPassengerType';\n  id: FieldWrapper<Scalars['ID']>;\n  passengerType: FieldWrapper<PassengerType>;\n};\n\nexport type UserPassengerTypeInput = {\n  id: Scalars['ID'];\n  passengerType: PassengerType;\n};\n\nexport type AcceptNewPriceMutationVariables = Exact<{\n  id: Scalars['ID'];\n  withSupplemental?: Maybe<Scalars['Boolean']>;\n}>;\n\n\nexport type AcceptNewPriceMutation = (\n  { __typename?: 'Mutation' }\n  & { acceptNewPrice: (\n    { __typename?: 'Basket' }\n    & BasketFieldsFragment\n  ) }\n);\n\nexport type AddUsersToBasketItemMutationVariables = Exact<{\n  basketItem: Scalars['ID'];\n  users: Array<UserPassengerTypeInput> | UserPassengerTypeInput;\n  withSupplemental: Scalars['Boolean'];\n}>;\n\n\nexport type AddUsersToBasketItemMutation = (\n  { __typename?: 'Mutation' }\n  & { addUsersToBasketItem: (\n    { __typename?: 'Basket' }\n    & BasketFieldsFragment\n  ) }\n);\n\nexport type TravellerFieldsFragment = (\n  { __typename?: 'User' }\n  & Pick<User, 'id' | 'title' | 'forename' | 'surname' | 'email' | 'username' | 'employeeId'>\n);\n\nexport type OwnerFieldsFragment = (\n  { __typename?: 'User' }\n  & Pick<User, 'id' | 'title' | 'forename' | 'surname' | 'email'>\n);\n\nexport type BasketFieldsFragment = (\n  { __typename?: 'Basket' }\n  & Pick<Basket, 'id' | 'reference' | 'title' | 'notes' | 'createdAt' | 'updatedAt' | 'bookedAt' | 'status' | 'validated'>\n  & { owner: (\n    { __typename?: 'User' }\n    & OwnerFieldsFragment\n  ), basketItems: Array<(\n    { __typename?: 'BasketItem' }\n    & MakeOptional<Pick<BasketItem, 'id' | 'adults' | 'children' | 'infants' | 'detail' | 'detailHash' | 'createdAt' | 'updatedAt' | 'expiry' | 'expired' | 'searchQuery' | 'price' | 'currency' | 'miGroupsAvailable' | 'miGroupSelected' | 'validated' | 'latestValidation' | 'latestValidationPrice' | 'latestValidationPriceDifference' | 'latestValidationAvailable' | 'bookingThirdPartyReference' | 'pnrLocator' | 'status' | 'perItemSupplementaryBookingInfoSchema' | 'perPassengerSupplementaryBookingInfoSchema' | 'perItemAddress' | 'perItemPhoneNumber' | 'perPassengerAddress' | 'perPassengerPhoneNumber' | 'cancellable' | 'amendable' | 'co2PerItem' | 'co2PerPassenger' | 'outboundDate' | 'inboundDate'>, 'perItemSupplementaryBookingInfoSchema' | 'perPassengerSupplementaryBookingInfoSchema' | 'perItemAddress' | 'perItemPhoneNumber' | 'perPassengerAddress' | 'perPassengerPhoneNumber'>\n    & { availablePaymentMethods: Array<(\n      { __typename?: 'PaymentMethod' }\n      & Pick<PaymentMethod, 'id' | 'name' | 'description'>\n    )>, selectedPaymentMethod?: Maybe<(\n      { __typename?: 'PaymentMethod' }\n      & Pick<PaymentMethod, 'id' | 'name' | 'description'>\n    )>, service: (\n      { __typename?: 'Service' }\n      & Pick<Service, 'id' | 'type'>\n    ), users: Array<(\n      { __typename?: 'User' }\n      & TravellerFieldsFragment\n    )>, userPassengerTypes: Array<(\n      { __typename?: 'UserPassengerType' }\n      & Pick<UserPassengerType, 'id' | 'passengerType'>\n    )>, leadPassenger?: Maybe<(\n      { __typename?: 'User' }\n      & TravellerFieldsFragment\n    )>, managementInfo: Array<(\n      { __typename?: 'ManagementInfo' }\n      & Pick<ManagementInfo, 'id' | 'dbId' | 'name' | 'description' | 'handoff' | 'valueMask' | 'uiPresentation' | 'mandatory' | 'perPassenger' | 'perBooking' | 'agentOnly' | 'createdAt' | 'updatedAt' | 'fixed' | 'group'>\n      & { fixedValue?: Maybe<(\n        { __typename?: 'ManagementInfoValue' }\n        & Pick<ManagementInfoValue, 'id' | 'label' | 'value' | 'default' | 'fixed' | 'agentOnly'>\n      )>, defaultValue?: Maybe<(\n        { __typename?: 'ManagementInfoValue' }\n        & Pick<ManagementInfoValue, 'id' | 'label' | 'value' | 'default' | 'fixed' | 'agentOnly'>\n      )>, values: Array<(\n        { __typename?: 'ManagementInfoValue' }\n        & Pick<ManagementInfoValue, 'id' | 'label' | 'value' | 'default' | 'fixed' | 'agentOnly'>\n      )>, selectedValues: Array<(\n        { __typename?: 'SelectedManagementInfoValue' }\n        & Pick<SelectedManagementInfoValue, 'freeValue' | 'basketLevelValue' | 'userLevelValue'>\n        & { value?: Maybe<(\n          { __typename?: 'ManagementInfoValue' }\n          & Pick<ManagementInfoValue, 'id' | 'label' | 'value' | 'default' | 'fixed' | 'agentOnly'>\n        )>, user?: Maybe<(\n          { __typename?: 'User' }\n          & Pick<User, 'id' | 'title' | 'forename' | 'surname' | 'email' | 'username' | 'employeeId' | 'createdAt' | 'updatedAt' | 'dob' | 'admin' | 'companyAdmin' | 'bookerType' | 'authMethods' | 'active' | 'passwordLastUpdated'>\n        )> }\n      )> }\n    )> }\n  )>, companyGroup?: Maybe<(\n    { __typename?: 'CompanyGroup' }\n    & Pick<CompanyGroup, 'id' | 'name' | 'description' | 'createdAt' | 'updatedAt'>\n  )> }\n);\n\nexport type GetUserBasketsQueryVariables = Exact<{\n  user?: Maybe<Scalars['ID']>;\n  traveller?: Maybe<Scalars['ID']>;\n  basketStatus?: Maybe<BasketStatus>;\n  createdAfter?: Maybe<Scalars['DateTime']>;\n  createdBefore?: Maybe<Scalars['DateTime']>;\n  bookedAfter?: Maybe<Scalars['DateTime']>;\n  bookedBefore?: Maybe<Scalars['DateTime']>;\n  dateOfTravelBefore?: Maybe<Scalars['DateTime']>;\n  dateOfTravelAfter?: Maybe<Scalars['DateTime']>;\n  basketItemBookingReference?: Maybe<Scalars['String']>;\n  basketReference?: Maybe<Scalars['String']>;\n  basketTitle?: Maybe<Scalars['String']>;\n  withSupplemental?: Maybe<Scalars['Boolean']>;\n}>;\n\n\nexport type GetUserBasketsQuery = (\n  { __typename?: 'Query' }\n  & { getUserBaskets: Array<(\n    { __typename?: 'Basket' }\n    & BasketFieldsFragment\n  )> }\n);\n\nexport type DeleteBasketMutationVariables = Exact<{\n  id?: Maybe<Scalars['ID']>;\n  reference?: Maybe<Scalars['String']>;\n}>;\n\n\nexport type DeleteBasketMutation = (\n  { __typename?: 'Mutation' }\n  & Pick<Mutation, 'deleteBasket'>\n);\n\nexport type CreateBasketMutationVariables = Exact<{\n  title?: Maybe<Scalars['String']>;\n  withSupplemental?: Maybe<Scalars['Boolean']>;\n}>;\n\n\nexport type CreateBasketMutation = (\n  { __typename?: 'Mutation' }\n  & { createBasket: (\n    { __typename?: 'Basket' }\n    & BasketFieldsFragment\n  ) }\n);\n\nexport type RemoveItemFromBasketMutationVariables = Exact<{\n  basketItem: Scalars['ID'];\n  withSupplemental?: Maybe<Scalars['Boolean']>;\n}>;\n\n\nexport type RemoveItemFromBasketMutation = (\n  { __typename?: 'Mutation' }\n  & { removeItemFromBasket: (\n    { __typename?: 'Basket' }\n    & BasketFieldsFragment\n  ) }\n);\n\nexport type SendBasketForApprovalMutationVariables = Exact<{\n  basket: Scalars['ID'];\n  withSupplemental?: Maybe<Scalars['Boolean']>;\n}>;\n\n\nexport type SendBasketForApprovalMutation = (\n  { __typename?: 'Mutation' }\n  & { sendBasketForApproval: (\n    { __typename?: 'Basket' }\n    & BasketFieldsFragment\n  ) }\n);\n\nexport type AddItemToBasketMutationVariables = Exact<{\n  basket?: Maybe<Scalars['ID']>;\n  service: Scalars['ID'];\n  detail: Scalars['JSON'];\n  adults: Scalars['Int'];\n  children?: Maybe<Scalars['Int']>;\n  infants?: Maybe<Scalars['Int']>;\n  price: Scalars['Float'];\n  currency: CurrencyCode;\n  searchQuery: Scalars['JSON'];\n  quickAdd?: Maybe<Scalars['Boolean']>;\n  users?: Maybe<Array<Maybe<UserPassengerTypeInput>> | Maybe<UserPassengerTypeInput>>;\n  leadPassenger?: Maybe<Scalars['ID']>;\n  co2PerItem?: Maybe<Scalars['Float']>;\n  co2PerPassenger?: Maybe<Scalars['Float']>;\n  outboundDate: Scalars['DateTime'];\n  inboundDate?: Maybe<Scalars['DateTime']>;\n  withSupplemental?: Maybe<Scalars['Boolean']>;\n}>;\n\n\nexport type AddItemToBasketMutation = (\n  { __typename?: 'Mutation' }\n  & { addItemToBasket: (\n    { __typename?: 'Basket' }\n    & BasketFieldsFragment\n  ) }\n);\n\nexport type GetUserBasketQueryVariables = Exact<{\n  id: Scalars['ID'];\n  withSupplemental?: Maybe<Scalars['Boolean']>;\n}>;\n\n\nexport type GetUserBasketQuery = (\n  { __typename?: 'Query' }\n  & { getUserBasket: (\n    { __typename?: 'Basket' }\n    & BasketFieldsFragment\n  ) }\n);\n\nexport type RevalidateBasketMutationVariables = Exact<{\n  id: Scalars['ID'];\n  withSupplemental?: Maybe<Scalars['Boolean']>;\n}>;\n\n\nexport type RevalidateBasketMutation = (\n  { __typename?: 'Mutation' }\n  & { revalidateBasket: (\n    { __typename?: 'Basket' }\n    & BasketFieldsFragment\n  ) }\n);\n\nexport type BookBasketMutationVariables = Exact<{\n  id: Scalars['ID'];\n  supplementaryInfo: Array<SupplementaryBookingInfo> | SupplementaryBookingInfo;\n  withSupplemental?: Maybe<Scalars['Boolean']>;\n}>;\n\n\nexport type BookBasketMutation = (\n  { __typename?: 'Mutation' }\n  & { bookBasket: (\n    { __typename?: 'Basket' }\n    & BasketFieldsFragment\n  ) }\n);\n\nexport type SearchCabHireQueryVariables = Exact<{\n  departs: Scalars['DateTime'];\n  fromLocation: CabHireLocationInput;\n  toLocation: CabHireLocationInput;\n  adults: Scalars['Int'];\n  children?: Maybe<Scalars['Int']>;\n  infants?: Maybe<Scalars['Int']>;\n  vias?: Maybe<Array<Maybe<CabHireLocationInput>> | Maybe<CabHireLocationInput>>;\n  vehicleType?: Maybe<CabHireVehicleType>;\n}>;\n\n\nexport type SearchCabHireQuery = (\n  { __typename?: 'Query' }\n  & { searchCabHire: (\n    { __typename?: 'CabHireResult' }\n    & { results: Array<(\n      { __typename?: 'CabHireQuote' }\n      & Pick<CabHireQuote, 'id' | 'source' | 'sourceId' | 'supplierName' | 'estimatedCO2' | 'co2PerItem' | 'co2PerPassenger' | 'price' | 'currency' | 'vehicleType' | 'tripDistanceMetres' | 'tripDurationSeconds' | 'departs' | 'tmcPreferred' | 'companyPreferred' | 'officePreferred' | 'tmcPreferredMessage' | 'companyPreferredMessage' | 'officePreferredMessage' | 'unavailable' | 'unavailableMessage'>\n      & { fromLocation: (\n        { __typename?: 'CabHireLocation' }\n        & Pick<CabHireLocation, 'address' | 'postcode' | 'latitude' | 'longitude'>\n      ), toLocation: (\n        { __typename?: 'CabHireLocation' }\n        & Pick<CabHireLocation, 'address' | 'postcode' | 'latitude' | 'longitude'>\n      ), vias: Array<(\n        { __typename?: 'CabHireLocation' }\n        & Pick<CabHireLocation, 'address' | 'postcode' | 'latitude' | 'longitude'>\n      )> }\n    )>, errors: Array<(\n      { __typename?: 'SearchError' }\n      & ErrorsFragment\n    )> }\n  ) }\n);\n\nexport type CarHireAvailabilityDetailRequestQueryVariables = Exact<{\n  locationDetails: CarHireInputIdentifiers;\n}>;\n\n\nexport type CarHireAvailabilityDetailRequestQuery = (\n  { __typename?: 'Query' }\n  & { carHireAvailabilityDetailRequest: (\n    { __typename?: 'CarHireDetailRequestResponse' }\n    & { identifiers?: Maybe<(\n      { __typename?: 'CarHireIdentifiers' }\n      & Pick<CarHireIdentifiers, 'locator' | 'rph' | 'status' | 'vehType' | 'locationCode' | 'extendedLocationCode' | 'locationName' | 'dropOffLocation' | 'pickupDateTime' | 'dropoffDateTime' | 'vendor'>\n    )>, vendor?: Maybe<(\n      { __typename?: 'CarHireVendor' }\n      & Pick<CarHireVendor, 'name' | 'logo'>\n    )>, address?: Maybe<(\n      { __typename?: 'CarHireAddress' }\n      & Pick<CarHireAddress, 'name' | 'topLine' | 'city' | 'region' | 'postCode' | 'country' | 'countryCode' | 'stateCode' | 'latitude' | 'longitude'>\n    )>, additionalInfo?: Maybe<Array<(\n      { __typename?: 'CarHireAdditionalInfoItem' }\n      & Pick<CarHireAdditionalInfoItem, 'name' | 'text' | 'json'>\n      & { custom?: Maybe<Array<Maybe<(\n        { __typename?: 'CarHireCustom' }\n        & Pick<CarHireCustom, 'name' | 'text'>\n      )>>> }\n    )>> }\n  ) }\n);\n\nexport type SearchCarHireQueryVariables = Exact<{\n  airport?: Maybe<CarHireAirportInput>;\n  city?: Maybe<CarHireCityInput>;\n  location?: Maybe<CarHireLocationInput>;\n  depot?: Maybe<InputCarHireDepot>;\n  pickupDateTime: Scalars['DateTime'];\n  dropoffDateTime: Scalars['DateTime'];\n  vendor?: Maybe<Scalars['String']>;\n  class?: Maybe<CarHireClass>;\n  type?: Maybe<CarHireType>;\n  transmission?: Maybe<CarHireTransmission>;\n  aircon?: Maybe<Scalars['Boolean']>;\n  estimatedDailyDistance?: Maybe<Scalars['Float']>;\n  estimatedDailyDistanceUnits?: Maybe<DistanceTypes>;\n}>;\n\n\nexport type SearchCarHireQuery = (\n  { __typename?: 'Query' }\n  & { searchCarHire: (\n    { __typename?: 'CarHireResult' }\n    & { results: Array<(\n      { __typename?: 'CarHireVehicleAvailibility' }\n      & Pick<CarHireVehicleAvailibility, 'source' | 'sourceId' | 'tmcPreferred' | 'companyPreferred' | 'officePreferred' | 'tmcPreferredMessage' | 'companyPreferredMessage' | 'officePreferredMessage' | 'unavailable' | 'unavailableMessage' | 'co2PerPassenger' | 'co2PerItem'>\n      & { identifiers?: Maybe<(\n        { __typename?: 'CarHireIdentifiers' }\n        & Pick<CarHireIdentifiers, 'locator' | 'rph' | 'status' | 'vehType' | 'locationCode' | 'extendedLocationCode' | 'locationName' | 'dropOffLocation' | 'pickupDateTime' | 'dropoffDateTime' | 'vendor'>\n      )>, displayRecord?: Maybe<(\n        { __typename?: 'CarHireDisplayRecord' }\n        & Pick<CarHireDisplayRecord, 'status' | 'pickup' | 'dropoff'>\n        & { vendor?: Maybe<(\n          { __typename?: 'CarHireVendor' }\n          & Pick<CarHireVendor, 'name' | 'logo'>\n        )>, vehicle?: Maybe<(\n          { __typename?: 'CarHireVehicle' }\n          & Pick<CarHireVehicle, 'class' | 'type' | 'transmission' | 'aircon' | 'description' | 'images'>\n        )>, charges?: Maybe<Array<Maybe<(\n          { __typename?: 'CarHireCharge' }\n          & Pick<CarHireCharge, 'label' | 'amount' | 'currencyCode'>\n        )>>>, pickupLocation?: Maybe<(\n          { __typename?: 'CarHireAddress' }\n          & Pick<CarHireAddress, 'name' | 'topLine' | 'city' | 'region' | 'postCode' | 'country' | 'countryCode' | 'stateCode' | 'latitude' | 'longitude'>\n        )>, returnLocation?: Maybe<(\n          { __typename?: 'CarHireAddress' }\n          & Pick<CarHireAddress, 'name' | 'topLine' | 'city' | 'region' | 'postCode' | 'country' | 'countryCode' | 'stateCode' | 'latitude' | 'longitude'>\n        )>, additionalInfo?: Maybe<Array<Maybe<(\n          { __typename?: 'CarHireAdditionalInfoItem' }\n          & Pick<CarHireAdditionalInfoItem, 'name' | 'text' | 'json'>\n          & { custom?: Maybe<Array<Maybe<(\n            { __typename?: 'CarHireCustom' }\n            & Pick<CarHireCustom, 'name' | 'text'>\n          )>>> }\n        )>>> }\n      )> }\n    )>, errors: Array<(\n      { __typename?: 'SearchError' }\n      & ErrorsFragment\n    )> }\n  ) }\n);\n\nexport type DeleteRecentSearchMutationVariables = Exact<{\n  id: Scalars['ID'];\n}>;\n\n\nexport type DeleteRecentSearchMutation = (\n  { __typename?: 'Mutation' }\n  & Pick<Mutation, 'deleteRecentSearch'>\n);\n\nexport type DeleteUserAddressMutationVariables = Exact<{\n  id: Scalars['ID'];\n}>;\n\n\nexport type DeleteUserAddressMutation = (\n  { __typename?: 'Mutation' }\n  & Pick<Mutation, 'deleteUserAddress'>\n);\n\nexport type ErrorsFragment = (\n  { __typename?: 'SearchError' }\n  & Pick<SearchError, 'errorMessage' | 'errorCode'>\n  & { service: (\n    { __typename?: 'Service' }\n    & Pick<Service, 'id' | 'type' | 'name' | 'description'>\n  ) }\n);\n\nexport type GroupedFieldsFragment = (\n  { __typename?: 'GroupFlights' }\n  & Pick<GroupFlights, 'referenceID' | 'flightID' | 'boundIndicator' | 'minPrice' | 'maxPrice'>\n  & { flights: (\n    { __typename?: 'MatchingFlights' }\n    & Pick<MatchingFlights, 'LiteEconomy' | 'EconomyRestricted' | 'EconomyNoBags' | 'Economy' | 'PremiumEconomy' | 'Business' | 'PremiumBusiness' | 'First' | 'PremiumFirst'>\n  ) }\n);\n\nexport type SearchFlightsV2QueryVariables = Exact<{\n  passengers: Array<FlightPassengerObject> | FlightPassengerObject;\n  originAirport?: Maybe<Scalars['String']>;\n  destinationAirport?: Maybe<Scalars['String']>;\n  multiDestination?: Maybe<Array<Maybe<DestinationEntry>> | Maybe<DestinationEntry>>;\n  outboundDate?: Maybe<Scalars['Date']>;\n  outboundDepartureTimeWindow?: Maybe<Scalars['String']>;\n  outboundArrivalTimeWindow?: Maybe<Scalars['String']>;\n  outboundCabinClass?: Maybe<Array<Maybe<FlightCabinClass>> | Maybe<FlightCabinClass>>;\n  returnTrip: Scalars['Boolean'];\n  returnDate?: Maybe<Scalars['Date']>;\n  returnDepartureTimeWindow?: Maybe<Scalars['String']>;\n  returnArrivalTimeWindow?: Maybe<Scalars['String']>;\n  returnCabinClass?: Maybe<Array<Maybe<FlightCabinClass>> | Maybe<FlightCabinClass>>;\n  fareType: FareType;\n  requireFreeBag?: Maybe<Scalars['Boolean']>;\n  maxConnections?: Maybe<Scalars['Int']>;\n  preferredCarriers?: Maybe<Array<Maybe<Scalars['String']>> | Maybe<Scalars['String']>>;\n  includeNearbyAirports?: Maybe<Scalars['Boolean']>;\n  asSingles?: Maybe<Scalars['Boolean']>;\n  withGrouped: Scalars['Boolean'];\n}>;\n\n\nexport type SearchFlightsV2Query = (\n  { __typename?: 'Query' }\n  & { searchFlightsV2: (\n    { __typename?: 'FlightSearchResultV2' }\n    & { results: (\n      { __typename?: 'FEFlightSearchResults' }\n      & { journeys: Array<(\n        { __typename?: 'FlightItinerary' }\n        & Pick<FlightItinerary, 'uid' | 'passengerCount' | 'outboundTotalDuration' | 'inboundTotalDuration' | 'additional' | 'source' | 'sourceId' | 'version' | 'tmcPreferred' | 'companyPreferred' | 'officePreferred' | 'tmcPreferredMessage' | 'companyPreferredMessage' | 'officePreferredMessage' | 'unavailable' | 'unavailableMessage' | 'co2PerItem' | 'co2PerPassenger'>\n        & { outboundFlights: Array<(\n          { __typename?: 'FlightJourney' }\n          & Pick<FlightJourney, 'originAirport' | 'originTerminal' | 'originAirportName' | 'destinationAirport' | 'destinationTerminal' | 'destinationAirportName' | 'dateTimeDeparting' | 'dateTimeDepartingUTC' | 'dateTimeArriving' | 'dateTimeArrivingUTC' | 'marketingCarrier' | 'marketingCarrierName' | 'marketingFlightNumber' | 'operatingCarrier' | 'operatingCarrierName' | 'operatingFlightNumber' | 'equipmentCode' | 'equipmentName' | 'totalDuration' | 'cabinClass' | 'marketingNames' | 'vendorCode' | 'stops' | 'bookingCode' | 'marriageGroup' | 'fareBasisCode' | 'additional'>\n          & { originAirportDetail: (\n            { __typename?: 'AirportDetail' }\n            & Pick<AirportDetail, 'iata' | 'icao' | 'latitude' | 'longitude' | 'altitude' | 'state' | 'city' | 'road' | 'popularity' | 'area' | 'location' | 'offset' | 'airportName' | 'countryName' | 'countryCode' | 'postcode'>\n          ), destinationAirportDetail: (\n            { __typename?: 'AirportDetail' }\n            & Pick<AirportDetail, 'iata' | 'icao' | 'latitude' | 'longitude' | 'altitude' | 'state' | 'city' | 'road' | 'popularity' | 'area' | 'location' | 'offset' | 'airportName' | 'countryName' | 'countryCode' | 'postcode'>\n          ), marketingCarrierDetail: (\n            { __typename?: 'FlightCarrierDetail' }\n            & Pick<FlightCarrierDetail, 'name' | 'alias' | 'callsign' | 'iata' | 'icao' | 'logo' | 'banner' | 'popularity'>\n          ), operatingCarrierDetail: (\n            { __typename?: 'FlightCarrierDetail' }\n            & Pick<FlightCarrierDetail, 'name' | 'alias' | 'callsign' | 'iata' | 'icao' | 'logo' | 'banner' | 'popularity'>\n          ), fareConditions: (\n            { __typename?: 'FareConditions' }\n            & { cancellation?: Maybe<Array<Maybe<(\n              { __typename?: 'FareConditionEntry' }\n              & Pick<FareConditionEntry, 'name' | 'type' | 'currency' | 'amount' | 'remark' | 'changeFeeInd' | 'cancelFeeInd' | 'refundableInd'>\n            )>>>, change?: Maybe<Array<Maybe<(\n              { __typename?: 'FareConditionEntry' }\n              & Pick<FareConditionEntry, 'name' | 'type' | 'currency' | 'amount' | 'remark' | 'changeFeeInd' | 'cancelFeeInd' | 'refundableInd'>\n            )>>>, noShow?: Maybe<Array<Maybe<(\n              { __typename?: 'FareConditionEntry' }\n              & Pick<FareConditionEntry, 'name' | 'type' | 'currency' | 'amount' | 'remark' | 'changeFeeInd' | 'cancelFeeInd' | 'refundableInd'>\n            )>>>, upgrade?: Maybe<Array<Maybe<(\n              { __typename?: 'FareConditionEntry' }\n              & Pick<FareConditionEntry, 'name' | 'type' | 'currency' | 'amount' | 'remark' | 'changeFeeInd' | 'cancelFeeInd' | 'refundableInd'>\n            )>>>, other?: Maybe<Array<Maybe<(\n              { __typename?: 'FareConditionEntry' }\n              & Pick<FareConditionEntry, 'name' | 'type' | 'currency' | 'amount' | 'remark' | 'changeFeeInd' | 'cancelFeeInd' | 'refundableInd'>\n            )>>> }\n          ) }\n        )>, inboundFlights?: Maybe<Array<Maybe<(\n          { __typename?: 'FlightJourney' }\n          & Pick<FlightJourney, 'originAirport' | 'originTerminal' | 'originAirportName' | 'destinationAirport' | 'destinationTerminal' | 'destinationAirportName' | 'dateTimeDeparting' | 'dateTimeDepartingUTC' | 'dateTimeArriving' | 'dateTimeArrivingUTC' | 'marketingCarrier' | 'marketingCarrierName' | 'marketingFlightNumber' | 'operatingCarrier' | 'operatingCarrierName' | 'operatingFlightNumber' | 'equipmentCode' | 'equipmentName' | 'totalDuration' | 'cabinClass' | 'marketingNames' | 'vendorCode' | 'stops' | 'bookingCode' | 'marriageGroup' | 'fareBasisCode' | 'additional'>\n          & { originAirportDetail: (\n            { __typename?: 'AirportDetail' }\n            & Pick<AirportDetail, 'iata' | 'icao' | 'latitude' | 'longitude' | 'altitude' | 'state' | 'city' | 'road' | 'popularity' | 'area' | 'location' | 'offset' | 'airportName' | 'countryName' | 'countryCode' | 'postcode'>\n          ), destinationAirportDetail: (\n            { __typename?: 'AirportDetail' }\n            & Pick<AirportDetail, 'iata' | 'icao' | 'latitude' | 'longitude' | 'altitude' | 'state' | 'city' | 'road' | 'popularity' | 'area' | 'location' | 'offset' | 'airportName' | 'countryName' | 'countryCode' | 'postcode'>\n          ), marketingCarrierDetail: (\n            { __typename?: 'FlightCarrierDetail' }\n            & Pick<FlightCarrierDetail, 'name' | 'alias' | 'callsign' | 'iata' | 'icao' | 'logo' | 'banner' | 'popularity'>\n          ), operatingCarrierDetail: (\n            { __typename?: 'FlightCarrierDetail' }\n            & Pick<FlightCarrierDetail, 'name' | 'alias' | 'callsign' | 'iata' | 'icao' | 'logo' | 'banner' | 'popularity'>\n          ), fareConditions: (\n            { __typename?: 'FareConditions' }\n            & { cancellation?: Maybe<Array<Maybe<(\n              { __typename?: 'FareConditionEntry' }\n              & Pick<FareConditionEntry, 'name' | 'type' | 'currency' | 'amount' | 'remark' | 'changeFeeInd' | 'cancelFeeInd' | 'refundableInd'>\n            )>>>, change?: Maybe<Array<Maybe<(\n              { __typename?: 'FareConditionEntry' }\n              & Pick<FareConditionEntry, 'name' | 'type' | 'currency' | 'amount' | 'remark' | 'changeFeeInd' | 'cancelFeeInd' | 'refundableInd'>\n            )>>>, noShow?: Maybe<Array<Maybe<(\n              { __typename?: 'FareConditionEntry' }\n              & Pick<FareConditionEntry, 'name' | 'type' | 'currency' | 'amount' | 'remark' | 'changeFeeInd' | 'cancelFeeInd' | 'refundableInd'>\n            )>>>, upgrade?: Maybe<Array<Maybe<(\n              { __typename?: 'FareConditionEntry' }\n              & Pick<FareConditionEntry, 'name' | 'type' | 'currency' | 'amount' | 'remark' | 'changeFeeInd' | 'cancelFeeInd' | 'refundableInd'>\n            )>>>, other?: Maybe<Array<Maybe<(\n              { __typename?: 'FareConditionEntry' }\n              & Pick<FareConditionEntry, 'name' | 'type' | 'currency' | 'amount' | 'remark' | 'changeFeeInd' | 'cancelFeeInd' | 'refundableInd'>\n            )>>> }\n          ) }\n        )>>>, outboundCarbonEmissions?: Maybe<(\n          { __typename?: 'FlightCarbonEmissions' }\n          & Pick<FlightCarbonEmissions, 'amount' | 'unit'>\n        )>, inboundCarbonEmissions?: Maybe<(\n          { __typename?: 'FlightCarbonEmissions' }\n          & Pick<FlightCarbonEmissions, 'amount' | 'unit'>\n        )>, taxes?: Maybe<Array<Maybe<(\n          { __typename?: 'FlightAmount' }\n          & Pick<FlightAmount, 'description' | 'amount' | 'currency'>\n        )>>>, discounts?: Maybe<Array<Maybe<(\n          { __typename?: 'FlightAmount' }\n          & Pick<FlightAmount, 'description' | 'amount' | 'currency'>\n        )>>>, total: (\n          { __typename?: 'FlightFareTotal' }\n          & Pick<FlightFareTotal, 'price' | 'tax' | 'discount' | 'currency'>\n        ), fareConditions?: Maybe<(\n          { __typename?: 'FareConditions' }\n          & { cancellation?: Maybe<Array<Maybe<(\n            { __typename?: 'FareConditionEntry' }\n            & Pick<FareConditionEntry, 'name' | 'type' | 'currency' | 'amount' | 'remark' | 'changeFeeInd' | 'cancelFeeInd' | 'refundableInd'>\n          )>>>, change?: Maybe<Array<Maybe<(\n            { __typename?: 'FareConditionEntry' }\n            & Pick<FareConditionEntry, 'name' | 'type' | 'currency' | 'amount' | 'remark' | 'changeFeeInd' | 'cancelFeeInd' | 'refundableInd'>\n          )>>>, noShow?: Maybe<Array<Maybe<(\n            { __typename?: 'FareConditionEntry' }\n            & Pick<FareConditionEntry, 'name' | 'type' | 'currency' | 'amount' | 'remark' | 'changeFeeInd' | 'cancelFeeInd' | 'refundableInd'>\n          )>>>, upgrade?: Maybe<Array<Maybe<(\n            { __typename?: 'FareConditionEntry' }\n            & Pick<FareConditionEntry, 'name' | 'type' | 'currency' | 'amount' | 'remark' | 'changeFeeInd' | 'cancelFeeInd' | 'refundableInd'>\n          )>>>, other?: Maybe<Array<Maybe<(\n            { __typename?: 'FareConditionEntry' }\n            & Pick<FareConditionEntry, 'name' | 'type' | 'currency' | 'amount' | 'remark' | 'changeFeeInd' | 'cancelFeeInd' | 'refundableInd'>\n          )>>> }\n        )>, baggageAllowance?: Maybe<Array<Maybe<(\n          { __typename?: 'BaggageAllowance' }\n          & Pick<BaggageAllowance, 'type' | 'qty' | 'maxKG' | 'maxLBS'>\n        )>>> }\n      )>, multi: Array<(\n        { __typename?: 'ItinerarySummary' }\n        & Pick<ItinerarySummary, 'order' | 'origin' | 'destination' | 'minPrice' | 'maxPrice'>\n        & { results: Array<(\n          { __typename?: 'FlightItinerary' }\n          & Pick<FlightItinerary, 'uid' | 'passengerCount' | 'outboundTotalDuration' | 'inboundTotalDuration' | 'additional' | 'source' | 'sourceId' | 'version' | 'tmcPreferred' | 'companyPreferred' | 'officePreferred' | 'tmcPreferredMessage' | 'companyPreferredMessage' | 'officePreferredMessage' | 'unavailable' | 'unavailableMessage' | 'co2PerItem' | 'co2PerPassenger'>\n          & { outboundFlights: Array<(\n            { __typename?: 'FlightJourney' }\n            & Pick<FlightJourney, 'originAirport' | 'originTerminal' | 'originAirportName' | 'destinationAirport' | 'destinationTerminal' | 'destinationAirportName' | 'dateTimeDeparting' | 'dateTimeDepartingUTC' | 'dateTimeArriving' | 'dateTimeArrivingUTC' | 'marketingCarrier' | 'marketingCarrierName' | 'marketingFlightNumber' | 'operatingCarrier' | 'operatingCarrierName' | 'operatingFlightNumber' | 'equipmentCode' | 'equipmentName' | 'totalDuration' | 'cabinClass' | 'marketingNames' | 'vendorCode' | 'stops' | 'bookingCode' | 'marriageGroup' | 'fareBasisCode' | 'additional'>\n            & { originAirportDetail: (\n              { __typename?: 'AirportDetail' }\n              & Pick<AirportDetail, 'iata' | 'icao' | 'latitude' | 'longitude' | 'altitude' | 'state' | 'city' | 'road' | 'popularity' | 'area' | 'location' | 'offset' | 'airportName' | 'countryName' | 'countryCode' | 'postcode'>\n            ), destinationAirportDetail: (\n              { __typename?: 'AirportDetail' }\n              & Pick<AirportDetail, 'iata' | 'icao' | 'latitude' | 'longitude' | 'altitude' | 'state' | 'city' | 'road' | 'popularity' | 'area' | 'location' | 'offset' | 'airportName' | 'countryName' | 'countryCode' | 'postcode'>\n            ), marketingCarrierDetail: (\n              { __typename?: 'FlightCarrierDetail' }\n              & Pick<FlightCarrierDetail, 'name' | 'alias' | 'callsign' | 'iata' | 'icao' | 'logo' | 'banner' | 'popularity'>\n            ), operatingCarrierDetail: (\n              { __typename?: 'FlightCarrierDetail' }\n              & Pick<FlightCarrierDetail, 'name' | 'alias' | 'callsign' | 'iata' | 'icao' | 'logo' | 'banner' | 'popularity'>\n            ), fareConditions: (\n              { __typename?: 'FareConditions' }\n              & { cancellation?: Maybe<Array<Maybe<(\n                { __typename?: 'FareConditionEntry' }\n                & Pick<FareConditionEntry, 'name' | 'type' | 'currency' | 'amount' | 'remark' | 'changeFeeInd' | 'cancelFeeInd' | 'refundableInd'>\n              )>>>, change?: Maybe<Array<Maybe<(\n                { __typename?: 'FareConditionEntry' }\n                & Pick<FareConditionEntry, 'name' | 'type' | 'currency' | 'amount' | 'remark' | 'changeFeeInd' | 'cancelFeeInd' | 'refundableInd'>\n              )>>>, noShow?: Maybe<Array<Maybe<(\n                { __typename?: 'FareConditionEntry' }\n                & Pick<FareConditionEntry, 'name' | 'type' | 'currency' | 'amount' | 'remark' | 'changeFeeInd' | 'cancelFeeInd' | 'refundableInd'>\n              )>>>, upgrade?: Maybe<Array<Maybe<(\n                { __typename?: 'FareConditionEntry' }\n                & Pick<FareConditionEntry, 'name' | 'type' | 'currency' | 'amount' | 'remark' | 'changeFeeInd' | 'cancelFeeInd' | 'refundableInd'>\n              )>>>, other?: Maybe<Array<Maybe<(\n                { __typename?: 'FareConditionEntry' }\n                & Pick<FareConditionEntry, 'name' | 'type' | 'currency' | 'amount' | 'remark' | 'changeFeeInd' | 'cancelFeeInd' | 'refundableInd'>\n              )>>> }\n            ) }\n          )>, inboundFlights?: Maybe<Array<Maybe<(\n            { __typename?: 'FlightJourney' }\n            & Pick<FlightJourney, 'originAirport' | 'originTerminal' | 'originAirportName' | 'destinationAirport' | 'destinationTerminal' | 'destinationAirportName' | 'dateTimeDeparting' | 'dateTimeDepartingUTC' | 'dateTimeArriving' | 'dateTimeArrivingUTC' | 'marketingCarrier' | 'marketingCarrierName' | 'marketingFlightNumber' | 'operatingCarrier' | 'operatingCarrierName' | 'operatingFlightNumber' | 'equipmentCode' | 'equipmentName' | 'totalDuration' | 'cabinClass' | 'marketingNames' | 'vendorCode' | 'stops' | 'bookingCode' | 'marriageGroup' | 'fareBasisCode' | 'additional'>\n            & { originAirportDetail: (\n              { __typename?: 'AirportDetail' }\n              & Pick<AirportDetail, 'iata' | 'icao' | 'latitude' | 'longitude' | 'altitude' | 'state' | 'city' | 'road' | 'popularity' | 'area' | 'location' | 'offset' | 'airportName' | 'countryName' | 'countryCode' | 'postcode'>\n            ), destinationAirportDetail: (\n              { __typename?: 'AirportDetail' }\n              & Pick<AirportDetail, 'iata' | 'icao' | 'latitude' | 'longitude' | 'altitude' | 'state' | 'city' | 'road' | 'popularity' | 'area' | 'location' | 'offset' | 'airportName' | 'countryName' | 'countryCode' | 'postcode'>\n            ), marketingCarrierDetail: (\n              { __typename?: 'FlightCarrierDetail' }\n              & Pick<FlightCarrierDetail, 'name' | 'alias' | 'callsign' | 'iata' | 'icao' | 'logo' | 'banner' | 'popularity'>\n            ), operatingCarrierDetail: (\n              { __typename?: 'FlightCarrierDetail' }\n              & Pick<FlightCarrierDetail, 'name' | 'alias' | 'callsign' | 'iata' | 'icao' | 'logo' | 'banner' | 'popularity'>\n            ), fareConditions: (\n              { __typename?: 'FareConditions' }\n              & { cancellation?: Maybe<Array<Maybe<(\n                { __typename?: 'FareConditionEntry' }\n                & Pick<FareConditionEntry, 'name' | 'type' | 'currency' | 'amount' | 'remark' | 'changeFeeInd' | 'cancelFeeInd' | 'refundableInd'>\n              )>>>, change?: Maybe<Array<Maybe<(\n                { __typename?: 'FareConditionEntry' }\n                & Pick<FareConditionEntry, 'name' | 'type' | 'currency' | 'amount' | 'remark' | 'changeFeeInd' | 'cancelFeeInd' | 'refundableInd'>\n              )>>>, noShow?: Maybe<Array<Maybe<(\n                { __typename?: 'FareConditionEntry' }\n                & Pick<FareConditionEntry, 'name' | 'type' | 'currency' | 'amount' | 'remark' | 'changeFeeInd' | 'cancelFeeInd' | 'refundableInd'>\n              )>>>, upgrade?: Maybe<Array<Maybe<(\n                { __typename?: 'FareConditionEntry' }\n                & Pick<FareConditionEntry, 'name' | 'type' | 'currency' | 'amount' | 'remark' | 'changeFeeInd' | 'cancelFeeInd' | 'refundableInd'>\n              )>>>, other?: Maybe<Array<Maybe<(\n                { __typename?: 'FareConditionEntry' }\n                & Pick<FareConditionEntry, 'name' | 'type' | 'currency' | 'amount' | 'remark' | 'changeFeeInd' | 'cancelFeeInd' | 'refundableInd'>\n              )>>> }\n            ) }\n          )>>>, outboundCarbonEmissions?: Maybe<(\n            { __typename?: 'FlightCarbonEmissions' }\n            & Pick<FlightCarbonEmissions, 'amount' | 'unit'>\n          )>, inboundCarbonEmissions?: Maybe<(\n            { __typename?: 'FlightCarbonEmissions' }\n            & Pick<FlightCarbonEmissions, 'amount' | 'unit'>\n          )>, taxes?: Maybe<Array<Maybe<(\n            { __typename?: 'FlightAmount' }\n            & Pick<FlightAmount, 'description' | 'amount' | 'currency'>\n          )>>>, discounts?: Maybe<Array<Maybe<(\n            { __typename?: 'FlightAmount' }\n            & Pick<FlightAmount, 'description' | 'amount' | 'currency'>\n          )>>>, total: (\n            { __typename?: 'FlightFareTotal' }\n            & Pick<FlightFareTotal, 'price' | 'tax' | 'discount' | 'currency'>\n          ), fareConditions?: Maybe<(\n            { __typename?: 'FareConditions' }\n            & { cancellation?: Maybe<Array<Maybe<(\n              { __typename?: 'FareConditionEntry' }\n              & Pick<FareConditionEntry, 'name' | 'type' | 'currency' | 'amount' | 'remark' | 'changeFeeInd' | 'cancelFeeInd' | 'refundableInd'>\n            )>>>, change?: Maybe<Array<Maybe<(\n              { __typename?: 'FareConditionEntry' }\n              & Pick<FareConditionEntry, 'name' | 'type' | 'currency' | 'amount' | 'remark' | 'changeFeeInd' | 'cancelFeeInd' | 'refundableInd'>\n            )>>>, noShow?: Maybe<Array<Maybe<(\n              { __typename?: 'FareConditionEntry' }\n              & Pick<FareConditionEntry, 'name' | 'type' | 'currency' | 'amount' | 'remark' | 'changeFeeInd' | 'cancelFeeInd' | 'refundableInd'>\n            )>>>, upgrade?: Maybe<Array<Maybe<(\n              { __typename?: 'FareConditionEntry' }\n              & Pick<FareConditionEntry, 'name' | 'type' | 'currency' | 'amount' | 'remark' | 'changeFeeInd' | 'cancelFeeInd' | 'refundableInd'>\n            )>>>, other?: Maybe<Array<Maybe<(\n              { __typename?: 'FareConditionEntry' }\n              & Pick<FareConditionEntry, 'name' | 'type' | 'currency' | 'amount' | 'remark' | 'changeFeeInd' | 'cancelFeeInd' | 'refundableInd'>\n            )>>> }\n          )>, baggageAllowance?: Maybe<Array<Maybe<(\n            { __typename?: 'BaggageAllowance' }\n            & Pick<BaggageAllowance, 'type' | 'qty' | 'maxKG' | 'maxLBS'>\n          )>>> }\n        )> }\n      )>, grouped?: Maybe<Array<(\n        { __typename?: 'GroupFlights' }\n        & GroupedFieldsFragment\n      )>> }\n    ), errors: Array<(\n      { __typename?: 'SearchError' }\n      & ErrorsFragment\n    )> }\n  ) }\n);\n\nexport type GetCarHireDepotsQueryVariables = Exact<{\n  latitude: Scalars['Float'];\n  longitude: Scalars['Float'];\n  vendorCode?: Maybe<Scalars['String']>;\n}>;\n\n\nexport type GetCarHireDepotsQuery = (\n  { __typename?: 'Query' }\n  & { getCarHireDepots: Array<(\n    { __typename?: 'CarHireDepot' }\n    & Pick<CarHireDepot, 'countryCode' | 'locationCode' | 'extendedLocationCode' | 'vendorCode' | 'latitude' | 'longitude' | 'vendor' | 'addressLines' | 'cityName'>\n  )> }\n);\n\nexport type GetConfermaOfficeNamesQueryVariables = Exact<{ [key: string]: never; }>;\n\n\nexport type GetConfermaOfficeNamesQuery = (\n  { __typename?: 'Query' }\n  & { getConfermaOfficeNames: (\n    { __typename?: 'ConfermaOfficeNamesResult' }\n    & { results?: Maybe<Array<Maybe<(\n      { __typename?: 'ConfermaOfficeNames' }\n      & Pick<ConfermaOfficeNames, 'id' | 'name'>\n    )>>>, errors: Array<(\n      { __typename?: 'SearchError' }\n      & ErrorsFragment\n    )> }\n  ) }\n);\n\nexport type GetConfermaQuicklistQueryVariables = Exact<{\n  countryCode: Scalars['String'];\n}>;\n\n\nexport type GetConfermaQuicklistQuery = (\n  { __typename?: 'Query' }\n  & { getConfermaQuicklist: (\n    { __typename?: 'HotelSearchResult' }\n    & { results?: Maybe<Array<Maybe<(\n      { __typename?: 'HotelItinerary' }\n      & Pick<HotelItinerary, 'id' | 'name' | 'imageUrl' | 'group' | 'version' | 'tmcPreferredMessage' | 'companyPreferredMessage' | 'officePreferredMessage' | 'unavailableMessage'>\n      & { location: (\n        { __typename?: 'HotelLocation' }\n        & Pick<HotelLocation, 'distance' | 'distanceType' | 'longitude' | 'latitude'>\n      ), address: (\n        { __typename?: 'HotelAddress' }\n        & Pick<HotelAddress, 'addressLine1' | 'addressLine2' | 'addressLine3' | 'postOrZipCode' | 'countryCode' | 'telephone' | 'facsimile'>\n      ), transports?: Maybe<Array<Maybe<(\n        { __typename?: 'HotelTransport' }\n        & Pick<HotelTransport, 'type' | 'name' | 'code' | 'distance' | 'distanceType' | 'longitude' | 'latitude'>\n      )>>>, preferred: (\n        { __typename?: 'HotelPreferred' }\n        & Pick<HotelPreferred, 'client' | 'consumer'>\n      ), tags?: Maybe<Array<Maybe<(\n        { __typename?: 'HotelTag' }\n        & Pick<HotelTag, 'name' | 'display' | 'type' | 'icon'>\n      )>>>, availableRates?: Maybe<(\n        { __typename?: 'HotelAvailability' }\n        & Pick<HotelAvailability, 'hotelId' | 'imageUrl' | 'prpn' | 'currencyCode' | 'isBusy' | 'source' | 'version'>\n        & { rooms?: Maybe<Array<Maybe<(\n          { __typename?: 'HotelRoom' }\n          & Pick<HotelRoom, 'roomId' | 'roomType' | 'roomDescription' | 'rateCode' | 'rateDescription' | 'total' | 'currencyCode'>\n          & { currencyConversion?: Maybe<(\n            { __typename?: 'HotelConversion' }\n            & Pick<HotelConversion, 'rate' | 'localCode' | 'localTotal' | 'convertedCode' | 'convertedTotal'>\n          )>, deposit?: Maybe<(\n            { __typename?: 'HotelDeposit' }\n            & Pick<HotelDeposit, 'amount' | 'policy' | 'required'>\n          )>, nights: Array<(\n            { __typename?: 'HotelNight' }\n            & Pick<HotelNight, 'night' | 'rate' | 'info' | 'date'>\n          )>, policies: (\n            { __typename?: 'HotelPolicy' }\n            & Pick<HotelPolicy, 'cancellation' | 'deposit' | 'disabledAccess' | 'general' | 'guarantee' | 'refundAvailable'>\n          ), tax: (\n            { __typename?: 'HotelTax' }\n            & Pick<HotelTax, 'included' | 'rate'>\n          ), acceptedCards?: Maybe<Array<Maybe<(\n            { __typename?: 'HotelCard' }\n            & Pick<HotelCard, 'id' | 'name'>\n          )>>>, paymentTypes?: Maybe<Array<Maybe<(\n            { __typename?: 'HotelPaymentType' }\n            & Pick<HotelPaymentType, 'type' | 'name'>\n          )>>> }\n        )>>> }\n      )> }\n    )>>>, errors: Array<(\n      { __typename?: 'SearchError' }\n      & ErrorsFragment\n    )> }\n  ) }\n);\n\nexport type GetRailStationQueryVariables = Exact<{\n  id?: Maybe<Scalars['ID']>;\n  code?: Maybe<Scalars['String']>;\n}>;\n\n\nexport type GetRailStationQuery = (\n  { __typename?: 'Query' }\n  & { getRailStation: (\n    { __typename?: 'RailStation' }\n    & Pick<RailStation, 'id' | 'name' | 'stationCode' | 'nlcCode' | 'trainlineCode' | 'trainlineUniqueCode'>\n    & { locationDetails?: Maybe<(\n      { __typename?: 'LocationDetail' }\n      & Pick<LocationDetail, 'continent' | 'country' | 'countryCode' | 'state' | 'city' | 'postcode' | 'road' | 'gridReference' | 'northing' | 'easting'>\n      & { coordinates?: Maybe<(\n        { __typename?: 'GeoCoordinates' }\n        & Pick<GeoCoordinates, 'latitude' | 'longitude' | 'altitude'>\n      )> }\n    )> }\n  ) }\n);\n\nexport type GetRailcardsQueryVariables = Exact<{ [key: string]: never; }>;\n\n\nexport type GetRailcardsQuery = (\n  { __typename?: 'Query' }\n  & { getRailcards: Array<(\n    { __typename?: 'ReferenceRailCardQualifier' }\n    & Pick<ReferenceRailCardQualifier, 'name' | 'code'>\n  )> }\n);\n\nexport type GetRiskAlertsQueryVariables = Exact<{\n  minLevel: RiskLevel;\n  maxLevel: RiskLevel;\n  countryIsoCode?: Maybe<Scalars['String']>;\n  airport?: Maybe<Scalars['ID']>;\n  railStation?: Maybe<Scalars['ID']>;\n  airportIata?: Maybe<Scalars['String']>;\n}>;\n\n\nexport type GetRiskAlertsQuery = (\n  { __typename?: 'Query' }\n  & { getRiskAlerts: Array<(\n    { __typename?: 'RiskAlert' }\n    & Pick<RiskAlert, 'id' | 'title' | 'description' | 'breaking' | 'risk' | 'category' | 'country' | 'location' | 'latitude' | 'longitude' | 'startDate' | 'endDate' | 'receivedDate'>\n  )> }\n);\n\nexport type GetUserAddressesQueryVariables = Exact<{ [key: string]: never; }>;\n\n\nexport type GetUserAddressesQuery = (\n  { __typename?: 'Query' }\n  & { getUserAddresses: Array<(\n    { __typename?: 'Address' }\n    & Pick<Address, 'id' | 'description' | 'numberOrName' | 'street' | 'town' | 'county' | 'postcode' | 'countryCode' | 'userPrimary' | 'officePrimary'>\n  )> }\n);\n\nexport type GetUserCompanyOfficesQueryVariables = Exact<{ [key: string]: never; }>;\n\n\nexport type GetUserCompanyOfficesQuery = (\n  { __typename?: 'Query' }\n  & { getUserCompanyOffices: Array<(\n    { __typename?: 'Office' }\n    & Pick<Office, 'id' | 'name'>\n    & { addresses: Array<(\n      { __typename?: 'Address' }\n      & Pick<Address, 'id' | 'description' | 'numberOrName' | 'street' | 'town' | 'county' | 'postcode' | 'countryCode' | 'userPrimary' | 'officePrimary'>\n    )> }\n  )> }\n);\n\nexport type GetUserCurrentCarbonAllowanceQueryVariables = Exact<{\n  user?: Maybe<Scalars['ID']>;\n}>;\n\n\nexport type GetUserCurrentCarbonAllowanceQuery = (\n  { __typename?: 'Query' }\n  & { getUserCurrentCarbonAllowance?: Maybe<(\n    { __typename?: 'CarbonAllowance' }\n    & Pick<CarbonAllowance, 'id' | 'startOfPeriod' | 'endOfPeriod' | 'remainingCo2' | 'totalCo2' | 'carbonPolicySource'>\n    & { company?: Maybe<(\n      { __typename?: 'Company' }\n      & Pick<Company, 'id' | 'name'>\n    )>, office?: Maybe<(\n      { __typename?: 'Office' }\n      & Pick<Office, 'id' | 'name'>\n    )>, user: (\n      { __typename?: 'User' }\n      & Pick<User, 'id' | 'forename' | 'surname' | 'email'>\n    ), periodConsumption: Array<(\n      { __typename?: 'CarbonConsumption' }\n      & Pick<CarbonConsumption, 'id' | 'consumed' | 'datetime'>\n    )> }\n  )> }\n);\n\nexport type GetUserMiAutoSuggestValuesQueryVariables = Exact<{\n  mi: Scalars['ID'];\n  partialLabel: Scalars['String'];\n}>;\n\n\nexport type GetUserMiAutoSuggestValuesQuery = (\n  { __typename?: 'Query' }\n  & { getUserMIAutoSuggestValues: Array<(\n    { __typename?: 'ManagementInfoValue' }\n    & Pick<ManagementInfoValue, 'id' | 'label' | 'value' | 'default' | 'fixed' | 'agentOnly'>\n  )> }\n);\n\nexport type GetUserPhoneQueryVariables = Exact<{ [key: string]: never; }>;\n\n\nexport type GetUserPhoneQuery = (\n  { __typename?: 'Query' }\n  & { getUserPhoneNumbers: Array<(\n    { __typename?: 'PhoneNumber' }\n    & Pick<PhoneNumber, 'id' | 'description' | 'countryCode' | 'areaCode' | 'number' | 'extension' | 'type' | 'officePrimary' | 'userPrimary'>\n  )> }\n);\n\nexport type GetUserRecentSearchesQueryVariables = Exact<{\n  serviceType?: Maybe<ServiceType>;\n}>;\n\n\nexport type GetUserRecentSearchesQuery = (\n  { __typename?: 'Query' }\n  & { getUserRecentSearches: Array<(\n    { __typename?: 'Search' }\n    & Pick<Search, 'id' | 'name' | 'serviceType' | 'searchArgs' | 'createdAt' | 'updatedAt' | 'travelDate'>\n    & { travellers?: Maybe<Array<(\n      { __typename?: 'User' }\n      & Pick<User, 'id' | 'title' | 'forename' | 'surname' | 'email' | 'username' | 'dob'>\n    )>> }\n  )> }\n);\n\nexport type SearchHotelsQueryVariables = Exact<{\n  startDate: Scalars['Date'];\n  endDate: Scalars['Date'];\n  cityName?: Maybe<Scalars['String']>;\n  postOrZipCode?: Maybe<Scalars['String']>;\n  countryCode?: Maybe<Scalars['String']>;\n  latitude?: Maybe<Scalars['Float']>;\n  longitude?: Maybe<Scalars['Float']>;\n  trainStationCode?: Maybe<Scalars['String']>;\n  iata?: Maybe<Scalars['String']>;\n  officeId?: Maybe<Scalars['Int']>;\n  rooms: Scalars['Int'];\n  adults: Scalars['Int'];\n  children?: Maybe<Scalars['Int']>;\n  currency: Scalars['String'];\n  distanceType: DistanceTypes;\n  distance: Scalars['Int'];\n  maxResults?: Maybe<Scalars['Int']>;\n  hotelName?: Maybe<Scalars['String']>;\n  groupName?: Maybe<Scalars['String']>;\n}>;\n\n\nexport type SearchHotelsQuery = (\n  { __typename?: 'Query' }\n  & { searchHotels: (\n    { __typename?: 'HotelSearchResult' }\n    & { results?: Maybe<Array<Maybe<(\n      { __typename?: 'HotelItinerary' }\n      & Pick<HotelItinerary, 'id' | 'name' | 'imageUrl' | 'group' | 'co2PerPassenger' | 'co2PerItem' | 'source' | 'sourceId' | 'version' | 'tmcPreferred' | 'companyPreferred' | 'officePreferred' | 'tmcPreferredMessage' | 'companyPreferredMessage' | 'officePreferredMessage' | 'unavailable' | 'unavailableMessage'>\n      & { location: (\n        { __typename?: 'HotelLocation' }\n        & Pick<HotelLocation, 'distance' | 'distanceType' | 'longitude' | 'latitude'>\n      ), address: (\n        { __typename?: 'HotelAddress' }\n        & Pick<HotelAddress, 'addressLine1' | 'addressLine2' | 'addressLine3' | 'postOrZipCode' | 'countryCode' | 'telephone' | 'facsimile'>\n      ), transports?: Maybe<Array<Maybe<(\n        { __typename?: 'HotelTransport' }\n        & Pick<HotelTransport, 'type' | 'name' | 'code' | 'distance' | 'distanceType' | 'longitude' | 'latitude'>\n      )>>>, preferred: (\n        { __typename?: 'HotelPreferred' }\n        & Pick<HotelPreferred, 'client' | 'consumer'>\n      ), tags?: Maybe<Array<Maybe<(\n        { __typename?: 'HotelTag' }\n        & Pick<HotelTag, 'name' | 'display' | 'type' | 'icon'>\n      )>>>, availableRates?: Maybe<(\n        { __typename?: 'HotelAvailability' }\n        & Pick<HotelAvailability, 'hotelId' | 'imageUrl' | 'prpn' | 'currencyCode' | 'isBusy' | 'source' | 'version'>\n        & { rooms?: Maybe<Array<Maybe<(\n          { __typename?: 'HotelRoom' }\n          & Pick<HotelRoom, 'roomId' | 'roomType' | 'roomDescription' | 'rateCode' | 'rateDescription' | 'total' | 'currencyCode'>\n          & { currencyConversion?: Maybe<(\n            { __typename?: 'HotelConversion' }\n            & Pick<HotelConversion, 'rate' | 'localCode' | 'localTotal' | 'convertedCode' | 'convertedTotal'>\n          )>, deposit?: Maybe<(\n            { __typename?: 'HotelDeposit' }\n            & Pick<HotelDeposit, 'amount' | 'policy' | 'required'>\n          )>, nights: Array<(\n            { __typename?: 'HotelNight' }\n            & Pick<HotelNight, 'night' | 'rate' | 'info' | 'date'>\n          )>, policies: (\n            { __typename?: 'HotelPolicy' }\n            & Pick<HotelPolicy, 'cancellation' | 'deposit' | 'disabledAccess' | 'general' | 'guarantee' | 'refundAvailable'>\n          ), tax: (\n            { __typename?: 'HotelTax' }\n            & Pick<HotelTax, 'included' | 'rate'>\n          ), acceptedCards?: Maybe<Array<Maybe<(\n            { __typename?: 'HotelCard' }\n            & Pick<HotelCard, 'id' | 'name'>\n          )>>>, paymentTypes?: Maybe<Array<Maybe<(\n            { __typename?: 'HotelPaymentType' }\n            & Pick<HotelPaymentType, 'type' | 'name'>\n          )>>> }\n        )>>> }\n      )> }\n    )>>>, errors: Array<(\n      { __typename?: 'SearchError' }\n      & Pick<SearchError, 'errorMessage' | 'errorCode'>\n      & { service: (\n        { __typename?: 'Service' }\n        & Pick<Service, 'id' | 'type' | 'name' | 'description' | 'detailSchema' | 'searchQuerySchema'>\n      ) }\n    )> }\n  ) }\n);\n\nexport type GetMultipleHotelsAvailabilityQueryVariables = Exact<{\n  hotel: Array<Scalars['String']> | Scalars['String'];\n  startDate: Scalars['Date'];\n  endDate: Scalars['Date'];\n  currency: Scalars['String'];\n  occupants: Scalars['Int'];\n  rooms?: Maybe<Scalars['Int']>;\n}>;\n\n\nexport type GetMultipleHotelsAvailabilityQuery = (\n  { __typename?: 'Query' }\n  & { getMultipleHotelsAvailability: (\n    { __typename?: 'HotelMultiAvailabilityResult' }\n    & { results?: Maybe<Array<Maybe<(\n      { __typename?: 'HotelAvailability' }\n      & Pick<HotelAvailability, 'hotelId' | 'prpn' | 'currencyCode' | 'isBusy' | 'source' | 'version'>\n      & { rooms?: Maybe<Array<Maybe<(\n        { __typename?: 'HotelRoom' }\n        & Pick<HotelRoom, 'roomId' | 'roomType' | 'roomDescription' | 'rateCode' | 'rateDescription' | 'total' | 'currencyCode'>\n        & { currencyConversion?: Maybe<(\n          { __typename?: 'HotelConversion' }\n          & Pick<HotelConversion, 'rate' | 'localCode' | 'localTotal' | 'convertedCode' | 'convertedTotal'>\n        )>, deposit?: Maybe<(\n          { __typename?: 'HotelDeposit' }\n          & Pick<HotelDeposit, 'amount' | 'policy' | 'required'>\n        )>, nights: Array<(\n          { __typename?: 'HotelNight' }\n          & Pick<HotelNight, 'night' | 'rate' | 'info' | 'date'>\n        )>, policies: (\n          { __typename?: 'HotelPolicy' }\n          & Pick<HotelPolicy, 'cancellation' | 'deposit' | 'disabledAccess' | 'general' | 'guarantee' | 'refundAvailable'>\n        ), tax: (\n          { __typename?: 'HotelTax' }\n          & Pick<HotelTax, 'included' | 'rate'>\n        ), acceptedCards?: Maybe<Array<Maybe<(\n          { __typename?: 'HotelCard' }\n          & Pick<HotelCard, 'id' | 'name'>\n        )>>>, paymentTypes?: Maybe<Array<Maybe<(\n          { __typename?: 'HotelPaymentType' }\n          & Pick<HotelPaymentType, 'type' | 'name'>\n        )>>> }\n      )>>> }\n    )>>>, errors: Array<(\n      { __typename?: 'SearchError' }\n      & ErrorsFragment\n    )> }\n  ) }\n);\n\nexport type IsPostcodeValidQueryVariables = Exact<{\n  postcode: Scalars['String'];\n}>;\n\n\nexport type IsPostcodeValidQuery = (\n  { __typename?: 'Query' }\n  & Pick<Query, 'isPostcodeValid'>\n);\n\nexport type Location_DetailFragment = (\n  { __typename?: 'LocationDetail' }\n  & Pick<LocationDetail, 'continent' | 'country' | 'countryCode' | 'state' | 'city' | 'postcode' | 'road' | 'gridReference' | 'northing' | 'easting'>\n  & { coordinates?: Maybe<(\n    { __typename?: 'GeoCoordinates' }\n    & Pick<GeoCoordinates, 'latitude' | 'longitude' | 'altitude'>\n  )> }\n);\n\nexport type SearchAirportsQueryVariables = Exact<{\n  query: Scalars['String'];\n  countryCode?: Maybe<Scalars['String']>;\n  hasLounge?: Maybe<Scalars['Boolean']>;\n  hasParking?: Maybe<Scalars['Boolean']>;\n  hasFastTrack?: Maybe<Scalars['Boolean']>;\n}>;\n\n\nexport type SearchAirportsQuery = (\n  { __typename?: 'Query' }\n  & { searchAirports: (\n    { __typename?: 'AirportResults' }\n    & { iataMatch?: Maybe<(\n      { __typename?: 'Airport' }\n      & Pick<Airport, 'id' | 'name' | 'iata' | 'icao' | 'terminals'>\n      & { locationDetails?: Maybe<(\n        { __typename?: 'LocationDetail' }\n        & Location_DetailFragment\n      )> }\n    )>, generalMatches: Array<(\n      { __typename?: 'Airport' }\n      & Pick<Airport, 'id' | 'name' | 'iata' | 'icao' | 'terminals'>\n      & { locationDetails?: Maybe<(\n        { __typename?: 'LocationDetail' }\n        & Location_DetailFragment\n      )> }\n    )> }\n  ) }\n);\n\nexport type SearchLoungesQueryVariables = Exact<{\n  locationCode: Scalars['String'];\n  arrivalDatetime: Scalars['DateTime'];\n  adults: Scalars['Int'];\n  children?: Maybe<Scalars['Int']>;\n  infants?: Maybe<Scalars['Int']>;\n  terminal?: Maybe<Scalars['String']>;\n}>;\n\n\nexport type SearchLoungesQuery = (\n  { __typename?: 'Query' }\n  & { searchLounges: (\n    { __typename?: 'LoungeSearchResult' }\n    & { results: Array<(\n      { __typename?: 'LoungeQuote' }\n      & Pick<LoungeQuote, 'source' | 'sourceId' | 'name' | 'code' | 'price' | 'currency' | 'tmcPreferred' | 'companyPreferred' | 'officePreferred' | 'tmcPreferredMessage' | 'companyPreferredMessage' | 'officePreferredMessage' | 'unavailable' | 'unavailableMessage' | 'co2PerPassenger' | 'co2PerItem'>\n      & { lounge: (\n        { __typename?: 'LoungeLocation' }\n        & Pick<LoungeLocation, 'code' | 'name' | 'airport' | 'terminal' | 'address' | 'telephone' | 'fax' | 'directions' | 'introduction' | 'logo' | 'mobileImage' | 'furtherImages' | 'adultAge' | 'childAge' | 'infantAge' | 'landside' | 'airside' | 'facilities' | 'openTime' | 'closeTime' | 'wifi' | 'tv' | 'snacks' | 'phone' | 'internet' | 'childrenAllowed' | 'disabledAccess' | 'drinks' | 'freeDrinks' | 'freeFood' | 'smokingPermitted' | 'magazines' | 'includedDrinks' | 'menuFood' | 'menuDrinks' | 'menuExtras' | 'whatsIncludedDrinks' | 'whatsIncludedExtras' | 'whatsIncludedFood' | 'groupInfo' | 'checkInInfo' | 'dressCode' | 'facilitiesInfo' | 'foodAndBeverage' | 'cancellationInfo' | 'amendmentsInfo' | 'misc'>\n      ) }\n    )>, errors: Array<(\n      { __typename?: 'SearchError' }\n      & ErrorsFragment\n    )> }\n  ) }\n);\n\nexport type MoveItemToADifferentBasketMutationVariables = Exact<{\n  basketItem: Scalars['ID'];\n  newBasket: Scalars['ID'];\n  withSupplemental?: Maybe<Scalars['Boolean']>;\n}>;\n\n\nexport type MoveItemToADifferentBasketMutation = (\n  { __typename?: 'Mutation' }\n  & { moveItemToADifferentBasket: (\n    { __typename?: 'Basket' }\n    & BasketFieldsFragment\n  ) }\n);\n\nexport type SearchParkingQueryVariables = Exact<{\n  arrivalDatetime: Scalars['DateTime'];\n  departDatetime: Scalars['DateTime'];\n  locationCode: Scalars['String'];\n  outFlightNumber?: Maybe<Scalars['String']>;\n  recommended?: Maybe<Scalars['Boolean']>;\n  onAirport?: Maybe<Scalars['Boolean']>;\n  meetAndGreet?: Maybe<Scalars['Boolean']>;\n  parkAndRide?: Maybe<Scalars['Boolean']>;\n  parkAndStroll?: Maybe<Scalars['Boolean']>;\n  carParkedForYou?: Maybe<Scalars['Boolean']>;\n  terminal?: Maybe<Scalars['String']>;\n}>;\n\n\nexport type SearchParkingQuery = (\n  { __typename?: 'Query' }\n  & { searchParking: (\n    { __typename?: 'ParkingSearchResult' }\n    & { results: Array<(\n      { __typename?: 'ParkingQuote' }\n      & Pick<ParkingQuote, 'source' | 'sourceId' | 'requiredInfo' | 'price' | 'currency' | 'misc' | 'tmcPreferred' | 'companyPreferred' | 'officePreferred' | 'tmcPreferredMessage' | 'companyPreferredMessage' | 'officePreferredMessage' | 'unavailable' | 'unavailableMessage' | 'co2PerPassenger' | 'co2PerItem'>\n      & { carPark: (\n        { __typename?: 'ParkingLocation' }\n        & Pick<ParkingLocation, 'code' | 'name' | 'airport' | 'terminal' | 'latitude' | 'longitude' | 'address' | 'distanceToAirport' | 'onAirport' | 'carParkedForYou' | 'meetAndGreet' | 'telephone' | 'fax' | 'directions' | 'arrivalProcedure' | 'departureProcedure' | 'maximumCarSize' | 'introduction' | 'information' | 'transferInformation' | 'transferOperatingTimes' | 'transferTime' | 'logo' | 'defaultImage' | 'brandImage' | 'mobileImage' | 'furtherImages' | 'misc'>\n      ) }\n    )>, errors: Array<(\n      { __typename?: 'SearchError' }\n      & ErrorsFragment\n    )> }\n  ) }\n);\n\nexport type SearchRailQueryVariables = Exact<{\n  countryCode: Scalars['String'];\n  journeyType: RailJourneyType;\n  class?: Maybe<RailClass>;\n  outboundArrivalDateTime?: Maybe<Scalars['DateTime']>;\n  outboundDepartureDateTime?: Maybe<Scalars['DateTime']>;\n  departureLocationId: Scalars['ID'];\n  arrivalLocationId: Scalars['ID'];\n  adults: Scalars['Int'];\n  children?: Maybe<Scalars['Int']>;\n  returnArrivalDateTime?: Maybe<Scalars['DateTime']>;\n  returnDepartureDateTime?: Maybe<Scalars['DateTime']>;\n  railCardQualifiers?: Maybe<Array<Scalars['String']> | Scalars['String']>;\n  viaLocationId?: Maybe<Scalars['ID']>;\n  extraTimeToChange?: Maybe<Scalars['Boolean']>;\n  plusBusOut?: Maybe<RailPlusBusAvail>;\n  plusBusReturn?: Maybe<RailPlusBusAvail>;\n}>;\n\n\nexport type SearchRailQuery = (\n  { __typename?: 'Query' }\n  & { searchRail: (\n    { __typename?: 'RailSearchResult' }\n    & { results: Array<(\n      { __typename?: 'RailJourneyOptions' }\n      & Pick<RailJourneyOptions, 'source' | 'sourceId'>\n      & { outbound?: Maybe<Array<(\n        { __typename?: 'RailJourneyOption' }\n        & Pick<RailJourneyOption, 'co2PerItem' | 'from' | 'fromCode' | 'to' | 'toCode' | 'co2PerPassenger' | 'departDateTime' | 'arriveDateTime' | 'changes' | 'unsellable'>\n        & { identifiers?: Maybe<(\n          { __typename?: 'RailIdentifiers' }\n          & Pick<RailIdentifiers, 'transactionIdentifier' | 'journeyIdentifier' | 'provider' | 'fareIdentifier' | 'direction' | 'singleOrReturn' | 'bookingRef'>\n        )>, travellers?: Maybe<Array<(\n          { __typename?: 'RailTraveller' }\n          & Pick<RailTraveller, 'status' | 'id' | 'dob' | 'railcard' | 'givenName' | 'surname' | 'nameTitle' | 'contactInfo' | 'deliveryEmailAddress' | 'fare'>\n        )>>, segments?: Maybe<Array<(\n          { __typename?: 'RailSegment' }\n          & Pick<RailSegment, 'id' | 'operator' | 'depart' | 'departDateTime' | 'arrive' | 'arriveDateTime' | 'reservableStatus' | 'seatPreferenceGroup'>\n          & { seatPreferenceTypes?: Maybe<Array<(\n            { __typename?: 'RailSeatPreferenceType' }\n            & Pick<RailSeatPreferenceType, 'name' | 'allowedValues'>\n          )>>, seats?: Maybe<Array<(\n            { __typename?: 'RailSeat' }\n            & Pick<RailSeat, 'location' | 'coach' | 'number' | 'direction' | 'position' | 'deck' | 'seatType' | 'seatSelection' | 'facilities' | 'note'>\n          )>>, callingPoints?: Maybe<Array<(\n            { __typename?: 'RailCallingPoint' }\n            & Pick<RailCallingPoint, 'stationName' | 'stationCode' | 'arrivalDateTime' | 'departureDateTime' | 'scheduledPlatform' | 'stationClassification' | 'stoppingPattern'>\n          )>> }\n        )>>, providers?: Maybe<Array<(\n          { __typename?: 'RailProvider' }\n          & Pick<RailProvider, 'providerId' | 'name'>\n          & { cheapestTicket?: Maybe<(\n            { __typename?: 'RailTicketOption' }\n            & Pick<RailTicketOption, 'type' | 'class' | 'singleOrReturn' | 'price' | 'reservableStatus' | 'currency' | 'route' | 'routeCode' | 'availableSeats'>\n            & { identifiers?: Maybe<(\n              { __typename?: 'RailIdentifiers' }\n              & Pick<RailIdentifiers, 'transactionIdentifier' | 'journeyIdentifier' | 'provider' | 'fareIdentifier' | 'direction' | 'singleOrReturn' | 'bookingRef'>\n            )>, terms?: Maybe<(\n              { __typename?: 'RailTicketTerms' }\n              & Pick<RailTicketTerms, 'error' | 'ticketTypeCode' | 'trainOperatingCompanyCode' | 'ticketTypeName' | 'ticketTypeAltName' | 'ticketTypeClass' | 'reservationRule' | 'journeyType' | 'preBookingRequirement' | 'generalValidity' | 'validOutRule' | 'validReturnRule' | 'generalDiscount' | 'childDiscount' | 'railcardDiscount' | 'refundCancellationRule' | 'changeRule' | 'ticketTypeConditionsDescription' | 'journeyBreakRule' | 'availabilityRule' | 'todAvailable' | 'kioskAvailable' | 'startDate' | 'endDate'>\n              & { dynamicConditions?: Maybe<Array<Maybe<(\n                { __typename?: 'DynamicCondition' }\n                & Pick<DynamicCondition, 'name' | 'description'>\n              )>>> }\n            )>, tickets?: Maybe<Array<Maybe<(\n              { __typename?: 'RailTicket' }\n              & Pick<RailTicket, 'price' | 'type' | 'route' | 'numChildren' | 'numAdults'>\n              & { segments?: Maybe<Array<(\n                { __typename?: 'RailSegment' }\n                & Pick<RailSegment, 'id' | 'operator' | 'depart' | 'departDateTime' | 'arrive' | 'arriveDateTime' | 'reservableStatus' | 'seatPreferenceGroup'>\n              )>> }\n            )>>>, ticketQueueList?: Maybe<Array<Maybe<(\n              { __typename?: 'RailTicketQueue' }\n              & Pick<RailTicketQueue, 'id' | 'name' | 'type'>\n            )>>>, accountsList?: Maybe<Array<Maybe<(\n              { __typename?: 'RailAccount' }\n              & Pick<RailAccount, 'id' | 'reference' | 'description' | 'isDefault' | 'type'>\n            )>>> }\n          )>, ticketOptions?: Maybe<Array<Maybe<(\n            { __typename?: 'RailTicketOption' }\n            & Pick<RailTicketOption, 'type' | 'class' | 'singleOrReturn' | 'price' | 'reservableStatus' | 'currency' | 'route' | 'routeCode' | 'availableSeats'>\n            & { identifiers?: Maybe<(\n              { __typename?: 'RailIdentifiers' }\n              & Pick<RailIdentifiers, 'transactionIdentifier' | 'journeyIdentifier' | 'provider' | 'fareIdentifier' | 'direction' | 'singleOrReturn' | 'bookingRef'>\n              & { allowedWith: Array<(\n                { __typename?: 'RailIdentifiers' }\n                & Pick<RailIdentifiers, 'transactionIdentifier' | 'journeyIdentifier' | 'provider' | 'fareIdentifier' | 'direction' | 'singleOrReturn' | 'bookingRef'>\n              )> }\n            )>, terms?: Maybe<(\n              { __typename?: 'RailTicketTerms' }\n              & Pick<RailTicketTerms, 'error' | 'ticketTypeCode' | 'trainOperatingCompanyCode' | 'ticketTypeName' | 'ticketTypeAltName' | 'ticketTypeClass' | 'reservationRule' | 'journeyType' | 'preBookingRequirement' | 'generalValidity' | 'validOutRule' | 'validReturnRule' | 'generalDiscount' | 'childDiscount' | 'railcardDiscount' | 'refundCancellationRule' | 'changeRule' | 'ticketTypeConditionsDescription' | 'journeyBreakRule' | 'availabilityRule' | 'todAvailable' | 'kioskAvailable' | 'startDate' | 'endDate'>\n            )>, tickets?: Maybe<Array<Maybe<(\n              { __typename?: 'RailTicket' }\n              & Pick<RailTicket, 'price' | 'type' | 'route' | 'numChildren' | 'numAdults'>\n            )>>>, ticketQueueList?: Maybe<Array<Maybe<(\n              { __typename?: 'RailTicketQueue' }\n              & Pick<RailTicketQueue, 'id' | 'name' | 'type'>\n            )>>>, accountsList?: Maybe<Array<Maybe<(\n              { __typename?: 'RailAccount' }\n              & Pick<RailAccount, 'id' | 'reference' | 'description' | 'isDefault' | 'type'>\n            )>>> }\n          )>>>, bookedTicket?: Maybe<(\n            { __typename?: 'RailTicketOption' }\n            & Pick<RailTicketOption, 'type' | 'class' | 'singleOrReturn' | 'price' | 'reservableStatus' | 'currency' | 'route' | 'routeCode'>\n            & { identifiers?: Maybe<(\n              { __typename?: 'RailIdentifiers' }\n              & Pick<RailIdentifiers, 'transactionIdentifier' | 'journeyIdentifier' | 'provider' | 'fareIdentifier' | 'direction' | 'singleOrReturn' | 'bookingRef'>\n            )>, terms?: Maybe<(\n              { __typename?: 'RailTicketTerms' }\n              & Pick<RailTicketTerms, 'error' | 'ticketTypeCode' | 'trainOperatingCompanyCode' | 'ticketTypeName' | 'ticketTypeAltName' | 'ticketTypeClass' | 'reservationRule' | 'journeyType' | 'preBookingRequirement' | 'generalValidity' | 'validOutRule' | 'validReturnRule' | 'generalDiscount' | 'childDiscount' | 'railcardDiscount' | 'refundCancellationRule' | 'changeRule' | 'ticketTypeConditionsDescription' | 'journeyBreakRule' | 'availabilityRule' | 'todAvailable' | 'kioskAvailable' | 'startDate' | 'endDate'>\n            )>, tickets?: Maybe<Array<Maybe<(\n              { __typename?: 'RailTicket' }\n              & Pick<RailTicket, 'price' | 'type' | 'route' | 'numChildren' | 'numAdults'>\n            )>>>, ticketQueueList?: Maybe<Array<Maybe<(\n              { __typename?: 'RailTicketQueue' }\n              & Pick<RailTicketQueue, 'id' | 'name' | 'type'>\n            )>>>, accountsList?: Maybe<Array<Maybe<(\n              { __typename?: 'RailAccount' }\n              & Pick<RailAccount, 'id' | 'reference' | 'description' | 'isDefault' | 'type'>\n            )>>> }\n          )> }\n        )>>, ticketExtras?: Maybe<Array<(\n          { __typename?: 'RailTicketExtra' }\n          & Pick<RailTicketExtra, 'type' | 'location' | 'date' | 'description' | 'amount' | 'adultAmount' | 'childAmount' | 'currency'>\n          & { identifiers?: Maybe<(\n            { __typename?: 'RailTicketExtraIdentifiers' }\n            & Pick<RailTicketExtraIdentifiers, 'type' | 'location' | 'date' | 'journeyId' | 'isOrigin'>\n          )> }\n        )>>, plusBus?: Maybe<(\n          { __typename?: 'RailPlusBus' }\n          & Pick<RailPlusBus, 'originPlusBusNLC' | 'originStationNLC' | 'destinationPlusBusNLC' | 'destinationStationNLC'>\n        )> }\n      )>>, return?: Maybe<Array<(\n        { __typename?: 'RailJourneyOption' }\n        & Pick<RailJourneyOption, 'co2PerItem' | 'from' | 'fromCode' | 'to' | 'toCode' | 'departDateTime' | 'arriveDateTime' | 'changes' | 'unsellable'>\n        & { identifiers?: Maybe<(\n          { __typename?: 'RailIdentifiers' }\n          & Pick<RailIdentifiers, 'transactionIdentifier' | 'journeyIdentifier' | 'provider' | 'fareIdentifier' | 'direction' | 'singleOrReturn' | 'bookingRef'>\n        )>, travellers?: Maybe<Array<(\n          { __typename?: 'RailTraveller' }\n          & Pick<RailTraveller, 'status' | 'id' | 'dob' | 'railcard' | 'givenName' | 'surname' | 'nameTitle' | 'contactInfo' | 'deliveryEmailAddress' | 'fare'>\n        )>>, segments?: Maybe<Array<(\n          { __typename?: 'RailSegment' }\n          & Pick<RailSegment, 'id' | 'operator' | 'depart' | 'departDateTime' | 'arrive' | 'arriveDateTime' | 'reservableStatus' | 'seatPreferenceGroup'>\n          & { callingPoints?: Maybe<Array<(\n            { __typename?: 'RailCallingPoint' }\n            & Pick<RailCallingPoint, 'stationName' | 'stationCode' | 'arrivalDateTime' | 'departureDateTime' | 'scheduledPlatform' | 'stationClassification' | 'stoppingPattern'>\n          )>> }\n        )>>, providers?: Maybe<Array<(\n          { __typename?: 'RailProvider' }\n          & Pick<RailProvider, 'providerId' | 'name'>\n          & { cheapestTicket?: Maybe<(\n            { __typename?: 'RailTicketOption' }\n            & Pick<RailTicketOption, 'type' | 'class' | 'singleOrReturn' | 'price' | 'reservableStatus' | 'currency' | 'route' | 'routeCode' | 'availableSeats'>\n            & { identifiers?: Maybe<(\n              { __typename?: 'RailIdentifiers' }\n              & Pick<RailIdentifiers, 'transactionIdentifier' | 'journeyIdentifier' | 'provider' | 'fareIdentifier' | 'direction' | 'singleOrReturn' | 'bookingRef'>\n            )>, terms?: Maybe<(\n              { __typename?: 'RailTicketTerms' }\n              & Pick<RailTicketTerms, 'error' | 'ticketTypeCode' | 'trainOperatingCompanyCode' | 'ticketTypeName' | 'ticketTypeAltName' | 'ticketTypeClass' | 'reservationRule' | 'journeyType' | 'preBookingRequirement' | 'generalValidity' | 'validOutRule' | 'validReturnRule' | 'generalDiscount' | 'childDiscount' | 'railcardDiscount' | 'refundCancellationRule' | 'changeRule' | 'ticketTypeConditionsDescription' | 'journeyBreakRule' | 'availabilityRule' | 'todAvailable' | 'kioskAvailable' | 'startDate' | 'endDate'>\n              & { dynamicConditions?: Maybe<Array<Maybe<(\n                { __typename?: 'DynamicCondition' }\n                & Pick<DynamicCondition, 'name' | 'description'>\n              )>>> }\n            )>, tickets?: Maybe<Array<Maybe<(\n              { __typename?: 'RailTicket' }\n              & Pick<RailTicket, 'price' | 'type' | 'route' | 'numChildren' | 'numAdults'>\n              & { segments?: Maybe<Array<(\n                { __typename?: 'RailSegment' }\n                & Pick<RailSegment, 'id' | 'operator' | 'depart' | 'departDateTime' | 'arrive' | 'arriveDateTime' | 'reservableStatus' | 'seatPreferenceGroup'>\n              )>> }\n            )>>>, ticketQueueList?: Maybe<Array<Maybe<(\n              { __typename?: 'RailTicketQueue' }\n              & Pick<RailTicketQueue, 'id' | 'name' | 'type'>\n            )>>>, accountsList?: Maybe<Array<Maybe<(\n              { __typename?: 'RailAccount' }\n              & Pick<RailAccount, 'id' | 'reference' | 'description' | 'isDefault' | 'type'>\n            )>>> }\n          )>, ticketOptions?: Maybe<Array<Maybe<(\n            { __typename?: 'RailTicketOption' }\n            & Pick<RailTicketOption, 'type' | 'class' | 'singleOrReturn' | 'price' | 'reservableStatus' | 'currency' | 'route' | 'routeCode' | 'availableSeats'>\n            & { identifiers?: Maybe<(\n              { __typename?: 'RailIdentifiers' }\n              & Pick<RailIdentifiers, 'transactionIdentifier' | 'journeyIdentifier' | 'provider' | 'fareIdentifier' | 'direction' | 'singleOrReturn' | 'bookingRef'>\n              & { allowedWith: Array<(\n                { __typename?: 'RailIdentifiers' }\n                & Pick<RailIdentifiers, 'transactionIdentifier' | 'journeyIdentifier' | 'provider' | 'fareIdentifier' | 'direction' | 'singleOrReturn' | 'bookingRef'>\n              )> }\n            )>, terms?: Maybe<(\n              { __typename?: 'RailTicketTerms' }\n              & Pick<RailTicketTerms, 'error' | 'ticketTypeCode' | 'trainOperatingCompanyCode' | 'ticketTypeName' | 'ticketTypeAltName' | 'ticketTypeClass' | 'reservationRule' | 'journeyType' | 'preBookingRequirement' | 'generalValidity' | 'validOutRule' | 'validReturnRule' | 'generalDiscount' | 'childDiscount' | 'railcardDiscount' | 'refundCancellationRule' | 'changeRule' | 'ticketTypeConditionsDescription' | 'journeyBreakRule' | 'availabilityRule' | 'todAvailable' | 'kioskAvailable' | 'startDate' | 'endDate'>\n            )>, tickets?: Maybe<Array<Maybe<(\n              { __typename?: 'RailTicket' }\n              & Pick<RailTicket, 'price' | 'type' | 'route' | 'numChildren' | 'numAdults'>\n            )>>>, ticketQueueList?: Maybe<Array<Maybe<(\n              { __typename?: 'RailTicketQueue' }\n              & Pick<RailTicketQueue, 'id' | 'name' | 'type'>\n            )>>>, accountsList?: Maybe<Array<Maybe<(\n              { __typename?: 'RailAccount' }\n              & Pick<RailAccount, 'id' | 'reference' | 'description' | 'isDefault' | 'type'>\n            )>>> }\n          )>>>, bookedTicket?: Maybe<(\n            { __typename?: 'RailTicketOption' }\n            & Pick<RailTicketOption, 'type' | 'class' | 'singleOrReturn' | 'price' | 'reservableStatus' | 'currency' | 'route' | 'routeCode'>\n            & { identifiers?: Maybe<(\n              { __typename?: 'RailIdentifiers' }\n              & Pick<RailIdentifiers, 'transactionIdentifier' | 'journeyIdentifier' | 'provider' | 'fareIdentifier' | 'direction' | 'singleOrReturn' | 'bookingRef'>\n            )>, terms?: Maybe<(\n              { __typename?: 'RailTicketTerms' }\n              & Pick<RailTicketTerms, 'error' | 'ticketTypeCode' | 'trainOperatingCompanyCode' | 'ticketTypeName' | 'ticketTypeAltName' | 'ticketTypeClass' | 'reservationRule' | 'journeyType' | 'preBookingRequirement' | 'generalValidity' | 'validOutRule' | 'validReturnRule' | 'generalDiscount' | 'childDiscount' | 'railcardDiscount' | 'refundCancellationRule' | 'changeRule' | 'ticketTypeConditionsDescription' | 'journeyBreakRule' | 'availabilityRule' | 'todAvailable' | 'kioskAvailable' | 'startDate' | 'endDate'>\n            )>, tickets?: Maybe<Array<Maybe<(\n              { __typename?: 'RailTicket' }\n              & Pick<RailTicket, 'price' | 'type' | 'route' | 'numChildren' | 'numAdults'>\n            )>>>, ticketQueueList?: Maybe<Array<Maybe<(\n              { __typename?: 'RailTicketQueue' }\n              & Pick<RailTicketQueue, 'id' | 'name' | 'type'>\n            )>>>, accountsList?: Maybe<Array<Maybe<(\n              { __typename?: 'RailAccount' }\n              & Pick<RailAccount, 'id' | 'reference' | 'description' | 'isDefault' | 'type'>\n            )>>> }\n          )> }\n        )>>, ticketExtras?: Maybe<Array<(\n          { __typename?: 'RailTicketExtra' }\n          & Pick<RailTicketExtra, 'type' | 'location' | 'date' | 'description' | 'amount' | 'adultAmount' | 'childAmount' | 'currency'>\n        )>>, plusBus?: Maybe<(\n          { __typename?: 'RailPlusBus' }\n          & Pick<RailPlusBus, 'originPlusBusNLC' | 'originStationNLC' | 'destinationPlusBusNLC' | 'destinationStationNLC'>\n        )> }\n      )>> }\n    )>, errors: Array<(\n      { __typename?: 'SearchError' }\n      & ErrorsFragment\n    )> }\n  ) }\n);\n\nexport type SaveRecentSearchMutationVariables = Exact<{\n  serviceType: ServiceType;\n  searchArgs: Scalars['JSON'];\n  travelDate: Scalars['DateTime'];\n  travellers?: Maybe<Array<Maybe<Scalars['ID']>> | Maybe<Scalars['ID']>>;\n}>;\n\n\nexport type SaveRecentSearchMutation = (\n  { __typename?: 'Mutation' }\n  & { saveRecentSearch: Array<(\n    { __typename?: 'Search' }\n    & Pick<Search, 'id'>\n  )> }\n);\n\nexport type SaveUserAddressMutationVariables = Exact<{\n  description: Scalars['String'];\n  numberOrName?: Maybe<Scalars['String']>;\n  street?: Maybe<Scalars['String']>;\n  town?: Maybe<Scalars['String']>;\n  county?: Maybe<Scalars['String']>;\n  postcode?: Maybe<Scalars['String']>;\n  countryCode?: Maybe<Scalars['String']>;\n  userPrimary?: Maybe<Scalars['Boolean']>;\n}>;\n\n\nexport type SaveUserAddressMutation = (\n  { __typename?: 'Mutation' }\n  & { saveUserAddress: (\n    { __typename?: 'Address' }\n    & Pick<Address, 'id' | 'description' | 'numberOrName' | 'street' | 'town' | 'county' | 'postcode' | 'countryCode' | 'userPrimary' | 'officePrimary'>\n  ) }\n);\n\nexport type SearchAirlinesQueryVariables = Exact<{\n  query: Scalars['String'];\n}>;\n\n\nexport type SearchAirlinesQuery = (\n  { __typename?: 'Query' }\n  & { searchAirlines: (\n    { __typename?: 'AirlineResults' }\n    & { iataMatch?: Maybe<(\n      { __typename?: 'AirlineResult' }\n      & Pick<AirlineResult, 'id' | 'name' | 'iata' | 'icao' | 'alias' | 'callsign' | 'active' | 'continent' | 'country' | 'countryCode' | 'bannerImage' | 'logoImage'>\n    )>, generalMatches: Array<(\n      { __typename?: 'AirlineResult' }\n      & Pick<AirlineResult, 'id' | 'name' | 'iata' | 'icao' | 'alias' | 'callsign' | 'active' | 'continent' | 'country' | 'countryCode' | 'bannerImage' | 'logoImage'>\n    )> }\n  ) }\n);\n\nexport type SearchCitiesQueryVariables = Exact<{\n  query: Scalars['String'];\n  countryCode?: Maybe<Scalars['String']>;\n}>;\n\n\nexport type SearchCitiesQuery = (\n  { __typename?: 'Query' }\n  & { searchCities: Array<(\n    { __typename?: 'City' }\n    & Pick<City, 'id' | 'name' | 'country' | 'countryCode' | 'continentName'>\n    & { coordinates: (\n      { __typename?: 'GeoCoordinates' }\n      & Pick<GeoCoordinates, 'latitude' | 'longitude' | 'altitude'>\n    ) }\n  )> }\n);\n\nexport type SearchConfermaCitiesQueryVariables = Exact<{\n  cityName: Scalars['String'];\n  countryCode: Scalars['String'];\n}>;\n\n\nexport type SearchConfermaCitiesQuery = (\n  { __typename?: 'Query' }\n  & { searchConfermaCities: (\n    { __typename?: 'ConfermaCityLocation' }\n    & Pick<ConfermaCityLocation, 'foundExact'>\n    & { suggestions?: Maybe<Array<Maybe<(\n      { __typename?: 'ConfermaCityLocationOptions' }\n      & Pick<ConfermaCityLocationOptions, 'name' | 'countryCode' | 'latitude' | 'longitude'>\n    )>>> }\n  ) }\n);\n\nexport type SearchEurostarQueryVariables = Exact<{\n  passengers: Array<FlightPassengerObject> | FlightPassengerObject;\n  originAirport?: Maybe<Scalars['String']>;\n  destinationAirport?: Maybe<Scalars['String']>;\n  multiDestination?: Maybe<Array<Maybe<DestinationEntry>> | Maybe<DestinationEntry>>;\n  outboundDate?: Maybe<Scalars['Date']>;\n  outboundDepartureTimeWindow?: Maybe<Scalars['String']>;\n  outboundArrivalTimeWindow?: Maybe<Scalars['String']>;\n  outboundCabinClass?: Maybe<Array<Maybe<FlightCabinClass>> | Maybe<FlightCabinClass>>;\n  returnTrip: Scalars['Boolean'];\n  returnDate?: Maybe<Scalars['Date']>;\n  returnDepartureTimeWindow?: Maybe<Scalars['String']>;\n  returnArrivalTimeWindow?: Maybe<Scalars['String']>;\n  returnCabinClass?: Maybe<Array<Maybe<FlightCabinClass>> | Maybe<FlightCabinClass>>;\n  fareType: FareType;\n  requireFreeBag?: Maybe<Scalars['Boolean']>;\n  maxConnections?: Maybe<Scalars['Int']>;\n  preferredCarriers?: Maybe<Array<Maybe<Scalars['String']>> | Maybe<Scalars['String']>>;\n  includeNearbyAirports?: Maybe<Scalars['Boolean']>;\n  asSingles?: Maybe<Scalars['Boolean']>;\n}>;\n\n\nexport type SearchEurostarQuery = (\n  { __typename?: 'Query' }\n  & { searchEurostar: (\n    { __typename?: 'FlightSearchResultV2' }\n    & { results: (\n      { __typename?: 'FEFlightSearchResults' }\n      & { journeys: Array<(\n        { __typename?: 'FlightItinerary' }\n        & Pick<FlightItinerary, 'uid' | 'passengerCount' | 'outboundTotalDuration' | 'inboundTotalDuration' | 'additional' | 'source' | 'sourceId' | 'version' | 'tmcPreferred' | 'companyPreferred' | 'officePreferred' | 'tmcPreferredMessage' | 'companyPreferredMessage' | 'officePreferredMessage' | 'unavailable' | 'unavailableMessage' | 'co2PerItem' | 'co2PerPassenger'>\n        & { outboundFlights: Array<(\n          { __typename?: 'FlightJourney' }\n          & Pick<FlightJourney, 'originAirport' | 'originTerminal' | 'originAirportName' | 'destinationAirport' | 'destinationTerminal' | 'destinationAirportName' | 'dateTimeDeparting' | 'dateTimeDepartingUTC' | 'dateTimeArriving' | 'dateTimeArrivingUTC' | 'marketingCarrier' | 'marketingCarrierName' | 'marketingFlightNumber' | 'operatingCarrier' | 'operatingCarrierName' | 'operatingFlightNumber' | 'equipmentCode' | 'equipmentName' | 'totalDuration' | 'cabinClass' | 'marketingNames' | 'vendorCode' | 'stops' | 'bookingCode' | 'marriageGroup' | 'fareBasisCode' | 'additional'>\n          & { fareInfo?: Maybe<(\n            { __typename?: 'FlightSpecialFareInfo' }\n            & Pick<FlightSpecialFareInfo, 'title' | 'type' | 'code' | 'supplierCode'>\n          )>, originAirportDetail: (\n            { __typename?: 'AirportDetail' }\n            & Pick<AirportDetail, 'iata' | 'icao' | 'latitude' | 'longitude' | 'altitude' | 'state' | 'city' | 'road' | 'popularity' | 'area' | 'location' | 'offset' | 'airportName' | 'countryName' | 'countryCode' | 'postcode'>\n          ), destinationAirportDetail: (\n            { __typename?: 'AirportDetail' }\n            & Pick<AirportDetail, 'iata' | 'icao' | 'latitude' | 'longitude' | 'altitude' | 'state' | 'city' | 'road' | 'popularity' | 'area' | 'location' | 'offset' | 'airportName' | 'countryName' | 'countryCode' | 'postcode'>\n          ), marketingCarrierDetail: (\n            { __typename?: 'FlightCarrierDetail' }\n            & Pick<FlightCarrierDetail, 'name' | 'alias' | 'callsign' | 'iata' | 'icao' | 'logo' | 'banner' | 'popularity'>\n          ), operatingCarrierDetail: (\n            { __typename?: 'FlightCarrierDetail' }\n            & Pick<FlightCarrierDetail, 'name' | 'alias' | 'callsign' | 'iata' | 'icao' | 'logo' | 'banner' | 'popularity'>\n          ), fareConditions: (\n            { __typename?: 'FareConditions' }\n            & { cancellation?: Maybe<Array<Maybe<(\n              { __typename?: 'FareConditionEntry' }\n              & Pick<FareConditionEntry, 'name' | 'type' | 'currency' | 'amount' | 'remark' | 'changeFeeInd' | 'cancelFeeInd' | 'refundableInd'>\n            )>>>, change?: Maybe<Array<Maybe<(\n              { __typename?: 'FareConditionEntry' }\n              & Pick<FareConditionEntry, 'name' | 'type' | 'currency' | 'amount' | 'remark' | 'changeFeeInd' | 'cancelFeeInd' | 'refundableInd'>\n            )>>>, noShow?: Maybe<Array<Maybe<(\n              { __typename?: 'FareConditionEntry' }\n              & Pick<FareConditionEntry, 'name' | 'type' | 'currency' | 'amount' | 'remark' | 'changeFeeInd' | 'cancelFeeInd' | 'refundableInd'>\n            )>>>, upgrade?: Maybe<Array<Maybe<(\n              { __typename?: 'FareConditionEntry' }\n              & Pick<FareConditionEntry, 'name' | 'type' | 'currency' | 'amount' | 'remark' | 'changeFeeInd' | 'cancelFeeInd' | 'refundableInd'>\n            )>>>, other?: Maybe<Array<Maybe<(\n              { __typename?: 'FareConditionEntry' }\n              & Pick<FareConditionEntry, 'name' | 'type' | 'currency' | 'amount' | 'remark' | 'changeFeeInd' | 'cancelFeeInd' | 'refundableInd'>\n            )>>> }\n          ) }\n        )>, inboundFlights?: Maybe<Array<Maybe<(\n          { __typename?: 'FlightJourney' }\n          & Pick<FlightJourney, 'originAirport' | 'originTerminal' | 'originAirportName' | 'destinationAirport' | 'destinationTerminal' | 'destinationAirportName' | 'dateTimeDeparting' | 'dateTimeDepartingUTC' | 'dateTimeArriving' | 'dateTimeArrivingUTC' | 'marketingCarrier' | 'marketingCarrierName' | 'marketingFlightNumber' | 'operatingCarrier' | 'operatingCarrierName' | 'operatingFlightNumber' | 'equipmentCode' | 'equipmentName' | 'totalDuration' | 'cabinClass' | 'marketingNames' | 'vendorCode' | 'stops' | 'bookingCode' | 'marriageGroup' | 'fareBasisCode' | 'additional'>\n          & { fareInfo?: Maybe<(\n            { __typename?: 'FlightSpecialFareInfo' }\n            & Pick<FlightSpecialFareInfo, 'title' | 'type' | 'code' | 'supplierCode'>\n          )>, originAirportDetail: (\n            { __typename?: 'AirportDetail' }\n            & Pick<AirportDetail, 'iata' | 'icao' | 'latitude' | 'longitude' | 'altitude' | 'state' | 'city' | 'road' | 'popularity' | 'area' | 'location' | 'offset' | 'airportName' | 'countryName' | 'countryCode' | 'postcode'>\n          ), destinationAirportDetail: (\n            { __typename?: 'AirportDetail' }\n            & Pick<AirportDetail, 'iata' | 'icao' | 'latitude' | 'longitude' | 'altitude' | 'state' | 'city' | 'road' | 'popularity' | 'area' | 'location' | 'offset' | 'airportName' | 'countryName' | 'countryCode' | 'postcode'>\n          ), marketingCarrierDetail: (\n            { __typename?: 'FlightCarrierDetail' }\n            & Pick<FlightCarrierDetail, 'name' | 'alias' | 'callsign' | 'iata' | 'icao' | 'logo' | 'banner' | 'popularity'>\n          ), operatingCarrierDetail: (\n            { __typename?: 'FlightCarrierDetail' }\n            & Pick<FlightCarrierDetail, 'name' | 'alias' | 'callsign' | 'iata' | 'icao' | 'logo' | 'banner' | 'popularity'>\n          ), fareConditions: (\n            { __typename?: 'FareConditions' }\n            & { cancellation?: Maybe<Array<Maybe<(\n              { __typename?: 'FareConditionEntry' }\n              & Pick<FareConditionEntry, 'name' | 'type' | 'currency' | 'amount' | 'remark' | 'changeFeeInd' | 'cancelFeeInd' | 'refundableInd'>\n            )>>>, change?: Maybe<Array<Maybe<(\n              { __typename?: 'FareConditionEntry' }\n              & Pick<FareConditionEntry, 'name' | 'type' | 'currency' | 'amount' | 'remark' | 'changeFeeInd' | 'cancelFeeInd' | 'refundableInd'>\n            )>>>, noShow?: Maybe<Array<Maybe<(\n              { __typename?: 'FareConditionEntry' }\n              & Pick<FareConditionEntry, 'name' | 'type' | 'currency' | 'amount' | 'remark' | 'changeFeeInd' | 'cancelFeeInd' | 'refundableInd'>\n            )>>>, upgrade?: Maybe<Array<Maybe<(\n              { __typename?: 'FareConditionEntry' }\n              & Pick<FareConditionEntry, 'name' | 'type' | 'currency' | 'amount' | 'remark' | 'changeFeeInd' | 'cancelFeeInd' | 'refundableInd'>\n            )>>>, other?: Maybe<Array<Maybe<(\n              { __typename?: 'FareConditionEntry' }\n              & Pick<FareConditionEntry, 'name' | 'type' | 'currency' | 'amount' | 'remark' | 'changeFeeInd' | 'cancelFeeInd' | 'refundableInd'>\n            )>>> }\n          ) }\n        )>>>, outboundCarbonEmissions?: Maybe<(\n          { __typename?: 'FlightCarbonEmissions' }\n          & Pick<FlightCarbonEmissions, 'amount' | 'unit'>\n        )>, inboundCarbonEmissions?: Maybe<(\n          { __typename?: 'FlightCarbonEmissions' }\n          & Pick<FlightCarbonEmissions, 'amount' | 'unit'>\n        )>, taxes?: Maybe<Array<Maybe<(\n          { __typename?: 'FlightAmount' }\n          & Pick<FlightAmount, 'description' | 'amount' | 'currency'>\n        )>>>, discounts?: Maybe<Array<Maybe<(\n          { __typename?: 'FlightAmount' }\n          & Pick<FlightAmount, 'description' | 'amount' | 'currency'>\n        )>>>, total: (\n          { __typename?: 'FlightFareTotal' }\n          & Pick<FlightFareTotal, 'price' | 'tax' | 'discount' | 'currency'>\n        ), fareConditions?: Maybe<(\n          { __typename?: 'FareConditions' }\n          & { cancellation?: Maybe<Array<Maybe<(\n            { __typename?: 'FareConditionEntry' }\n            & Pick<FareConditionEntry, 'name' | 'type' | 'currency' | 'amount' | 'remark' | 'changeFeeInd' | 'cancelFeeInd' | 'refundableInd'>\n          )>>>, change?: Maybe<Array<Maybe<(\n            { __typename?: 'FareConditionEntry' }\n            & Pick<FareConditionEntry, 'name' | 'type' | 'currency' | 'amount' | 'remark' | 'changeFeeInd' | 'cancelFeeInd' | 'refundableInd'>\n          )>>>, noShow?: Maybe<Array<Maybe<(\n            { __typename?: 'FareConditionEntry' }\n            & Pick<FareConditionEntry, 'name' | 'type' | 'currency' | 'amount' | 'remark' | 'changeFeeInd' | 'cancelFeeInd' | 'refundableInd'>\n          )>>>, upgrade?: Maybe<Array<Maybe<(\n            { __typename?: 'FareConditionEntry' }\n            & Pick<FareConditionEntry, 'name' | 'type' | 'currency' | 'amount' | 'remark' | 'changeFeeInd' | 'cancelFeeInd' | 'refundableInd'>\n          )>>>, other?: Maybe<Array<Maybe<(\n            { __typename?: 'FareConditionEntry' }\n            & Pick<FareConditionEntry, 'name' | 'type' | 'currency' | 'amount' | 'remark' | 'changeFeeInd' | 'cancelFeeInd' | 'refundableInd'>\n          )>>> }\n        )>, baggageAllowance?: Maybe<Array<Maybe<(\n          { __typename?: 'BaggageAllowance' }\n          & Pick<BaggageAllowance, 'type' | 'qty' | 'maxKG' | 'maxLBS'>\n        )>>> }\n      )>, multi: Array<(\n        { __typename?: 'ItinerarySummary' }\n        & Pick<ItinerarySummary, 'order' | 'origin' | 'destination' | 'minPrice' | 'maxPrice'>\n        & { results: Array<(\n          { __typename?: 'FlightItinerary' }\n          & Pick<FlightItinerary, 'uid' | 'passengerCount' | 'outboundTotalDuration' | 'inboundTotalDuration' | 'additional' | 'source' | 'sourceId' | 'version' | 'tmcPreferred' | 'companyPreferred' | 'officePreferred' | 'tmcPreferredMessage' | 'companyPreferredMessage' | 'officePreferredMessage' | 'unavailable' | 'unavailableMessage' | 'co2PerItem' | 'co2PerPassenger'>\n          & { outboundFlights: Array<(\n            { __typename?: 'FlightJourney' }\n            & Pick<FlightJourney, 'originAirport' | 'originTerminal' | 'originAirportName' | 'destinationAirport' | 'destinationTerminal' | 'destinationAirportName' | 'dateTimeDeparting' | 'dateTimeDepartingUTC' | 'dateTimeArriving' | 'dateTimeArrivingUTC' | 'marketingCarrier' | 'marketingCarrierName' | 'marketingFlightNumber' | 'operatingCarrier' | 'operatingCarrierName' | 'operatingFlightNumber' | 'equipmentCode' | 'equipmentName' | 'totalDuration' | 'cabinClass' | 'marketingNames' | 'vendorCode' | 'stops' | 'bookingCode' | 'marriageGroup' | 'fareBasisCode' | 'additional'>\n            & { fareInfo?: Maybe<(\n              { __typename?: 'FlightSpecialFareInfo' }\n              & Pick<FlightSpecialFareInfo, 'title' | 'type' | 'code' | 'supplierCode'>\n            )>, originAirportDetail: (\n              { __typename?: 'AirportDetail' }\n              & Pick<AirportDetail, 'iata' | 'icao' | 'latitude' | 'longitude' | 'altitude' | 'state' | 'city' | 'road' | 'popularity' | 'area' | 'location' | 'offset' | 'airportName' | 'countryName' | 'countryCode' | 'postcode'>\n            ), destinationAirportDetail: (\n              { __typename?: 'AirportDetail' }\n              & Pick<AirportDetail, 'iata' | 'icao' | 'latitude' | 'longitude' | 'altitude' | 'state' | 'city' | 'road' | 'popularity' | 'area' | 'location' | 'offset' | 'airportName' | 'countryName' | 'countryCode' | 'postcode'>\n            ), marketingCarrierDetail: (\n              { __typename?: 'FlightCarrierDetail' }\n              & Pick<FlightCarrierDetail, 'name' | 'alias' | 'callsign' | 'iata' | 'icao' | 'logo' | 'banner' | 'popularity'>\n            ), operatingCarrierDetail: (\n              { __typename?: 'FlightCarrierDetail' }\n              & Pick<FlightCarrierDetail, 'name' | 'alias' | 'callsign' | 'iata' | 'icao' | 'logo' | 'banner' | 'popularity'>\n            ), fareConditions: (\n              { __typename?: 'FareConditions' }\n              & { cancellation?: Maybe<Array<Maybe<(\n                { __typename?: 'FareConditionEntry' }\n                & Pick<FareConditionEntry, 'name' | 'type' | 'currency' | 'amount' | 'remark' | 'changeFeeInd' | 'cancelFeeInd' | 'refundableInd'>\n              )>>>, change?: Maybe<Array<Maybe<(\n                { __typename?: 'FareConditionEntry' }\n                & Pick<FareConditionEntry, 'name' | 'type' | 'currency' | 'amount' | 'remark' | 'changeFeeInd' | 'cancelFeeInd' | 'refundableInd'>\n              )>>>, noShow?: Maybe<Array<Maybe<(\n                { __typename?: 'FareConditionEntry' }\n                & Pick<FareConditionEntry, 'name' | 'type' | 'currency' | 'amount' | 'remark' | 'changeFeeInd' | 'cancelFeeInd' | 'refundableInd'>\n              )>>>, upgrade?: Maybe<Array<Maybe<(\n                { __typename?: 'FareConditionEntry' }\n                & Pick<FareConditionEntry, 'name' | 'type' | 'currency' | 'amount' | 'remark' | 'changeFeeInd' | 'cancelFeeInd' | 'refundableInd'>\n              )>>>, other?: Maybe<Array<Maybe<(\n                { __typename?: 'FareConditionEntry' }\n                & Pick<FareConditionEntry, 'name' | 'type' | 'currency' | 'amount' | 'remark' | 'changeFeeInd' | 'cancelFeeInd' | 'refundableInd'>\n              )>>> }\n            ) }\n          )>, inboundFlights?: Maybe<Array<Maybe<(\n            { __typename?: 'FlightJourney' }\n            & Pick<FlightJourney, 'originAirport' | 'originTerminal' | 'originAirportName' | 'destinationAirport' | 'destinationTerminal' | 'destinationAirportName' | 'dateTimeDeparting' | 'dateTimeDepartingUTC' | 'dateTimeArriving' | 'dateTimeArrivingUTC' | 'marketingCarrier' | 'marketingCarrierName' | 'marketingFlightNumber' | 'operatingCarrier' | 'operatingCarrierName' | 'operatingFlightNumber' | 'equipmentCode' | 'equipmentName' | 'totalDuration' | 'cabinClass' | 'marketingNames' | 'vendorCode' | 'stops' | 'bookingCode' | 'marriageGroup' | 'fareBasisCode' | 'additional'>\n            & { fareInfo?: Maybe<(\n              { __typename?: 'FlightSpecialFareInfo' }\n              & Pick<FlightSpecialFareInfo, 'title' | 'type' | 'code' | 'supplierCode'>\n            )>, originAirportDetail: (\n              { __typename?: 'AirportDetail' }\n              & Pick<AirportDetail, 'iata' | 'icao' | 'latitude' | 'longitude' | 'altitude' | 'state' | 'city' | 'road' | 'popularity' | 'area' | 'location' | 'offset' | 'airportName' | 'countryName' | 'countryCode' | 'postcode'>\n            ), destinationAirportDetail: (\n              { __typename?: 'AirportDetail' }\n              & Pick<AirportDetail, 'iata' | 'icao' | 'latitude' | 'longitude' | 'altitude' | 'state' | 'city' | 'road' | 'popularity' | 'area' | 'location' | 'offset' | 'airportName' | 'countryName' | 'countryCode' | 'postcode'>\n            ), marketingCarrierDetail: (\n              { __typename?: 'FlightCarrierDetail' }\n              & Pick<FlightCarrierDetail, 'name' | 'alias' | 'callsign' | 'iata' | 'icao' | 'logo' | 'banner' | 'popularity'>\n            ), operatingCarrierDetail: (\n              { __typename?: 'FlightCarrierDetail' }\n              & Pick<FlightCarrierDetail, 'name' | 'alias' | 'callsign' | 'iata' | 'icao' | 'logo' | 'banner' | 'popularity'>\n            ), fareConditions: (\n              { __typename?: 'FareConditions' }\n              & { cancellation?: Maybe<Array<Maybe<(\n                { __typename?: 'FareConditionEntry' }\n                & Pick<FareConditionEntry, 'name' | 'type' | 'currency' | 'amount' | 'remark' | 'changeFeeInd' | 'cancelFeeInd' | 'refundableInd'>\n              )>>>, change?: Maybe<Array<Maybe<(\n                { __typename?: 'FareConditionEntry' }\n                & Pick<FareConditionEntry, 'name' | 'type' | 'currency' | 'amount' | 'remark' | 'changeFeeInd' | 'cancelFeeInd' | 'refundableInd'>\n              )>>>, noShow?: Maybe<Array<Maybe<(\n                { __typename?: 'FareConditionEntry' }\n                & Pick<FareConditionEntry, 'name' | 'type' | 'currency' | 'amount' | 'remark' | 'changeFeeInd' | 'cancelFeeInd' | 'refundableInd'>\n              )>>>, upgrade?: Maybe<Array<Maybe<(\n                { __typename?: 'FareConditionEntry' }\n                & Pick<FareConditionEntry, 'name' | 'type' | 'currency' | 'amount' | 'remark' | 'changeFeeInd' | 'cancelFeeInd' | 'refundableInd'>\n              )>>>, other?: Maybe<Array<Maybe<(\n                { __typename?: 'FareConditionEntry' }\n                & Pick<FareConditionEntry, 'name' | 'type' | 'currency' | 'amount' | 'remark' | 'changeFeeInd' | 'cancelFeeInd' | 'refundableInd'>\n              )>>> }\n            ) }\n          )>>>, outboundCarbonEmissions?: Maybe<(\n            { __typename?: 'FlightCarbonEmissions' }\n            & Pick<FlightCarbonEmissions, 'amount' | 'unit'>\n          )>, inboundCarbonEmissions?: Maybe<(\n            { __typename?: 'FlightCarbonEmissions' }\n            & Pick<FlightCarbonEmissions, 'amount' | 'unit'>\n          )>, taxes?: Maybe<Array<Maybe<(\n            { __typename?: 'FlightAmount' }\n            & Pick<FlightAmount, 'description' | 'amount' | 'currency'>\n          )>>>, discounts?: Maybe<Array<Maybe<(\n            { __typename?: 'FlightAmount' }\n            & Pick<FlightAmount, 'description' | 'amount' | 'currency'>\n          )>>>, total: (\n            { __typename?: 'FlightFareTotal' }\n            & Pick<FlightFareTotal, 'price' | 'tax' | 'discount' | 'currency'>\n          ), fareConditions?: Maybe<(\n            { __typename?: 'FareConditions' }\n            & { cancellation?: Maybe<Array<Maybe<(\n              { __typename?: 'FareConditionEntry' }\n              & Pick<FareConditionEntry, 'name' | 'type' | 'currency' | 'amount' | 'remark' | 'changeFeeInd' | 'cancelFeeInd' | 'refundableInd'>\n            )>>>, change?: Maybe<Array<Maybe<(\n              { __typename?: 'FareConditionEntry' }\n              & Pick<FareConditionEntry, 'name' | 'type' | 'currency' | 'amount' | 'remark' | 'changeFeeInd' | 'cancelFeeInd' | 'refundableInd'>\n            )>>>, noShow?: Maybe<Array<Maybe<(\n              { __typename?: 'FareConditionEntry' }\n              & Pick<FareConditionEntry, 'name' | 'type' | 'currency' | 'amount' | 'remark' | 'changeFeeInd' | 'cancelFeeInd' | 'refundableInd'>\n            )>>>, upgrade?: Maybe<Array<Maybe<(\n              { __typename?: 'FareConditionEntry' }\n              & Pick<FareConditionEntry, 'name' | 'type' | 'currency' | 'amount' | 'remark' | 'changeFeeInd' | 'cancelFeeInd' | 'refundableInd'>\n            )>>>, other?: Maybe<Array<Maybe<(\n              { __typename?: 'FareConditionEntry' }\n              & Pick<FareConditionEntry, 'name' | 'type' | 'currency' | 'amount' | 'remark' | 'changeFeeInd' | 'cancelFeeInd' | 'refundableInd'>\n            )>>> }\n          )>, baggageAllowance?: Maybe<Array<Maybe<(\n            { __typename?: 'BaggageAllowance' }\n            & Pick<BaggageAllowance, 'type' | 'qty' | 'maxKG' | 'maxLBS'>\n          )>>> }\n        )> }\n      )>, grouped?: Maybe<Array<(\n        { __typename?: 'GroupFlights' }\n        & Pick<GroupFlights, 'referenceID' | 'flightID' | 'boundIndicator' | 'minPrice' | 'maxPrice'>\n        & { flights: (\n          { __typename?: 'MatchingFlights' }\n          & Pick<MatchingFlights, 'LiteEconomy' | 'EconomyRestricted' | 'EconomyNoBags' | 'Economy' | 'PremiumEconomy' | 'Business' | 'PremiumBusiness' | 'First' | 'PremiumFirst'>\n        ) }\n      )>> }\n    ), errors: Array<(\n      { __typename?: 'SearchError' }\n      & ErrorsFragment\n    )> }\n  ) }\n);\n\nexport type SearchHotelChainsQueryVariables = Exact<{\n  query: Scalars['String'];\n}>;\n\n\nexport type SearchHotelChainsQuery = (\n  { __typename?: 'Query' }\n  & Pick<Query, 'searchHotelChains'>\n);\n\nexport type SearchIrlQueryVariables = Exact<{\n  supplier: IrlSupplier;\n  countryCode: Scalars['String'];\n  journeyType: IrlJourneyType;\n  class?: Maybe<IrlClass>;\n  outboundDepartureDateTime: Scalars['DateTime'];\n  departureLocationId: Scalars['ID'];\n  arrivalLocationId: Scalars['ID'];\n  adults: Scalars['Int'];\n  children?: Maybe<Scalars['Int']>;\n  returnDepartureDateTime?: Maybe<Scalars['DateTime']>;\n}>;\n\n\nexport type SearchIrlQuery = (\n  { __typename?: 'Query' }\n  & { searchIRL: (\n    { __typename?: 'IRLSearchResult' }\n    & { results: Array<(\n      { __typename?: 'IRLJourneyOptions' }\n      & Pick<IrlJourneyOptions, 'source' | 'sourceId'>\n      & { outbound?: Maybe<Array<(\n        { __typename?: 'IRLJourneyOption' }\n        & Pick<IrlJourneyOption, 'from' | 'fromCode' | 'to' | 'toCode' | 'departDateTime' | 'arriveDateTime' | 'changes' | 'unsellable'>\n        & { identifiers?: Maybe<(\n          { __typename?: 'IRLIdentifiers' }\n          & Pick<IrlIdentifiers, 'transactionIdentifier' | 'signature' | 'journeyIdentifier' | 'provider' | 'fareIdentifier' | 'direction' | 'singleOrReturn' | 'bookingRef'>\n        )>, travellers?: Maybe<Array<(\n          { __typename?: 'IRLTraveller' }\n          & Pick<IrlTraveller, 'status' | 'id' | 'dob' | 'railcard' | 'givenName' | 'surname' | 'nameTitle' | 'contactInfo' | 'deliveryEmailAddress' | 'fare'>\n        )>>, segments?: Maybe<Array<(\n          { __typename?: 'IRLSegment' }\n          & Pick<IrlSegment, 'id' | 'operator' | 'depart' | 'departDateTime' | 'arrive' | 'arriveDateTime' | 'reservableStatus' | 'seatPreferenceGroup'>\n          & { seatPreferenceTypes?: Maybe<Array<(\n            { __typename?: 'IRLSeatPreferenceType' }\n            & Pick<IrlSeatPreferenceType, 'name' | 'allowedValues'>\n          )>>, seats?: Maybe<Array<(\n            { __typename?: 'IRLSeat' }\n            & Pick<IrlSeat, 'location' | 'coach' | 'number' | 'direction' | 'position' | 'deck' | 'seatType' | 'seatSelection' | 'facilities' | 'note'>\n          )>> }\n        )>>, providers?: Maybe<Array<(\n          { __typename?: 'IRLProvider' }\n          & Pick<IrlProvider, 'providerId' | 'name'>\n          & { cheapestTicket?: Maybe<(\n            { __typename?: 'IRLTicketOption' }\n            & Pick<IrlTicketOption, 'type' | 'class' | 'singleOrReturn' | 'price' | 'reservableStatus' | 'currency' | 'route' | 'routeCode'>\n            & { identifiers?: Maybe<(\n              { __typename?: 'IRLIdentifiers' }\n              & Pick<IrlIdentifiers, 'transactionIdentifier' | 'signature' | 'journeyIdentifier' | 'provider' | 'fareIdentifier' | 'direction' | 'singleOrReturn' | 'bookingRef'>\n            )>, tickets?: Maybe<Array<Maybe<(\n              { __typename?: 'IRLTicket' }\n              & Pick<IrlTicket, 'price' | 'type' | 'route' | 'numChildren' | 'numAdults'>\n              & { segments?: Maybe<Array<(\n                { __typename?: 'IRLSegment' }\n                & Pick<IrlSegment, 'id' | 'operator' | 'depart' | 'departDateTime' | 'arrive' | 'arriveDateTime' | 'reservableStatus' | 'seatPreferenceGroup'>\n                & { seatPreferenceTypes?: Maybe<Array<(\n                  { __typename?: 'IRLSeatPreferenceType' }\n                  & Pick<IrlSeatPreferenceType, 'name' | 'allowedValues'>\n                )>>, seats?: Maybe<Array<(\n                  { __typename?: 'IRLSeat' }\n                  & Pick<IrlSeat, 'location' | 'coach' | 'number' | 'direction' | 'position' | 'deck' | 'seatType' | 'seatSelection' | 'facilities' | 'note'>\n                )>> }\n              )>> }\n            )>>> }\n          )>, ticketOptions?: Maybe<Array<Maybe<(\n            { __typename?: 'IRLTicketOption' }\n            & Pick<IrlTicketOption, 'type' | 'class' | 'singleOrReturn' | 'price' | 'reservableStatus' | 'currency' | 'route' | 'routeCode'>\n            & { identifiers?: Maybe<(\n              { __typename?: 'IRLIdentifiers' }\n              & Pick<IrlIdentifiers, 'transactionIdentifier' | 'signature' | 'journeyIdentifier' | 'provider' | 'fareIdentifier' | 'direction' | 'singleOrReturn' | 'bookingRef'>\n            )>, tickets?: Maybe<Array<Maybe<(\n              { __typename?: 'IRLTicket' }\n              & Pick<IrlTicket, 'price' | 'type' | 'route' | 'numChildren' | 'numAdults'>\n              & { segments?: Maybe<Array<(\n                { __typename?: 'IRLSegment' }\n                & Pick<IrlSegment, 'id' | 'operator' | 'depart' | 'departDateTime' | 'arrive' | 'arriveDateTime' | 'reservableStatus' | 'seatPreferenceGroup'>\n                & { seatPreferenceTypes?: Maybe<Array<(\n                  { __typename?: 'IRLSeatPreferenceType' }\n                  & Pick<IrlSeatPreferenceType, 'name' | 'allowedValues'>\n                )>>, seats?: Maybe<Array<(\n                  { __typename?: 'IRLSeat' }\n                  & Pick<IrlSeat, 'location' | 'coach' | 'number' | 'direction' | 'position' | 'deck' | 'seatType' | 'seatSelection' | 'facilities' | 'note'>\n                )>> }\n              )>> }\n            )>>> }\n          )>>>, bookedTicket?: Maybe<(\n            { __typename?: 'IRLTicketOption' }\n            & Pick<IrlTicketOption, 'type' | 'class' | 'singleOrReturn' | 'price' | 'reservableStatus' | 'currency' | 'route' | 'routeCode'>\n            & { identifiers?: Maybe<(\n              { __typename?: 'IRLIdentifiers' }\n              & Pick<IrlIdentifiers, 'transactionIdentifier' | 'signature' | 'journeyIdentifier' | 'provider' | 'fareIdentifier' | 'direction' | 'singleOrReturn' | 'bookingRef'>\n            )>, tickets?: Maybe<Array<Maybe<(\n              { __typename?: 'IRLTicket' }\n              & Pick<IrlTicket, 'price' | 'type' | 'route' | 'numChildren' | 'numAdults'>\n              & { segments?: Maybe<Array<(\n                { __typename?: 'IRLSegment' }\n                & Pick<IrlSegment, 'id' | 'operator' | 'depart' | 'departDateTime' | 'arrive' | 'arriveDateTime' | 'reservableStatus' | 'seatPreferenceGroup'>\n                & { seatPreferenceTypes?: Maybe<Array<(\n                  { __typename?: 'IRLSeatPreferenceType' }\n                  & Pick<IrlSeatPreferenceType, 'name' | 'allowedValues'>\n                )>>, seats?: Maybe<Array<(\n                  { __typename?: 'IRLSeat' }\n                  & Pick<IrlSeat, 'location' | 'coach' | 'number' | 'direction' | 'position' | 'deck' | 'seatType' | 'seatSelection' | 'facilities' | 'note'>\n                )>> }\n              )>> }\n            )>>> }\n          )> }\n        )>>, ticketExtras?: Maybe<Array<(\n          { __typename?: 'IRLTicketExtra' }\n          & Pick<IrlTicketExtra, 'type' | 'location' | 'date' | 'description' | 'amount' | 'adultAmount' | 'childAmount' | 'currency'>\n          & { identifiers?: Maybe<(\n            { __typename?: 'IRLTicketExtraIdentifiers' }\n            & Pick<IrlTicketExtraIdentifiers, 'type' | 'location' | 'date' | 'journeyId' | 'isOrigin'>\n          )> }\n        )>>, plusBus?: Maybe<(\n          { __typename?: 'IRLPlusBus' }\n          & Pick<IrlPlusBus, 'originPlusBusNLC' | 'originStationNLC' | 'destinationPlusBusNLC' | 'destinationStationNLC'>\n        )> }\n      )>>, return?: Maybe<Array<(\n        { __typename?: 'IRLJourneyOption' }\n        & Pick<IrlJourneyOption, 'from' | 'fromCode' | 'to' | 'toCode' | 'departDateTime' | 'arriveDateTime' | 'changes' | 'unsellable'>\n        & { identifiers?: Maybe<(\n          { __typename?: 'IRLIdentifiers' }\n          & Pick<IrlIdentifiers, 'transactionIdentifier' | 'signature' | 'journeyIdentifier' | 'provider' | 'fareIdentifier' | 'direction' | 'singleOrReturn' | 'bookingRef'>\n        )>, travellers?: Maybe<Array<(\n          { __typename?: 'IRLTraveller' }\n          & Pick<IrlTraveller, 'status' | 'id' | 'dob' | 'railcard' | 'givenName' | 'surname' | 'nameTitle' | 'contactInfo' | 'deliveryEmailAddress' | 'fare'>\n        )>>, segments?: Maybe<Array<(\n          { __typename?: 'IRLSegment' }\n          & Pick<IrlSegment, 'id' | 'operator' | 'depart' | 'departDateTime' | 'arrive' | 'arriveDateTime' | 'reservableStatus' | 'seatPreferenceGroup'>\n          & { seatPreferenceTypes?: Maybe<Array<(\n            { __typename?: 'IRLSeatPreferenceType' }\n            & Pick<IrlSeatPreferenceType, 'name' | 'allowedValues'>\n          )>>, seats?: Maybe<Array<(\n            { __typename?: 'IRLSeat' }\n            & Pick<IrlSeat, 'location' | 'coach' | 'number' | 'direction' | 'position' | 'deck' | 'seatType' | 'seatSelection' | 'facilities' | 'note'>\n          )>> }\n        )>>, providers?: Maybe<Array<(\n          { __typename?: 'IRLProvider' }\n          & Pick<IrlProvider, 'providerId' | 'name'>\n          & { cheapestTicket?: Maybe<(\n            { __typename?: 'IRLTicketOption' }\n            & Pick<IrlTicketOption, 'type' | 'class' | 'singleOrReturn' | 'price' | 'reservableStatus' | 'currency' | 'route' | 'routeCode'>\n            & { identifiers?: Maybe<(\n              { __typename?: 'IRLIdentifiers' }\n              & Pick<IrlIdentifiers, 'transactionIdentifier' | 'signature' | 'journeyIdentifier' | 'provider' | 'fareIdentifier' | 'direction' | 'singleOrReturn' | 'bookingRef'>\n            )>, tickets?: Maybe<Array<Maybe<(\n              { __typename?: 'IRLTicket' }\n              & Pick<IrlTicket, 'price' | 'type' | 'route' | 'numChildren' | 'numAdults'>\n              & { segments?: Maybe<Array<(\n                { __typename?: 'IRLSegment' }\n                & Pick<IrlSegment, 'id' | 'operator' | 'depart' | 'departDateTime' | 'arrive' | 'arriveDateTime' | 'reservableStatus' | 'seatPreferenceGroup'>\n                & { seatPreferenceTypes?: Maybe<Array<(\n                  { __typename?: 'IRLSeatPreferenceType' }\n                  & Pick<IrlSeatPreferenceType, 'name' | 'allowedValues'>\n                )>>, seats?: Maybe<Array<(\n                  { __typename?: 'IRLSeat' }\n                  & Pick<IrlSeat, 'location' | 'coach' | 'number' | 'direction' | 'position' | 'deck' | 'seatType' | 'seatSelection' | 'facilities' | 'note'>\n                )>> }\n              )>> }\n            )>>> }\n          )>, ticketOptions?: Maybe<Array<Maybe<(\n            { __typename?: 'IRLTicketOption' }\n            & Pick<IrlTicketOption, 'type' | 'class' | 'singleOrReturn' | 'price' | 'reservableStatus' | 'currency' | 'route' | 'routeCode'>\n            & { identifiers?: Maybe<(\n              { __typename?: 'IRLIdentifiers' }\n              & Pick<IrlIdentifiers, 'transactionIdentifier' | 'signature' | 'journeyIdentifier' | 'provider' | 'fareIdentifier' | 'direction' | 'singleOrReturn' | 'bookingRef'>\n            )>, tickets?: Maybe<Array<Maybe<(\n              { __typename?: 'IRLTicket' }\n              & Pick<IrlTicket, 'price' | 'type' | 'route' | 'numChildren' | 'numAdults'>\n              & { segments?: Maybe<Array<(\n                { __typename?: 'IRLSegment' }\n                & Pick<IrlSegment, 'id' | 'operator' | 'depart' | 'departDateTime' | 'arrive' | 'arriveDateTime' | 'reservableStatus' | 'seatPreferenceGroup'>\n                & { seatPreferenceTypes?: Maybe<Array<(\n                  { __typename?: 'IRLSeatPreferenceType' }\n                  & Pick<IrlSeatPreferenceType, 'name' | 'allowedValues'>\n                )>>, seats?: Maybe<Array<(\n                  { __typename?: 'IRLSeat' }\n                  & Pick<IrlSeat, 'location' | 'coach' | 'number' | 'direction' | 'position' | 'deck' | 'seatType' | 'seatSelection' | 'facilities' | 'note'>\n                )>> }\n              )>> }\n            )>>> }\n          )>>>, bookedTicket?: Maybe<(\n            { __typename?: 'IRLTicketOption' }\n            & Pick<IrlTicketOption, 'type' | 'class' | 'singleOrReturn' | 'price' | 'reservableStatus' | 'currency' | 'route' | 'routeCode'>\n            & { identifiers?: Maybe<(\n              { __typename?: 'IRLIdentifiers' }\n              & Pick<IrlIdentifiers, 'transactionIdentifier' | 'signature' | 'journeyIdentifier' | 'provider' | 'fareIdentifier' | 'direction' | 'singleOrReturn' | 'bookingRef'>\n            )>, tickets?: Maybe<Array<Maybe<(\n              { __typename?: 'IRLTicket' }\n              & Pick<IrlTicket, 'price' | 'type' | 'route' | 'numChildren' | 'numAdults'>\n              & { segments?: Maybe<Array<(\n                { __typename?: 'IRLSegment' }\n                & Pick<IrlSegment, 'id' | 'operator' | 'depart' | 'departDateTime' | 'arrive' | 'arriveDateTime' | 'reservableStatus' | 'seatPreferenceGroup'>\n                & { seatPreferenceTypes?: Maybe<Array<(\n                  { __typename?: 'IRLSeatPreferenceType' }\n                  & Pick<IrlSeatPreferenceType, 'name' | 'allowedValues'>\n                )>>, seats?: Maybe<Array<(\n                  { __typename?: 'IRLSeat' }\n                  & Pick<IrlSeat, 'location' | 'coach' | 'number' | 'direction' | 'position' | 'deck' | 'seatType' | 'seatSelection' | 'facilities' | 'note'>\n                )>> }\n              )>> }\n            )>>> }\n          )> }\n        )>>, ticketExtras?: Maybe<Array<(\n          { __typename?: 'IRLTicketExtra' }\n          & Pick<IrlTicketExtra, 'type' | 'location' | 'date' | 'description' | 'amount' | 'adultAmount' | 'childAmount' | 'currency'>\n          & { identifiers?: Maybe<(\n            { __typename?: 'IRLTicketExtraIdentifiers' }\n            & Pick<IrlTicketExtraIdentifiers, 'type' | 'location' | 'date' | 'journeyId' | 'isOrigin'>\n          )> }\n        )>>, plusBus?: Maybe<(\n          { __typename?: 'IRLPlusBus' }\n          & Pick<IrlPlusBus, 'originPlusBusNLC' | 'originStationNLC' | 'destinationPlusBusNLC' | 'destinationStationNLC'>\n        )> }\n      )>> }\n    )>, errors: Array<(\n      { __typename?: 'SearchError' }\n      & ErrorsFragment\n    )> }\n  ) }\n);\n\nexport type SearchPostcodesQueryVariables = Exact<{\n  postcode: Scalars['String'];\n}>;\n\n\nexport type SearchPostcodesQuery = (\n  { __typename?: 'Query' }\n  & { getPostcodeDetails: (\n    { __typename?: 'PostcodeDetails' }\n    & Pick<PostcodeDetails, 'postcode' | 'latitude' | 'longitude'>\n  ) }\n);\n\nexport type SearchRailStationsQueryVariables = Exact<{\n  query: Scalars['String'];\n  countryCode?: Maybe<Scalars['String']>;\n}>;\n\n\nexport type SearchRailStationsQuery = (\n  { __typename?: 'Query' }\n  & { searchRailStations: Array<(\n    { __typename?: 'RailStation' }\n    & Pick<RailStation, 'id' | 'name' | 'stationCode' | 'nlcCode' | 'trainlineCode' | 'trainlineUniqueCode'>\n    & { locationDetails?: Maybe<(\n      { __typename?: 'LocationDetail' }\n      & Pick<LocationDetail, 'continent' | 'country' | 'countryCode' | 'state' | 'city' | 'postcode' | 'road' | 'gridReference' | 'northing' | 'easting'>\n      & { coordinates?: Maybe<(\n        { __typename?: 'GeoCoordinates' }\n        & Pick<GeoCoordinates, 'latitude' | 'longitude' | 'altitude'>\n      )> }\n    )> }\n  )> }\n);\n\nexport type SearchUserAddressQueryVariables = Exact<{ [key: string]: never; }>;\n\n\nexport type SearchUserAddressQuery = (\n  { __typename?: 'Query' }\n  & { getUserAddresses: Array<(\n    { __typename?: 'Address' }\n    & Pick<Address, 'id' | 'description' | 'numberOrName' | 'street' | 'town' | 'county' | 'postcode' | 'countryCode' | 'userPrimary' | 'officePrimary'>\n  )> }\n);\n\nexport type SetBasketItemMiGroupMutationVariables = Exact<{\n  basketItem: Scalars['ID'];\n  group?: Maybe<Scalars['String']>;\n  withSupplemental?: Maybe<Scalars['Boolean']>;\n}>;\n\n\nexport type SetBasketItemMiGroupMutation = (\n  { __typename?: 'Mutation' }\n  & { setBasketItemMIGroup: (\n    { __typename?: 'Basket' }\n    & BasketFieldsFragment\n  ) }\n);\n\nexport type SetBasketItemLeadPassengerMutationVariables = Exact<{\n  id: Scalars['ID'];\n  user: Scalars['ID'];\n  withSupplemental: Scalars['Boolean'];\n}>;\n\n\nexport type SetBasketItemLeadPassengerMutation = (\n  { __typename?: 'Mutation' }\n  & { setBasketItemLeadPassenger: (\n    { __typename?: 'Basket' }\n    & BasketFieldsFragment\n  ) }\n);\n\nexport type SetBasketItemMiValueMutationVariables = Exact<{\n  mi: Scalars['ID'];\n  miValue?: Maybe<Scalars['ID']>;\n  miFreeValue?: Maybe<Scalars['String']>;\n  user?: Maybe<Scalars['ID']>;\n  withSupplemental?: Maybe<Scalars['Boolean']>;\n}>;\n\n\nexport type SetBasketItemMiValueMutation = (\n  { __typename?: 'Mutation' }\n  & { setBasketItemMIValue: (\n    { __typename?: 'Basket' }\n    & BasketFieldsFragment\n  ) }\n);\n\nexport type SetBasketItemPaymentMethodMutationVariables = Exact<{\n  basketItem: Scalars['ID'];\n  paymentMethod: Scalars['ID'];\n  withSupplemental?: Maybe<Scalars['Boolean']>;\n}>;\n\n\nexport type SetBasketItemPaymentMethodMutation = (\n  { __typename?: 'Mutation' }\n  & { setBasketItemPaymentMethod: (\n    { __typename?: 'Basket' }\n    & BasketFieldsFragment\n  ) }\n);\n\nexport type UpdateBasketNotesMutationVariables = Exact<{\n  id?: Maybe<Scalars['ID']>;\n  reference?: Maybe<Scalars['String']>;\n  notes: Scalars['String'];\n  withSupplemental?: Maybe<Scalars['Boolean']>;\n}>;\n\n\nexport type UpdateBasketNotesMutation = (\n  { __typename?: 'Mutation' }\n  & { updateBasketNotes: (\n    { __typename?: 'Basket' }\n    & BasketFieldsFragment\n  ) }\n);\n\nexport type UpdateBasketTitleMutationVariables = Exact<{\n  id?: Maybe<Scalars['ID']>;\n  reference?: Maybe<Scalars['String']>;\n  newTitle: Scalars['String'];\n  withSupplemental?: Maybe<Scalars['Boolean']>;\n}>;\n\n\nexport type UpdateBasketTitleMutation = (\n  { __typename?: 'Mutation' }\n  & { updateBasketTitle: (\n    { __typename?: 'Basket' }\n    & BasketFieldsFragment\n  ) }\n);\n\nexport type UserFieldsFragment = (\n  { __typename?: 'User' }\n  & Pick<User, 'id' | 'title' | 'forename' | 'surname' | 'email' | 'username' | 'employeeId' | 'createdAt' | 'updatedAt' | 'dob' | 'admin' | 'tmcAdmin' | 'companyAdmin' | 'bookerType' | 'authMethods' | 'active' | 'passwordLastUpdated'>\n  & { selectedLanguage: (\n    { __typename?: 'Language' }\n    & Pick<Language, 'id' | 'name' | 'isoCode'>\n  ), availableLanguages: Array<(\n    { __typename?: 'Language' }\n    & Pick<Language, 'id' | 'name' | 'isoCode'>\n  )>, passports: Array<(\n    { __typename?: 'Passport' }\n    & Pick<Passport, 'id' | 'number' | 'codeOfIssuingState' | 'nationality' | 'sex' | 'dob' | 'surname' | 'givenNames' | 'dateOfIssue' | 'createdAt' | 'updatedAt'>\n  )>, addresses: Array<(\n    { __typename?: 'Address' }\n    & Pick<Address, 'id' | 'description' | 'numberOrName' | 'street' | 'town' | 'county' | 'postcode' | 'countryCode' | 'userPrimary' | 'officePrimary'>\n  )>, phoneNumbers: Array<(\n    { __typename?: 'PhoneNumber' }\n    & Pick<PhoneNumber, 'id' | 'description' | 'countryCode' | 'areaCode' | 'number' | 'extension' | 'type' | 'officePrimary' | 'userPrimary'>\n  )> }\n);\n\nexport type GetUserServicesQueryVariables = Exact<{ [key: string]: never; }>;\n\n\nexport type GetUserServicesQuery = (\n  { __typename?: 'Query' }\n  & { getUserServices: Array<(\n    { __typename?: 'Service' }\n    & Pick<Service, 'id' | 'cancellable' | 'amendable' | 'type' | 'name' | 'description' | 'detailSchema' | 'searchQuerySchema'>\n  )> }\n);\n\nexport type GetUserUiConfigsQueryVariables = Exact<{ [key: string]: never; }>;\n\n\nexport type GetUserUiConfigsQuery = (\n  { __typename?: 'Query' }\n  & { getUserUIConfigs: (\n    { __typename?: 'UIConfigCollection' }\n    & { all: Array<(\n      { __typename?: 'UIConfig' }\n      & Pick<UiConfig, 'id' | 'config' | 'key'>\n    )> }\n  ) }\n);\n\nexport type GetUserMessagesQueryVariables = Exact<{ [key: string]: never; }>;\n\n\nexport type GetUserMessagesQuery = (\n  { __typename?: 'Query' }\n  & { getUserMessages: Array<(\n    { __typename?: 'Message' }\n    & Pick<Message, 'id' | 'name' | 'description' | 'config' | 'target' | 'key'>\n  )> }\n);\n\nexport type GetUserPhoneNumbersQueryVariables = Exact<{ [key: string]: never; }>;\n\n\nexport type GetUserPhoneNumbersQuery = (\n  { __typename?: 'Query' }\n  & { getUserPhoneNumbers: Array<(\n    { __typename?: 'PhoneNumber' }\n    & Pick<PhoneNumber, 'id' | 'description' | 'countryCode' | 'areaCode' | 'number' | 'extension' | 'type' | 'officePrimary' | 'userPrimary'>\n  )> }\n);\n\nexport type SetUserLanguageMutationVariables = Exact<{\n  language?: Maybe<Scalars['ID']>;\n}>;\n\n\nexport type SetUserLanguageMutation = (\n  { __typename?: 'Mutation' }\n  & { setUserLanguage: (\n    { __typename?: 'User' }\n    & Pick<User, 'id'>\n    & { selectedLanguage: (\n      { __typename?: 'Language' }\n      & Pick<Language, 'id' | 'name'>\n    ) }\n  ) }\n);\n\nexport type GetUserQueryVariables = Exact<{\n  id?: Maybe<Scalars['ID']>;\n}>;\n\n\nexport type GetUserQuery = (\n  { __typename?: 'Query' }\n  & { getUser: (\n    { __typename?: 'User' }\n    & UserFieldsFragment\n  ) }\n);\n\nexport type SearchUserCanBookForQueryVariables = Exact<{\n  email?: Maybe<Scalars['String']>;\n  userName?: Maybe<Scalars['String']>;\n  employeeId?: Maybe<Scalars['String']>;\n}>;\n\n\nexport type SearchUserCanBookForQuery = (\n  { __typename?: 'Query' }\n  & { searchUserCanBookFor: Array<(\n    { __typename?: 'User' }\n    & Pick<User, 'id' | 'forename' | 'surname' | 'email'>\n  )> }\n);\n\nexport type ValidateUserMiFreeValueQueryVariables = Exact<{\n  mi: Scalars['ID'];\n  freeValue: Scalars['String'];\n}>;\n\n\nexport type ValidateUserMiFreeValueQuery = (\n  { __typename?: 'Query' }\n  & Pick<Query, 'validateUserMIFreeValue'>\n);\n\nexport namespace AcceptNewPrice {\n  export type Variables = AcceptNewPriceMutationVariables;\n  export type Mutation = AcceptNewPriceMutation;\n  export type AcceptNewPrice = AcceptNewPriceMutation['acceptNewPrice'];\n}\n\nexport namespace AddUsersToBasketItem {\n  export type Variables = AddUsersToBasketItemMutationVariables;\n  export type Mutation = AddUsersToBasketItemMutation;\n  export type AddUsersToBasketItem = AddUsersToBasketItemMutation['addUsersToBasketItem'];\n}\n\nexport namespace TravellerFields {\n  export type Fragment = TravellerFieldsFragment;\n}\n\nexport namespace OwnerFields {\n  export type Fragment = OwnerFieldsFragment;\n}\n\nexport namespace BasketFields {\n  export type Fragment = BasketFieldsFragment;\n  export type Owner = BasketFieldsFragment['owner'];\n  export type BasketItems = BasketFieldsFragment['basketItems'][number];\n  export type AvailablePaymentMethods = BasketFieldsFragment['basketItems'][number]['availablePaymentMethods'][number];\n  export type SelectedPaymentMethod = BasketFieldsFragment['basketItems'][number]['selectedPaymentMethod'];\n  export type Service = BasketFieldsFragment['basketItems'][number]['service'];\n  export type Users = BasketFieldsFragment['basketItems'][number]['users'][number];\n  export type UserPassengerTypes = BasketFieldsFragment['basketItems'][number]['userPassengerTypes'][number];\n  export type LeadPassenger = BasketFieldsFragment['basketItems'][number]['leadPassenger'];\n  export type ManagementInfo = BasketFieldsFragment['basketItems'][number]['managementInfo'][number];\n  export type FixedValue = BasketFieldsFragment['basketItems'][number]['managementInfo'][number]['fixedValue'];\n  export type DefaultValue = BasketFieldsFragment['basketItems'][number]['managementInfo'][number]['defaultValue'];\n  export type Values = BasketFieldsFragment['basketItems'][number]['managementInfo'][number]['values'][number];\n  export type SelectedValues = BasketFieldsFragment['basketItems'][number]['managementInfo'][number]['selectedValues'][number];\n  export type Value = BasketFieldsFragment['basketItems'][number]['managementInfo'][number]['selectedValues'][number]['value'];\n  export type User = BasketFieldsFragment['basketItems'][number]['managementInfo'][number]['selectedValues'][number]['user'];\n  export type CompanyGroup = BasketFieldsFragment['companyGroup'];\n}\n\nexport namespace GetUserBaskets {\n  export type Variables = GetUserBasketsQueryVariables;\n  export type Query = GetUserBasketsQuery;\n  export type GetUserBaskets = GetUserBasketsQuery['getUserBaskets'][number];\n}\n\nexport namespace DeleteBasket {\n  export type Variables = DeleteBasketMutationVariables;\n  export type Mutation = DeleteBasketMutation;\n}\n\nexport namespace CreateBasket {\n  export type Variables = CreateBasketMutationVariables;\n  export type Mutation = CreateBasketMutation;\n  export type CreateBasket = CreateBasketMutation['createBasket'];\n}\n\nexport namespace RemoveItemFromBasket {\n  export type Variables = RemoveItemFromBasketMutationVariables;\n  export type Mutation = RemoveItemFromBasketMutation;\n  export type RemoveItemFromBasket = RemoveItemFromBasketMutation['removeItemFromBasket'];\n}\n\nexport namespace SendBasketForApproval {\n  export type Variables = SendBasketForApprovalMutationVariables;\n  export type Mutation = SendBasketForApprovalMutation;\n  export type SendBasketForApproval = SendBasketForApprovalMutation['sendBasketForApproval'];\n}\n\nexport namespace AddItemToBasket {\n  export type Variables = AddItemToBasketMutationVariables;\n  export type Mutation = AddItemToBasketMutation;\n  export type AddItemToBasket = AddItemToBasketMutation['addItemToBasket'];\n}\n\nexport namespace GetUserBasket {\n  export type Variables = GetUserBasketQueryVariables;\n  export type Query = GetUserBasketQuery;\n  export type GetUserBasket = GetUserBasketQuery['getUserBasket'];\n}\n\nexport namespace RevalidateBasket {\n  export type Variables = RevalidateBasketMutationVariables;\n  export type Mutation = RevalidateBasketMutation;\n  export type RevalidateBasket = RevalidateBasketMutation['revalidateBasket'];\n}\n\nexport namespace BookBasket {\n  export type Variables = BookBasketMutationVariables;\n  export type Mutation = BookBasketMutation;\n  export type BookBasket = BookBasketMutation['bookBasket'];\n}\n\nexport namespace SearchCabHire {\n  export type Variables = SearchCabHireQueryVariables;\n  export type Query = SearchCabHireQuery;\n  export type SearchCabHire = SearchCabHireQuery['searchCabHire'];\n  export type Results = SearchCabHireQuery['searchCabHire']['results'][number];\n  export type FromLocation = SearchCabHireQuery['searchCabHire']['results'][number]['fromLocation'];\n  export type ToLocation = SearchCabHireQuery['searchCabHire']['results'][number]['toLocation'];\n  export type Vias = SearchCabHireQuery['searchCabHire']['results'][number]['vias'][number];\n  export type Errors = SearchCabHireQuery['searchCabHire']['errors'][number];\n}\n\nexport namespace CarHireAvailabilityDetailRequest {\n  export type Variables = CarHireAvailabilityDetailRequestQueryVariables;\n  export type Query = CarHireAvailabilityDetailRequestQuery;\n  export type CarHireAvailabilityDetailRequest = CarHireAvailabilityDetailRequestQuery['carHireAvailabilityDetailRequest'];\n  export type Identifiers = CarHireAvailabilityDetailRequestQuery['carHireAvailabilityDetailRequest']['identifiers'];\n  export type Vendor = CarHireAvailabilityDetailRequestQuery['carHireAvailabilityDetailRequest']['vendor'];\n  export type Address = CarHireAvailabilityDetailRequestQuery['carHireAvailabilityDetailRequest']['address'];\n  export type AdditionalInfo = CarHireAvailabilityDetailRequestQuery['carHireAvailabilityDetailRequest']['additionalInfo'][number];\n  export type Custom = CarHireAvailabilityDetailRequestQuery['carHireAvailabilityDetailRequest']['additionalInfo'][number]['custom'][number];\n}\n\nexport namespace SearchCarHire {\n  export type Variables = SearchCarHireQueryVariables;\n  export type Query = SearchCarHireQuery;\n  export type SearchCarHire = SearchCarHireQuery['searchCarHire'];\n  export type Results = SearchCarHireQuery['searchCarHire']['results'][number];\n  export type Identifiers = SearchCarHireQuery['searchCarHire']['results'][number]['identifiers'];\n  export type DisplayRecord = SearchCarHireQuery['searchCarHire']['results'][number]['displayRecord'];\n  export type Vendor = SearchCarHireQuery['searchCarHire']['results'][number]['displayRecord']['vendor'];\n  export type Vehicle = SearchCarHireQuery['searchCarHire']['results'][number]['displayRecord']['vehicle'];\n  export type Charges = SearchCarHireQuery['searchCarHire']['results'][number]['displayRecord']['charges'][number];\n  export type PickupLocation = SearchCarHireQuery['searchCarHire']['results'][number]['displayRecord']['pickupLocation'];\n  export type ReturnLocation = SearchCarHireQuery['searchCarHire']['results'][number]['displayRecord']['returnLocation'];\n  export type AdditionalInfo = SearchCarHireQuery['searchCarHire']['results'][number]['displayRecord']['additionalInfo'][number];\n  export type Custom = SearchCarHireQuery['searchCarHire']['results'][number]['displayRecord']['additionalInfo'][number]['custom'][number];\n  export type Errors = SearchCarHireQuery['searchCarHire']['errors'][number];\n}\n\nexport namespace DeleteRecentSearch {\n  export type Variables = DeleteRecentSearchMutationVariables;\n  export type Mutation = DeleteRecentSearchMutation;\n}\n\nexport namespace DeleteUserAddress {\n  export type Variables = DeleteUserAddressMutationVariables;\n  export type Mutation = DeleteUserAddressMutation;\n}\n\nexport namespace Errors {\n  export type Fragment = ErrorsFragment;\n  export type Service = ErrorsFragment['service'];\n}\n\nexport namespace GroupedFields {\n  export type Fragment = GroupedFieldsFragment;\n  export type Flights = GroupedFieldsFragment['flights'];\n}\n\nexport namespace SearchFlightsV2 {\n  export type Variables = SearchFlightsV2QueryVariables;\n  export type Query = SearchFlightsV2Query;\n  export type SearchFlightsV2 = SearchFlightsV2Query['searchFlightsV2'];\n  export type Results = SearchFlightsV2Query['searchFlightsV2']['results'];\n  export type Journeys = SearchFlightsV2Query['searchFlightsV2']['results']['journeys'][number];\n  export type OutboundFlights = SearchFlightsV2Query['searchFlightsV2']['results']['journeys'][number]['outboundFlights'][number];\n  export type OriginAirportDetail = SearchFlightsV2Query['searchFlightsV2']['results']['journeys'][number]['outboundFlights'][number]['originAirportDetail'];\n  export type DestinationAirportDetail = SearchFlightsV2Query['searchFlightsV2']['results']['journeys'][number]['outboundFlights'][number]['destinationAirportDetail'];\n  export type MarketingCarrierDetail = SearchFlightsV2Query['searchFlightsV2']['results']['journeys'][number]['outboundFlights'][number]['marketingCarrierDetail'];\n  export type OperatingCarrierDetail = SearchFlightsV2Query['searchFlightsV2']['results']['journeys'][number]['outboundFlights'][number]['operatingCarrierDetail'];\n  export type FareConditions = SearchFlightsV2Query['searchFlightsV2']['results']['journeys'][number]['outboundFlights'][number]['fareConditions'];\n  export type Cancellation = SearchFlightsV2Query['searchFlightsV2']['results']['journeys'][number]['outboundFlights'][number]['fareConditions']['cancellation'][number];\n  export type Change = SearchFlightsV2Query['searchFlightsV2']['results']['journeys'][number]['outboundFlights'][number]['fareConditions']['change'][number];\n  export type NoShow = SearchFlightsV2Query['searchFlightsV2']['results']['journeys'][number]['outboundFlights'][number]['fareConditions']['noShow'][number];\n  export type Upgrade = SearchFlightsV2Query['searchFlightsV2']['results']['journeys'][number]['outboundFlights'][number]['fareConditions']['upgrade'][number];\n  export type Other = SearchFlightsV2Query['searchFlightsV2']['results']['journeys'][number]['outboundFlights'][number]['fareConditions']['other'][number];\n  export type InboundFlights = SearchFlightsV2Query['searchFlightsV2']['results']['journeys'][number]['inboundFlights'][number];\n  export type _OriginAirportDetail = SearchFlightsV2Query['searchFlightsV2']['results']['journeys'][number]['inboundFlights'][number]['originAirportDetail'];\n  export type _DestinationAirportDetail = SearchFlightsV2Query['searchFlightsV2']['results']['journeys'][number]['inboundFlights'][number]['destinationAirportDetail'];\n  export type _MarketingCarrierDetail = SearchFlightsV2Query['searchFlightsV2']['results']['journeys'][number]['inboundFlights'][number]['marketingCarrierDetail'];\n  export type _OperatingCarrierDetail = SearchFlightsV2Query['searchFlightsV2']['results']['journeys'][number]['inboundFlights'][number]['operatingCarrierDetail'];\n  export type _FareConditions = SearchFlightsV2Query['searchFlightsV2']['results']['journeys'][number]['inboundFlights'][number]['fareConditions'];\n  export type _Cancellation = SearchFlightsV2Query['searchFlightsV2']['results']['journeys'][number]['inboundFlights'][number]['fareConditions']['cancellation'][number];\n  export type _Change = SearchFlightsV2Query['searchFlightsV2']['results']['journeys'][number]['inboundFlights'][number]['fareConditions']['change'][number];\n  export type _NoShow = SearchFlightsV2Query['searchFlightsV2']['results']['journeys'][number]['inboundFlights'][number]['fareConditions']['noShow'][number];\n  export type _Upgrade = SearchFlightsV2Query['searchFlightsV2']['results']['journeys'][number]['inboundFlights'][number]['fareConditions']['upgrade'][number];\n  export type _Other = SearchFlightsV2Query['searchFlightsV2']['results']['journeys'][number]['inboundFlights'][number]['fareConditions']['other'][number];\n  export type OutboundCarbonEmissions = SearchFlightsV2Query['searchFlightsV2']['results']['journeys'][number]['outboundCarbonEmissions'];\n  export type InboundCarbonEmissions = SearchFlightsV2Query['searchFlightsV2']['results']['journeys'][number]['inboundCarbonEmissions'];\n  export type Taxes = SearchFlightsV2Query['searchFlightsV2']['results']['journeys'][number]['taxes'][number];\n  export type Discounts = SearchFlightsV2Query['searchFlightsV2']['results']['journeys'][number]['discounts'][number];\n  export type Total = SearchFlightsV2Query['searchFlightsV2']['results']['journeys'][number]['total'];\n  export type __FareConditions = SearchFlightsV2Query['searchFlightsV2']['results']['journeys'][number]['fareConditions'];\n  export type __Cancellation = SearchFlightsV2Query['searchFlightsV2']['results']['journeys'][number]['fareConditions']['cancellation'][number];\n  export type __Change = SearchFlightsV2Query['searchFlightsV2']['results']['journeys'][number]['fareConditions']['change'][number];\n  export type __NoShow = SearchFlightsV2Query['searchFlightsV2']['results']['journeys'][number]['fareConditions']['noShow'][number];\n  export type __Upgrade = SearchFlightsV2Query['searchFlightsV2']['results']['journeys'][number]['fareConditions']['upgrade'][number];\n  export type __Other = SearchFlightsV2Query['searchFlightsV2']['results']['journeys'][number]['fareConditions']['other'][number];\n  export type BaggageAllowance = SearchFlightsV2Query['searchFlightsV2']['results']['journeys'][number]['baggageAllowance'][number];\n  export type Multi = SearchFlightsV2Query['searchFlightsV2']['results']['multi'][number];\n  export type _Results = SearchFlightsV2Query['searchFlightsV2']['results']['multi'][number]['results'][number];\n  export type _OutboundFlights = SearchFlightsV2Query['searchFlightsV2']['results']['multi'][number]['results'][number]['outboundFlights'][number];\n  export type __OriginAirportDetail = SearchFlightsV2Query['searchFlightsV2']['results']['multi'][number]['results'][number]['outboundFlights'][number]['originAirportDetail'];\n  export type __DestinationAirportDetail = SearchFlightsV2Query['searchFlightsV2']['results']['multi'][number]['results'][number]['outboundFlights'][number]['destinationAirportDetail'];\n  export type __MarketingCarrierDetail = SearchFlightsV2Query['searchFlightsV2']['results']['multi'][number]['results'][number]['outboundFlights'][number]['marketingCarrierDetail'];\n  export type __OperatingCarrierDetail = SearchFlightsV2Query['searchFlightsV2']['results']['multi'][number]['results'][number]['outboundFlights'][number]['operatingCarrierDetail'];\n  export type ___FareConditions = SearchFlightsV2Query['searchFlightsV2']['results']['multi'][number]['results'][number]['outboundFlights'][number]['fareConditions'];\n  export type ___Cancellation = SearchFlightsV2Query['searchFlightsV2']['results']['multi'][number]['results'][number]['outboundFlights'][number]['fareConditions']['cancellation'][number];\n  export type ___Change = SearchFlightsV2Query['searchFlightsV2']['results']['multi'][number]['results'][number]['outboundFlights'][number]['fareConditions']['change'][number];\n  export type ___NoShow = SearchFlightsV2Query['searchFlightsV2']['results']['multi'][number]['results'][number]['outboundFlights'][number]['fareConditions']['noShow'][number];\n  export type ___Upgrade = SearchFlightsV2Query['searchFlightsV2']['results']['multi'][number]['results'][number]['outboundFlights'][number]['fareConditions']['upgrade'][number];\n  export type ___Other = SearchFlightsV2Query['searchFlightsV2']['results']['multi'][number]['results'][number]['outboundFlights'][number]['fareConditions']['other'][number];\n  export type _InboundFlights = SearchFlightsV2Query['searchFlightsV2']['results']['multi'][number]['results'][number]['inboundFlights'][number];\n  export type ___OriginAirportDetail = SearchFlightsV2Query['searchFlightsV2']['results']['multi'][number]['results'][number]['inboundFlights'][number]['originAirportDetail'];\n  export type ___DestinationAirportDetail = SearchFlightsV2Query['searchFlightsV2']['results']['multi'][number]['results'][number]['inboundFlights'][number]['destinationAirportDetail'];\n  export type ___MarketingCarrierDetail = SearchFlightsV2Query['searchFlightsV2']['results']['multi'][number]['results'][number]['inboundFlights'][number]['marketingCarrierDetail'];\n  export type ___OperatingCarrierDetail = SearchFlightsV2Query['searchFlightsV2']['results']['multi'][number]['results'][number]['inboundFlights'][number]['operatingCarrierDetail'];\n  export type ____FareConditions = SearchFlightsV2Query['searchFlightsV2']['results']['multi'][number]['results'][number]['inboundFlights'][number]['fareConditions'];\n  export type ____Cancellation = SearchFlightsV2Query['searchFlightsV2']['results']['multi'][number]['results'][number]['inboundFlights'][number]['fareConditions']['cancellation'][number];\n  export type ____Change = SearchFlightsV2Query['searchFlightsV2']['results']['multi'][number]['results'][number]['inboundFlights'][number]['fareConditions']['change'][number];\n  export type ____NoShow = SearchFlightsV2Query['searchFlightsV2']['results']['multi'][number]['results'][number]['inboundFlights'][number]['fareConditions']['noShow'][number];\n  export type ____Upgrade = SearchFlightsV2Query['searchFlightsV2']['results']['multi'][number]['results'][number]['inboundFlights'][number]['fareConditions']['upgrade'][number];\n  export type ____Other = SearchFlightsV2Query['searchFlightsV2']['results']['multi'][number]['results'][number]['inboundFlights'][number]['fareConditions']['other'][number];\n  export type _OutboundCarbonEmissions = SearchFlightsV2Query['searchFlightsV2']['results']['multi'][number]['results'][number]['outboundCarbonEmissions'];\n  export type _InboundCarbonEmissions = SearchFlightsV2Query['searchFlightsV2']['results']['multi'][number]['results'][number]['inboundCarbonEmissions'];\n  export type _Taxes = SearchFlightsV2Query['searchFlightsV2']['results']['multi'][number]['results'][number]['taxes'][number];\n  export type _Discounts = SearchFlightsV2Query['searchFlightsV2']['results']['multi'][number]['results'][number]['discounts'][number];\n  export type _Total = SearchFlightsV2Query['searchFlightsV2']['results']['multi'][number]['results'][number]['total'];\n  export type _____FareConditions = SearchFlightsV2Query['searchFlightsV2']['results']['multi'][number]['results'][number]['fareConditions'];\n  export type _____Cancellation = SearchFlightsV2Query['searchFlightsV2']['results']['multi'][number]['results'][number]['fareConditions']['cancellation'][number];\n  export type _____Change = SearchFlightsV2Query['searchFlightsV2']['results']['multi'][number]['results'][number]['fareConditions']['change'][number];\n  export type _____NoShow = SearchFlightsV2Query['searchFlightsV2']['results']['multi'][number]['results'][number]['fareConditions']['noShow'][number];\n  export type _____Upgrade = SearchFlightsV2Query['searchFlightsV2']['results']['multi'][number]['results'][number]['fareConditions']['upgrade'][number];\n  export type _____Other = SearchFlightsV2Query['searchFlightsV2']['results']['multi'][number]['results'][number]['fareConditions']['other'][number];\n  export type _BaggageAllowance = SearchFlightsV2Query['searchFlightsV2']['results']['multi'][number]['results'][number]['baggageAllowance'][number];\n  export type Grouped = SearchFlightsV2Query['searchFlightsV2']['results']['grouped'][number];\n  export type Errors = SearchFlightsV2Query['searchFlightsV2']['errors'][number];\n}\n\nexport namespace GetCarHireDepots {\n  export type Variables = GetCarHireDepotsQueryVariables;\n  export type Query = GetCarHireDepotsQuery;\n  export type GetCarHireDepots = GetCarHireDepotsQuery['getCarHireDepots'][number];\n}\n\nexport namespace GetConfermaOfficeNames {\n  export type Variables = GetConfermaOfficeNamesQueryVariables;\n  export type Query = GetConfermaOfficeNamesQuery;\n  export type GetConfermaOfficeNames = GetConfermaOfficeNamesQuery['getConfermaOfficeNames'];\n  export type Results = GetConfermaOfficeNamesQuery['getConfermaOfficeNames']['results'][number];\n  export type Errors = GetConfermaOfficeNamesQuery['getConfermaOfficeNames']['errors'][number];\n}\n\nexport namespace GetConfermaQuicklist {\n  export type Variables = GetConfermaQuicklistQueryVariables;\n  export type Query = GetConfermaQuicklistQuery;\n  export type GetConfermaQuicklist = GetConfermaQuicklistQuery['getConfermaQuicklist'];\n  export type Results = GetConfermaQuicklistQuery['getConfermaQuicklist']['results'][number];\n  export type Location = GetConfermaQuicklistQuery['getConfermaQuicklist']['results'][number]['location'];\n  export type Address = GetConfermaQuicklistQuery['getConfermaQuicklist']['results'][number]['address'];\n  export type Transports = GetConfermaQuicklistQuery['getConfermaQuicklist']['results'][number]['transports'][number];\n  export type Preferred = GetConfermaQuicklistQuery['getConfermaQuicklist']['results'][number]['preferred'];\n  export type Tags = GetConfermaQuicklistQuery['getConfermaQuicklist']['results'][number]['tags'][number];\n  export type AvailableRates = GetConfermaQuicklistQuery['getConfermaQuicklist']['results'][number]['availableRates'];\n  export type Rooms = GetConfermaQuicklistQuery['getConfermaQuicklist']['results'][number]['availableRates']['rooms'][number];\n  export type CurrencyConversion = GetConfermaQuicklistQuery['getConfermaQuicklist']['results'][number]['availableRates']['rooms'][number]['currencyConversion'];\n  export type Deposit = GetConfermaQuicklistQuery['getConfermaQuicklist']['results'][number]['availableRates']['rooms'][number]['deposit'];\n  export type Nights = GetConfermaQuicklistQuery['getConfermaQuicklist']['results'][number]['availableRates']['rooms'][number]['nights'][number];\n  export type Policies = GetConfermaQuicklistQuery['getConfermaQuicklist']['results'][number]['availableRates']['rooms'][number]['policies'];\n  export type Tax = GetConfermaQuicklistQuery['getConfermaQuicklist']['results'][number]['availableRates']['rooms'][number]['tax'];\n  export type AcceptedCards = GetConfermaQuicklistQuery['getConfermaQuicklist']['results'][number]['availableRates']['rooms'][number]['acceptedCards'][number];\n  export type PaymentTypes = GetConfermaQuicklistQuery['getConfermaQuicklist']['results'][number]['availableRates']['rooms'][number]['paymentTypes'][number];\n  export type Errors = GetConfermaQuicklistQuery['getConfermaQuicklist']['errors'][number];\n}\n\nexport namespace GetRailStation {\n  export type Variables = GetRailStationQueryVariables;\n  export type Query = GetRailStationQuery;\n  export type GetRailStation = GetRailStationQuery['getRailStation'];\n  export type LocationDetails = GetRailStationQuery['getRailStation']['locationDetails'];\n  export type Coordinates = GetRailStationQuery['getRailStation']['locationDetails']['coordinates'];\n}\n\nexport namespace GetRailcards {\n  export type Variables = GetRailcardsQueryVariables;\n  export type Query = GetRailcardsQuery;\n  export type GetRailcards = GetRailcardsQuery['getRailcards'][number];\n}\n\nexport namespace GetRiskAlerts {\n  export type Variables = GetRiskAlertsQueryVariables;\n  export type Query = GetRiskAlertsQuery;\n  export type GetRiskAlerts = GetRiskAlertsQuery['getRiskAlerts'][number];\n}\n\nexport namespace GetUserAddresses {\n  export type Variables = GetUserAddressesQueryVariables;\n  export type Query = GetUserAddressesQuery;\n  export type GetUserAddresses = GetUserAddressesQuery['getUserAddresses'][number];\n}\n\nexport namespace GetUserCompanyOffices {\n  export type Variables = GetUserCompanyOfficesQueryVariables;\n  export type Query = GetUserCompanyOfficesQuery;\n  export type GetUserCompanyOffices = GetUserCompanyOfficesQuery['getUserCompanyOffices'][number];\n  export type Addresses = GetUserCompanyOfficesQuery['getUserCompanyOffices'][number]['addresses'][number];\n}\n\nexport namespace GetUserCurrentCarbonAllowance {\n  export type Variables = GetUserCurrentCarbonAllowanceQueryVariables;\n  export type Query = GetUserCurrentCarbonAllowanceQuery;\n  export type GetUserCurrentCarbonAllowance = GetUserCurrentCarbonAllowanceQuery['getUserCurrentCarbonAllowance'];\n  export type Company = GetUserCurrentCarbonAllowanceQuery['getUserCurrentCarbonAllowance']['company'];\n  export type Office = GetUserCurrentCarbonAllowanceQuery['getUserCurrentCarbonAllowance']['office'];\n  export type User = GetUserCurrentCarbonAllowanceQuery['getUserCurrentCarbonAllowance']['user'];\n  export type PeriodConsumption = GetUserCurrentCarbonAllowanceQuery['getUserCurrentCarbonAllowance']['periodConsumption'][number];\n}\n\nexport namespace GetUserMiAutoSuggestValues {\n  export type Variables = GetUserMiAutoSuggestValuesQueryVariables;\n  export type Query = GetUserMiAutoSuggestValuesQuery;\n  export type GetUserMiAutoSuggestValues = GetUserMiAutoSuggestValuesQuery['getUserMIAutoSuggestValues'][number];\n}\n\nexport namespace GetUserPhone {\n  export type Variables = GetUserPhoneQueryVariables;\n  export type Query = GetUserPhoneQuery;\n  export type GetUserPhoneNumbers = GetUserPhoneQuery['getUserPhoneNumbers'][number];\n}\n\nexport namespace GetUserRecentSearches {\n  export type Variables = GetUserRecentSearchesQueryVariables;\n  export type Query = GetUserRecentSearchesQuery;\n  export type GetUserRecentSearches = GetUserRecentSearchesQuery['getUserRecentSearches'][number];\n  export type Travellers = GetUserRecentSearchesQuery['getUserRecentSearches'][number]['travellers'][number];\n}\n\nexport namespace SearchHotels {\n  export type Variables = SearchHotelsQueryVariables;\n  export type Query = SearchHotelsQuery;\n  export type SearchHotels = SearchHotelsQuery['searchHotels'];\n  export type Results = SearchHotelsQuery['searchHotels']['results'][number];\n  export type Location = SearchHotelsQuery['searchHotels']['results'][number]['location'];\n  export type Address = SearchHotelsQuery['searchHotels']['results'][number]['address'];\n  export type Transports = SearchHotelsQuery['searchHotels']['results'][number]['transports'][number];\n  export type Preferred = SearchHotelsQuery['searchHotels']['results'][number]['preferred'];\n  export type Tags = SearchHotelsQuery['searchHotels']['results'][number]['tags'][number];\n  export type AvailableRates = SearchHotelsQuery['searchHotels']['results'][number]['availableRates'];\n  export type Rooms = SearchHotelsQuery['searchHotels']['results'][number]['availableRates']['rooms'][number];\n  export type CurrencyConversion = SearchHotelsQuery['searchHotels']['results'][number]['availableRates']['rooms'][number]['currencyConversion'];\n  export type Deposit = SearchHotelsQuery['searchHotels']['results'][number]['availableRates']['rooms'][number]['deposit'];\n  export type Nights = SearchHotelsQuery['searchHotels']['results'][number]['availableRates']['rooms'][number]['nights'][number];\n  export type Policies = SearchHotelsQuery['searchHotels']['results'][number]['availableRates']['rooms'][number]['policies'];\n  export type Tax = SearchHotelsQuery['searchHotels']['results'][number]['availableRates']['rooms'][number]['tax'];\n  export type AcceptedCards = SearchHotelsQuery['searchHotels']['results'][number]['availableRates']['rooms'][number]['acceptedCards'][number];\n  export type PaymentTypes = SearchHotelsQuery['searchHotels']['results'][number]['availableRates']['rooms'][number]['paymentTypes'][number];\n  export type Errors = SearchHotelsQuery['searchHotels']['errors'][number];\n  export type Service = SearchHotelsQuery['searchHotels']['errors'][number]['service'];\n}\n\nexport namespace GetMultipleHotelsAvailability {\n  export type Variables = GetMultipleHotelsAvailabilityQueryVariables;\n  export type Query = GetMultipleHotelsAvailabilityQuery;\n  export type GetMultipleHotelsAvailability = GetMultipleHotelsAvailabilityQuery['getMultipleHotelsAvailability'];\n  export type Results = GetMultipleHotelsAvailabilityQuery['getMultipleHotelsAvailability']['results'][number];\n  export type Rooms = GetMultipleHotelsAvailabilityQuery['getMultipleHotelsAvailability']['results'][number]['rooms'][number];\n  export type CurrencyConversion = GetMultipleHotelsAvailabilityQuery['getMultipleHotelsAvailability']['results'][number]['rooms'][number]['currencyConversion'];\n  export type Deposit = GetMultipleHotelsAvailabilityQuery['getMultipleHotelsAvailability']['results'][number]['rooms'][number]['deposit'];\n  export type Nights = GetMultipleHotelsAvailabilityQuery['getMultipleHotelsAvailability']['results'][number]['rooms'][number]['nights'][number];\n  export type Policies = GetMultipleHotelsAvailabilityQuery['getMultipleHotelsAvailability']['results'][number]['rooms'][number]['policies'];\n  export type Tax = GetMultipleHotelsAvailabilityQuery['getMultipleHotelsAvailability']['results'][number]['rooms'][number]['tax'];\n  export type AcceptedCards = GetMultipleHotelsAvailabilityQuery['getMultipleHotelsAvailability']['results'][number]['rooms'][number]['acceptedCards'][number];\n  export type PaymentTypes = GetMultipleHotelsAvailabilityQuery['getMultipleHotelsAvailability']['results'][number]['rooms'][number]['paymentTypes'][number];\n  export type Errors = GetMultipleHotelsAvailabilityQuery['getMultipleHotelsAvailability']['errors'][number];\n}\n\nexport namespace IsPostcodeValid {\n  export type Variables = IsPostcodeValidQueryVariables;\n  export type Query = IsPostcodeValidQuery;\n}\n\nexport namespace Location_Detail {\n  export type Fragment = Location_DetailFragment;\n  export type Coordinates = Location_DetailFragment['coordinates'];\n}\n\nexport namespace SearchAirports {\n  export type Variables = SearchAirportsQueryVariables;\n  export type Query = SearchAirportsQuery;\n  export type SearchAirports = SearchAirportsQuery['searchAirports'];\n  export type IataMatch = SearchAirportsQuery['searchAirports']['iataMatch'];\n  export type LocationDetails = SearchAirportsQuery['searchAirports']['iataMatch']['locationDetails'];\n  export type GeneralMatches = SearchAirportsQuery['searchAirports']['generalMatches'][number];\n  export type _LocationDetails = SearchAirportsQuery['searchAirports']['generalMatches'][number]['locationDetails'];\n}\n\nexport namespace SearchLounges {\n  export type Variables = SearchLoungesQueryVariables;\n  export type Query = SearchLoungesQuery;\n  export type SearchLounges = SearchLoungesQuery['searchLounges'];\n  export type Results = SearchLoungesQuery['searchLounges']['results'][number];\n  export type Lounge = SearchLoungesQuery['searchLounges']['results'][number]['lounge'];\n  export type Errors = SearchLoungesQuery['searchLounges']['errors'][number];\n}\n\nexport namespace MoveItemToADifferentBasket {\n  export type Variables = MoveItemToADifferentBasketMutationVariables;\n  export type Mutation = MoveItemToADifferentBasketMutation;\n  export type MoveItemToADifferentBasket = MoveItemToADifferentBasketMutation['moveItemToADifferentBasket'];\n}\n\nexport namespace SearchParking {\n  export type Variables = SearchParkingQueryVariables;\n  export type Query = SearchParkingQuery;\n  export type SearchParking = SearchParkingQuery['searchParking'];\n  export type Results = SearchParkingQuery['searchParking']['results'][number];\n  export type CarPark = SearchParkingQuery['searchParking']['results'][number]['carPark'];\n  export type Errors = SearchParkingQuery['searchParking']['errors'][number];\n}\n\nexport namespace SearchRail {\n  export type Variables = SearchRailQueryVariables;\n  export type Query = SearchRailQuery;\n  export type SearchRail = SearchRailQuery['searchRail'];\n  export type Results = SearchRailQuery['searchRail']['results'][number];\n  export type Outbound = SearchRailQuery['searchRail']['results'][number]['outbound'][number];\n  export type Identifiers = SearchRailQuery['searchRail']['results'][number]['outbound'][number]['identifiers'];\n  export type Travellers = SearchRailQuery['searchRail']['results'][number]['outbound'][number]['travellers'][number];\n  export type Segments = SearchRailQuery['searchRail']['results'][number]['outbound'][number]['segments'][number];\n  export type SeatPreferenceTypes = SearchRailQuery['searchRail']['results'][number]['outbound'][number]['segments'][number]['seatPreferenceTypes'][number];\n  export type Seats = SearchRailQuery['searchRail']['results'][number]['outbound'][number]['segments'][number]['seats'][number];\n  export type CallingPoints = SearchRailQuery['searchRail']['results'][number]['outbound'][number]['segments'][number]['callingPoints'][number];\n  export type Providers = SearchRailQuery['searchRail']['results'][number]['outbound'][number]['providers'][number];\n  export type CheapestTicket = SearchRailQuery['searchRail']['results'][number]['outbound'][number]['providers'][number]['cheapestTicket'];\n  export type _Identifiers = SearchRailQuery['searchRail']['results'][number]['outbound'][number]['providers'][number]['cheapestTicket']['identifiers'];\n  export type Terms = SearchRailQuery['searchRail']['results'][number]['outbound'][number]['providers'][number]['cheapestTicket']['terms'];\n  export type DynamicConditions = SearchRailQuery['searchRail']['results'][number]['outbound'][number]['providers'][number]['cheapestTicket']['terms']['dynamicConditions'][number];\n  export type Tickets = SearchRailQuery['searchRail']['results'][number]['outbound'][number]['providers'][number]['cheapestTicket']['tickets'][number];\n  export type _Segments = SearchRailQuery['searchRail']['results'][number]['outbound'][number]['providers'][number]['cheapestTicket']['tickets'][number]['segments'][number];\n  export type TicketQueueList = SearchRailQuery['searchRail']['results'][number]['outbound'][number]['providers'][number]['cheapestTicket']['ticketQueueList'][number];\n  export type AccountsList = SearchRailQuery['searchRail']['results'][number]['outbound'][number]['providers'][number]['cheapestTicket']['accountsList'][number];\n  export type TicketOptions = SearchRailQuery['searchRail']['results'][number]['outbound'][number]['providers'][number]['ticketOptions'][number];\n  export type __Identifiers = SearchRailQuery['searchRail']['results'][number]['outbound'][number]['providers'][number]['ticketOptions'][number]['identifiers'];\n  export type AllowedWith = SearchRailQuery['searchRail']['results'][number]['outbound'][number]['providers'][number]['ticketOptions'][number]['identifiers']['allowedWith'][number];\n  export type _Terms = SearchRailQuery['searchRail']['results'][number]['outbound'][number]['providers'][number]['ticketOptions'][number]['terms'];\n  export type _Tickets = SearchRailQuery['searchRail']['results'][number]['outbound'][number]['providers'][number]['ticketOptions'][number]['tickets'][number];\n  export type _TicketQueueList = SearchRailQuery['searchRail']['results'][number]['outbound'][number]['providers'][number]['ticketOptions'][number]['ticketQueueList'][number];\n  export type _AccountsList = SearchRailQuery['searchRail']['results'][number]['outbound'][number]['providers'][number]['ticketOptions'][number]['accountsList'][number];\n  export type BookedTicket = SearchRailQuery['searchRail']['results'][number]['outbound'][number]['providers'][number]['bookedTicket'];\n  export type ___Identifiers = SearchRailQuery['searchRail']['results'][number]['outbound'][number]['providers'][number]['bookedTicket']['identifiers'];\n  export type __Terms = SearchRailQuery['searchRail']['results'][number]['outbound'][number]['providers'][number]['bookedTicket']['terms'];\n  export type __Tickets = SearchRailQuery['searchRail']['results'][number]['outbound'][number]['providers'][number]['bookedTicket']['tickets'][number];\n  export type __TicketQueueList = SearchRailQuery['searchRail']['results'][number]['outbound'][number]['providers'][number]['bookedTicket']['ticketQueueList'][number];\n  export type __AccountsList = SearchRailQuery['searchRail']['results'][number]['outbound'][number]['providers'][number]['bookedTicket']['accountsList'][number];\n  export type TicketExtras = SearchRailQuery['searchRail']['results'][number]['outbound'][number]['ticketExtras'][number];\n  export type ____Identifiers = SearchRailQuery['searchRail']['results'][number]['outbound'][number]['ticketExtras'][number]['identifiers'];\n  export type PlusBus = SearchRailQuery['searchRail']['results'][number]['outbound'][number]['plusBus'];\n  export type Return = SearchRailQuery['searchRail']['results'][number]['return'][number];\n  export type _____Identifiers = SearchRailQuery['searchRail']['results'][number]['return'][number]['identifiers'];\n  export type _Travellers = SearchRailQuery['searchRail']['results'][number]['return'][number]['travellers'][number];\n  export type __Segments = SearchRailQuery['searchRail']['results'][number]['return'][number]['segments'][number];\n  export type _CallingPoints = SearchRailQuery['searchRail']['results'][number]['return'][number]['segments'][number]['callingPoints'][number];\n  export type _Providers = SearchRailQuery['searchRail']['results'][number]['return'][number]['providers'][number];\n  export type _CheapestTicket = SearchRailQuery['searchRail']['results'][number]['return'][number]['providers'][number]['cheapestTicket'];\n  export type ______Identifiers = SearchRailQuery['searchRail']['results'][number]['return'][number]['providers'][number]['cheapestTicket']['identifiers'];\n  export type ___Terms = SearchRailQuery['searchRail']['results'][number]['return'][number]['providers'][number]['cheapestTicket']['terms'];\n  export type _DynamicConditions = SearchRailQuery['searchRail']['results'][number]['return'][number]['providers'][number]['cheapestTicket']['terms']['dynamicConditions'][number];\n  export type ___Tickets = SearchRailQuery['searchRail']['results'][number]['return'][number]['providers'][number]['cheapestTicket']['tickets'][number];\n  export type ___Segments = SearchRailQuery['searchRail']['results'][number]['return'][number]['providers'][number]['cheapestTicket']['tickets'][number]['segments'][number];\n  export type ___TicketQueueList = SearchRailQuery['searchRail']['results'][number]['return'][number]['providers'][number]['cheapestTicket']['ticketQueueList'][number];\n  export type ___AccountsList = SearchRailQuery['searchRail']['results'][number]['return'][number]['providers'][number]['cheapestTicket']['accountsList'][number];\n  export type _TicketOptions = SearchRailQuery['searchRail']['results'][number]['return'][number]['providers'][number]['ticketOptions'][number];\n  export type _______Identifiers = SearchRailQuery['searchRail']['results'][number]['return'][number]['providers'][number]['ticketOptions'][number]['identifiers'];\n  export type _AllowedWith = SearchRailQuery['searchRail']['results'][number]['return'][number]['providers'][number]['ticketOptions'][number]['identifiers']['allowedWith'][number];\n  export type ____Terms = SearchRailQuery['searchRail']['results'][number]['return'][number]['providers'][number]['ticketOptions'][number]['terms'];\n  export type ____Tickets = SearchRailQuery['searchRail']['results'][number]['return'][number]['providers'][number]['ticketOptions'][number]['tickets'][number];\n  export type ____TicketQueueList = SearchRailQuery['searchRail']['results'][number]['return'][number]['providers'][number]['ticketOptions'][number]['ticketQueueList'][number];\n  export type ____AccountsList = SearchRailQuery['searchRail']['results'][number]['return'][number]['providers'][number]['ticketOptions'][number]['accountsList'][number];\n  export type _BookedTicket = SearchRailQuery['searchRail']['results'][number]['return'][number]['providers'][number]['bookedTicket'];\n  export type ________Identifiers = SearchRailQuery['searchRail']['results'][number]['return'][number]['providers'][number]['bookedTicket']['identifiers'];\n  export type _____Terms = SearchRailQuery['searchRail']['results'][number]['return'][number]['providers'][number]['bookedTicket']['terms'];\n  export type _____Tickets = SearchRailQuery['searchRail']['results'][number]['return'][number]['providers'][number]['bookedTicket']['tickets'][number];\n  export type _____TicketQueueList = SearchRailQuery['searchRail']['results'][number]['return'][number]['providers'][number]['bookedTicket']['ticketQueueList'][number];\n  export type _____AccountsList = SearchRailQuery['searchRail']['results'][number]['return'][number]['providers'][number]['bookedTicket']['accountsList'][number];\n  export type _TicketExtras = SearchRailQuery['searchRail']['results'][number]['return'][number]['ticketExtras'][number];\n  export type _PlusBus = SearchRailQuery['searchRail']['results'][number]['return'][number]['plusBus'];\n  export type Errors = SearchRailQuery['searchRail']['errors'][number];\n}\n\nexport namespace SaveRecentSearch {\n  export type Variables = SaveRecentSearchMutationVariables;\n  export type Mutation = SaveRecentSearchMutation;\n  export type SaveRecentSearch = SaveRecentSearchMutation['saveRecentSearch'][number];\n}\n\nexport namespace SaveUserAddress {\n  export type Variables = SaveUserAddressMutationVariables;\n  export type Mutation = SaveUserAddressMutation;\n  export type SaveUserAddress = SaveUserAddressMutation['saveUserAddress'];\n}\n\nexport namespace SearchAirlines {\n  export type Variables = SearchAirlinesQueryVariables;\n  export type Query = SearchAirlinesQuery;\n  export type SearchAirlines = SearchAirlinesQuery['searchAirlines'];\n  export type IataMatch = SearchAirlinesQuery['searchAirlines']['iataMatch'];\n  export type GeneralMatches = SearchAirlinesQuery['searchAirlines']['generalMatches'][number];\n}\n\nexport namespace SearchCities {\n  export type Variables = SearchCitiesQueryVariables;\n  export type Query = SearchCitiesQuery;\n  export type SearchCities = SearchCitiesQuery['searchCities'][number];\n  export type Coordinates = SearchCitiesQuery['searchCities'][number]['coordinates'];\n}\n\nexport namespace SearchConfermaCities {\n  export type Variables = SearchConfermaCitiesQueryVariables;\n  export type Query = SearchConfermaCitiesQuery;\n  export type SearchConfermaCities = SearchConfermaCitiesQuery['searchConfermaCities'];\n  export type Suggestions = SearchConfermaCitiesQuery['searchConfermaCities']['suggestions'][number];\n}\n\nexport namespace SearchEurostar {\n  export type Variables = SearchEurostarQueryVariables;\n  export type Query = SearchEurostarQuery;\n  export type SearchEurostar = SearchEurostarQuery['searchEurostar'];\n  export type Results = SearchEurostarQuery['searchEurostar']['results'];\n  export type Journeys = SearchEurostarQuery['searchEurostar']['results']['journeys'][number];\n  export type OutboundFlights = SearchEurostarQuery['searchEurostar']['results']['journeys'][number]['outboundFlights'][number];\n  export type FareInfo = SearchEurostarQuery['searchEurostar']['results']['journeys'][number]['outboundFlights'][number]['fareInfo'];\n  export type OriginAirportDetail = SearchEurostarQuery['searchEurostar']['results']['journeys'][number]['outboundFlights'][number]['originAirportDetail'];\n  export type DestinationAirportDetail = SearchEurostarQuery['searchEurostar']['results']['journeys'][number]['outboundFlights'][number]['destinationAirportDetail'];\n  export type MarketingCarrierDetail = SearchEurostarQuery['searchEurostar']['results']['journeys'][number]['outboundFlights'][number]['marketingCarrierDetail'];\n  export type OperatingCarrierDetail = SearchEurostarQuery['searchEurostar']['results']['journeys'][number]['outboundFlights'][number]['operatingCarrierDetail'];\n  export type FareConditions = SearchEurostarQuery['searchEurostar']['results']['journeys'][number]['outboundFlights'][number]['fareConditions'];\n  export type Cancellation = SearchEurostarQuery['searchEurostar']['results']['journeys'][number]['outboundFlights'][number]['fareConditions']['cancellation'][number];\n  export type Change = SearchEurostarQuery['searchEurostar']['results']['journeys'][number]['outboundFlights'][number]['fareConditions']['change'][number];\n  export type NoShow = SearchEurostarQuery['searchEurostar']['results']['journeys'][number]['outboundFlights'][number]['fareConditions']['noShow'][number];\n  export type Upgrade = SearchEurostarQuery['searchEurostar']['results']['journeys'][number]['outboundFlights'][number]['fareConditions']['upgrade'][number];\n  export type Other = SearchEurostarQuery['searchEurostar']['results']['journeys'][number]['outboundFlights'][number]['fareConditions']['other'][number];\n  export type InboundFlights = SearchEurostarQuery['searchEurostar']['results']['journeys'][number]['inboundFlights'][number];\n  export type _FareInfo = SearchEurostarQuery['searchEurostar']['results']['journeys'][number]['inboundFlights'][number]['fareInfo'];\n  export type _OriginAirportDetail = SearchEurostarQuery['searchEurostar']['results']['journeys'][number]['inboundFlights'][number]['originAirportDetail'];\n  export type _DestinationAirportDetail = SearchEurostarQuery['searchEurostar']['results']['journeys'][number]['inboundFlights'][number]['destinationAirportDetail'];\n  export type _MarketingCarrierDetail = SearchEurostarQuery['searchEurostar']['results']['journeys'][number]['inboundFlights'][number]['marketingCarrierDetail'];\n  export type _OperatingCarrierDetail = SearchEurostarQuery['searchEurostar']['results']['journeys'][number]['inboundFlights'][number]['operatingCarrierDetail'];\n  export type _FareConditions = SearchEurostarQuery['searchEurostar']['results']['journeys'][number]['inboundFlights'][number]['fareConditions'];\n  export type _Cancellation = SearchEurostarQuery['searchEurostar']['results']['journeys'][number]['inboundFlights'][number]['fareConditions']['cancellation'][number];\n  export type _Change = SearchEurostarQuery['searchEurostar']['results']['journeys'][number]['inboundFlights'][number]['fareConditions']['change'][number];\n  export type _NoShow = SearchEurostarQuery['searchEurostar']['results']['journeys'][number]['inboundFlights'][number]['fareConditions']['noShow'][number];\n  export type _Upgrade = SearchEurostarQuery['searchEurostar']['results']['journeys'][number]['inboundFlights'][number]['fareConditions']['upgrade'][number];\n  export type _Other = SearchEurostarQuery['searchEurostar']['results']['journeys'][number]['inboundFlights'][number]['fareConditions']['other'][number];\n  export type OutboundCarbonEmissions = SearchEurostarQuery['searchEurostar']['results']['journeys'][number]['outboundCarbonEmissions'];\n  export type InboundCarbonEmissions = SearchEurostarQuery['searchEurostar']['results']['journeys'][number]['inboundCarbonEmissions'];\n  export type Taxes = SearchEurostarQuery['searchEurostar']['results']['journeys'][number]['taxes'][number];\n  export type Discounts = SearchEurostarQuery['searchEurostar']['results']['journeys'][number]['discounts'][number];\n  export type Total = SearchEurostarQuery['searchEurostar']['results']['journeys'][number]['total'];\n  export type __FareConditions = SearchEurostarQuery['searchEurostar']['results']['journeys'][number]['fareConditions'];\n  export type __Cancellation = SearchEurostarQuery['searchEurostar']['results']['journeys'][number]['fareConditions']['cancellation'][number];\n  export type __Change = SearchEurostarQuery['searchEurostar']['results']['journeys'][number]['fareConditions']['change'][number];\n  export type __NoShow = SearchEurostarQuery['searchEurostar']['results']['journeys'][number]['fareConditions']['noShow'][number];\n  export type __Upgrade = SearchEurostarQuery['searchEurostar']['results']['journeys'][number]['fareConditions']['upgrade'][number];\n  export type __Other = SearchEurostarQuery['searchEurostar']['results']['journeys'][number]['fareConditions']['other'][number];\n  export type BaggageAllowance = SearchEurostarQuery['searchEurostar']['results']['journeys'][number]['baggageAllowance'][number];\n  export type Multi = SearchEurostarQuery['searchEurostar']['results']['multi'][number];\n  export type _Results = SearchEurostarQuery['searchEurostar']['results']['multi'][number]['results'][number];\n  export type _OutboundFlights = SearchEurostarQuery['searchEurostar']['results']['multi'][number]['results'][number]['outboundFlights'][number];\n  export type __FareInfo = SearchEurostarQuery['searchEurostar']['results']['multi'][number]['results'][number]['outboundFlights'][number]['fareInfo'];\n  export type __OriginAirportDetail = SearchEurostarQuery['searchEurostar']['results']['multi'][number]['results'][number]['outboundFlights'][number]['originAirportDetail'];\n  export type __DestinationAirportDetail = SearchEurostarQuery['searchEurostar']['results']['multi'][number]['results'][number]['outboundFlights'][number]['destinationAirportDetail'];\n  export type __MarketingCarrierDetail = SearchEurostarQuery['searchEurostar']['results']['multi'][number]['results'][number]['outboundFlights'][number]['marketingCarrierDetail'];\n  export type __OperatingCarrierDetail = SearchEurostarQuery['searchEurostar']['results']['multi'][number]['results'][number]['outboundFlights'][number]['operatingCarrierDetail'];\n  export type ___FareConditions = SearchEurostarQuery['searchEurostar']['results']['multi'][number]['results'][number]['outboundFlights'][number]['fareConditions'];\n  export type ___Cancellation = SearchEurostarQuery['searchEurostar']['results']['multi'][number]['results'][number]['outboundFlights'][number]['fareConditions']['cancellation'][number];\n  export type ___Change = SearchEurostarQuery['searchEurostar']['results']['multi'][number]['results'][number]['outboundFlights'][number]['fareConditions']['change'][number];\n  export type ___NoShow = SearchEurostarQuery['searchEurostar']['results']['multi'][number]['results'][number]['outboundFlights'][number]['fareConditions']['noShow'][number];\n  export type ___Upgrade = SearchEurostarQuery['searchEurostar']['results']['multi'][number]['results'][number]['outboundFlights'][number]['fareConditions']['upgrade'][number];\n  export type ___Other = SearchEurostarQuery['searchEurostar']['results']['multi'][number]['results'][number]['outboundFlights'][number]['fareConditions']['other'][number];\n  export type _InboundFlights = SearchEurostarQuery['searchEurostar']['results']['multi'][number]['results'][number]['inboundFlights'][number];\n  export type ___FareInfo = SearchEurostarQuery['searchEurostar']['results']['multi'][number]['results'][number]['inboundFlights'][number]['fareInfo'];\n  export type ___OriginAirportDetail = SearchEurostarQuery['searchEurostar']['results']['multi'][number]['results'][number]['inboundFlights'][number]['originAirportDetail'];\n  export type ___DestinationAirportDetail = SearchEurostarQuery['searchEurostar']['results']['multi'][number]['results'][number]['inboundFlights'][number]['destinationAirportDetail'];\n  export type ___MarketingCarrierDetail = SearchEurostarQuery['searchEurostar']['results']['multi'][number]['results'][number]['inboundFlights'][number]['marketingCarrierDetail'];\n  export type ___OperatingCarrierDetail = SearchEurostarQuery['searchEurostar']['results']['multi'][number]['results'][number]['inboundFlights'][number]['operatingCarrierDetail'];\n  export type ____FareConditions = SearchEurostarQuery['searchEurostar']['results']['multi'][number]['results'][number]['inboundFlights'][number]['fareConditions'];\n  export type ____Cancellation = SearchEurostarQuery['searchEurostar']['results']['multi'][number]['results'][number]['inboundFlights'][number]['fareConditions']['cancellation'][number];\n  export type ____Change = SearchEurostarQuery['searchEurostar']['results']['multi'][number]['results'][number]['inboundFlights'][number]['fareConditions']['change'][number];\n  export type ____NoShow = SearchEurostarQuery['searchEurostar']['results']['multi'][number]['results'][number]['inboundFlights'][number]['fareConditions']['noShow'][number];\n  export type ____Upgrade = SearchEurostarQuery['searchEurostar']['results']['multi'][number]['results'][number]['inboundFlights'][number]['fareConditions']['upgrade'][number];\n  export type ____Other = SearchEurostarQuery['searchEurostar']['results']['multi'][number]['results'][number]['inboundFlights'][number]['fareConditions']['other'][number];\n  export type _OutboundCarbonEmissions = SearchEurostarQuery['searchEurostar']['results']['multi'][number]['results'][number]['outboundCarbonEmissions'];\n  export type _InboundCarbonEmissions = SearchEurostarQuery['searchEurostar']['results']['multi'][number]['results'][number]['inboundCarbonEmissions'];\n  export type _Taxes = SearchEurostarQuery['searchEurostar']['results']['multi'][number]['results'][number]['taxes'][number];\n  export type _Discounts = SearchEurostarQuery['searchEurostar']['results']['multi'][number]['results'][number]['discounts'][number];\n  export type _Total = SearchEurostarQuery['searchEurostar']['results']['multi'][number]['results'][number]['total'];\n  export type _____FareConditions = SearchEurostarQuery['searchEurostar']['results']['multi'][number]['results'][number]['fareConditions'];\n  export type _____Cancellation = SearchEurostarQuery['searchEurostar']['results']['multi'][number]['results'][number]['fareConditions']['cancellation'][number];\n  export type _____Change = SearchEurostarQuery['searchEurostar']['results']['multi'][number]['results'][number]['fareConditions']['change'][number];\n  export type _____NoShow = SearchEurostarQuery['searchEurostar']['results']['multi'][number]['results'][number]['fareConditions']['noShow'][number];\n  export type _____Upgrade = SearchEurostarQuery['searchEurostar']['results']['multi'][number]['results'][number]['fareConditions']['upgrade'][number];\n  export type _____Other = SearchEurostarQuery['searchEurostar']['results']['multi'][number]['results'][number]['fareConditions']['other'][number];\n  export type _BaggageAllowance = SearchEurostarQuery['searchEurostar']['results']['multi'][number]['results'][number]['baggageAllowance'][number];\n  export type Grouped = SearchEurostarQuery['searchEurostar']['results']['grouped'][number];\n  export type Flights = SearchEurostarQuery['searchEurostar']['results']['grouped'][number]['flights'];\n  export type Errors = SearchEurostarQuery['searchEurostar']['errors'][number];\n}\n\nexport namespace SearchHotelChains {\n  export type Variables = SearchHotelChainsQueryVariables;\n  export type Query = SearchHotelChainsQuery;\n}\n\nexport namespace SearchIrl {\n  export type Variables = SearchIrlQueryVariables;\n  export type Query = SearchIrlQuery;\n  export type SearchIrl = SearchIrlQuery['searchIRL'];\n  export type Results = SearchIrlQuery['searchIRL']['results'][number];\n  export type Outbound = SearchIrlQuery['searchIRL']['results'][number]['outbound'][number];\n  export type Identifiers = SearchIrlQuery['searchIRL']['results'][number]['outbound'][number]['identifiers'];\n  export type Travellers = SearchIrlQuery['searchIRL']['results'][number]['outbound'][number]['travellers'][number];\n  export type Segments = SearchIrlQuery['searchIRL']['results'][number]['outbound'][number]['segments'][number];\n  export type SeatPreferenceTypes = SearchIrlQuery['searchIRL']['results'][number]['outbound'][number]['segments'][number]['seatPreferenceTypes'][number];\n  export type Seats = SearchIrlQuery['searchIRL']['results'][number]['outbound'][number]['segments'][number]['seats'][number];\n  export type Providers = SearchIrlQuery['searchIRL']['results'][number]['outbound'][number]['providers'][number];\n  export type CheapestTicket = SearchIrlQuery['searchIRL']['results'][number]['outbound'][number]['providers'][number]['cheapestTicket'];\n  export type _Identifiers = SearchIrlQuery['searchIRL']['results'][number]['outbound'][number]['providers'][number]['cheapestTicket']['identifiers'];\n  export type Tickets = SearchIrlQuery['searchIRL']['results'][number]['outbound'][number]['providers'][number]['cheapestTicket']['tickets'][number];\n  export type _Segments = SearchIrlQuery['searchIRL']['results'][number]['outbound'][number]['providers'][number]['cheapestTicket']['tickets'][number]['segments'][number];\n  export type _SeatPreferenceTypes = SearchIrlQuery['searchIRL']['results'][number]['outbound'][number]['providers'][number]['cheapestTicket']['tickets'][number]['segments'][number]['seatPreferenceTypes'][number];\n  export type _Seats = SearchIrlQuery['searchIRL']['results'][number]['outbound'][number]['providers'][number]['cheapestTicket']['tickets'][number]['segments'][number]['seats'][number];\n  export type TicketOptions = SearchIrlQuery['searchIRL']['results'][number]['outbound'][number]['providers'][number]['ticketOptions'][number];\n  export type __Identifiers = SearchIrlQuery['searchIRL']['results'][number]['outbound'][number]['providers'][number]['ticketOptions'][number]['identifiers'];\n  export type _Tickets = SearchIrlQuery['searchIRL']['results'][number]['outbound'][number]['providers'][number]['ticketOptions'][number]['tickets'][number];\n  export type __Segments = SearchIrlQuery['searchIRL']['results'][number]['outbound'][number]['providers'][number]['ticketOptions'][number]['tickets'][number]['segments'][number];\n  export type __SeatPreferenceTypes = SearchIrlQuery['searchIRL']['results'][number]['outbound'][number]['providers'][number]['ticketOptions'][number]['tickets'][number]['segments'][number]['seatPreferenceTypes'][number];\n  export type __Seats = SearchIrlQuery['searchIRL']['results'][number]['outbound'][number]['providers'][number]['ticketOptions'][number]['tickets'][number]['segments'][number]['seats'][number];\n  export type BookedTicket = SearchIrlQuery['searchIRL']['results'][number]['outbound'][number]['providers'][number]['bookedTicket'];\n  export type ___Identifiers = SearchIrlQuery['searchIRL']['results'][number]['outbound'][number]['providers'][number]['bookedTicket']['identifiers'];\n  export type __Tickets = SearchIrlQuery['searchIRL']['results'][number]['outbound'][number]['providers'][number]['bookedTicket']['tickets'][number];\n  export type ___Segments = SearchIrlQuery['searchIRL']['results'][number]['outbound'][number]['providers'][number]['bookedTicket']['tickets'][number]['segments'][number];\n  export type ___SeatPreferenceTypes = SearchIrlQuery['searchIRL']['results'][number]['outbound'][number]['providers'][number]['bookedTicket']['tickets'][number]['segments'][number]['seatPreferenceTypes'][number];\n  export type ___Seats = SearchIrlQuery['searchIRL']['results'][number]['outbound'][number]['providers'][number]['bookedTicket']['tickets'][number]['segments'][number]['seats'][number];\n  export type TicketExtras = SearchIrlQuery['searchIRL']['results'][number]['outbound'][number]['ticketExtras'][number];\n  export type ____Identifiers = SearchIrlQuery['searchIRL']['results'][number]['outbound'][number]['ticketExtras'][number]['identifiers'];\n  export type PlusBus = SearchIrlQuery['searchIRL']['results'][number]['outbound'][number]['plusBus'];\n  export type Return = SearchIrlQuery['searchIRL']['results'][number]['return'][number];\n  export type _____Identifiers = SearchIrlQuery['searchIRL']['results'][number]['return'][number]['identifiers'];\n  export type _Travellers = SearchIrlQuery['searchIRL']['results'][number]['return'][number]['travellers'][number];\n  export type ____Segments = SearchIrlQuery['searchIRL']['results'][number]['return'][number]['segments'][number];\n  export type ____SeatPreferenceTypes = SearchIrlQuery['searchIRL']['results'][number]['return'][number]['segments'][number]['seatPreferenceTypes'][number];\n  export type ____Seats = SearchIrlQuery['searchIRL']['results'][number]['return'][number]['segments'][number]['seats'][number];\n  export type _Providers = SearchIrlQuery['searchIRL']['results'][number]['return'][number]['providers'][number];\n  export type _CheapestTicket = SearchIrlQuery['searchIRL']['results'][number]['return'][number]['providers'][number]['cheapestTicket'];\n  export type ______Identifiers = SearchIrlQuery['searchIRL']['results'][number]['return'][number]['providers'][number]['cheapestTicket']['identifiers'];\n  export type ___Tickets = SearchIrlQuery['searchIRL']['results'][number]['return'][number]['providers'][number]['cheapestTicket']['tickets'][number];\n  export type _____Segments = SearchIrlQuery['searchIRL']['results'][number]['return'][number]['providers'][number]['cheapestTicket']['tickets'][number]['segments'][number];\n  export type _____SeatPreferenceTypes = SearchIrlQuery['searchIRL']['results'][number]['return'][number]['providers'][number]['cheapestTicket']['tickets'][number]['segments'][number]['seatPreferenceTypes'][number];\n  export type _____Seats = SearchIrlQuery['searchIRL']['results'][number]['return'][number]['providers'][number]['cheapestTicket']['tickets'][number]['segments'][number]['seats'][number];\n  export type _TicketOptions = SearchIrlQuery['searchIRL']['results'][number]['return'][number]['providers'][number]['ticketOptions'][number];\n  export type _______Identifiers = SearchIrlQuery['searchIRL']['results'][number]['return'][number]['providers'][number]['ticketOptions'][number]['identifiers'];\n  export type ____Tickets = SearchIrlQuery['searchIRL']['results'][number]['return'][number]['providers'][number]['ticketOptions'][number]['tickets'][number];\n  export type ______Segments = SearchIrlQuery['searchIRL']['results'][number]['return'][number]['providers'][number]['ticketOptions'][number]['tickets'][number]['segments'][number];\n  export type ______SeatPreferenceTypes = SearchIrlQuery['searchIRL']['results'][number]['return'][number]['providers'][number]['ticketOptions'][number]['tickets'][number]['segments'][number]['seatPreferenceTypes'][number];\n  export type ______Seats = SearchIrlQuery['searchIRL']['results'][number]['return'][number]['providers'][number]['ticketOptions'][number]['tickets'][number]['segments'][number]['seats'][number];\n  export type _BookedTicket = SearchIrlQuery['searchIRL']['results'][number]['return'][number]['providers'][number]['bookedTicket'];\n  export type ________Identifiers = SearchIrlQuery['searchIRL']['results'][number]['return'][number]['providers'][number]['bookedTicket']['identifiers'];\n  export type _____Tickets = SearchIrlQuery['searchIRL']['results'][number]['return'][number]['providers'][number]['bookedTicket']['tickets'][number];\n  export type _______Segments = SearchIrlQuery['searchIRL']['results'][number]['return'][number]['providers'][number]['bookedTicket']['tickets'][number]['segments'][number];\n  export type _______SeatPreferenceTypes = SearchIrlQuery['searchIRL']['results'][number]['return'][number]['providers'][number]['bookedTicket']['tickets'][number]['segments'][number]['seatPreferenceTypes'][number];\n  export type _______Seats = SearchIrlQuery['searchIRL']['results'][number]['return'][number]['providers'][number]['bookedTicket']['tickets'][number]['segments'][number]['seats'][number];\n  export type _TicketExtras = SearchIrlQuery['searchIRL']['results'][number]['return'][number]['ticketExtras'][number];\n  export type _________Identifiers = SearchIrlQuery['searchIRL']['results'][number]['return'][number]['ticketExtras'][number]['identifiers'];\n  export type _PlusBus = SearchIrlQuery['searchIRL']['results'][number]['return'][number]['plusBus'];\n  export type Errors = SearchIrlQuery['searchIRL']['errors'][number];\n}\n\nexport namespace SearchPostcodes {\n  export type Variables = SearchPostcodesQueryVariables;\n  export type Query = SearchPostcodesQuery;\n  export type GetPostcodeDetails = SearchPostcodesQuery['getPostcodeDetails'];\n}\n\nexport namespace SearchRailStations {\n  export type Variables = SearchRailStationsQueryVariables;\n  export type Query = SearchRailStationsQuery;\n  export type SearchRailStations = SearchRailStationsQuery['searchRailStations'][number];\n  export type LocationDetails = SearchRailStationsQuery['searchRailStations'][number]['locationDetails'];\n  export type Coordinates = SearchRailStationsQuery['searchRailStations'][number]['locationDetails']['coordinates'];\n}\n\nexport namespace SearchUserAddress {\n  export type Variables = SearchUserAddressQueryVariables;\n  export type Query = SearchUserAddressQuery;\n  export type GetUserAddresses = SearchUserAddressQuery['getUserAddresses'][number];\n}\n\nexport namespace SetBasketItemMiGroup {\n  export type Variables = SetBasketItemMiGroupMutationVariables;\n  export type Mutation = SetBasketItemMiGroupMutation;\n  export type SetBasketItemMiGroup = SetBasketItemMiGroupMutation['setBasketItemMIGroup'];\n}\n\nexport namespace SetBasketItemLeadPassenger {\n  export type Variables = SetBasketItemLeadPassengerMutationVariables;\n  export type Mutation = SetBasketItemLeadPassengerMutation;\n  export type SetBasketItemLeadPassenger = SetBasketItemLeadPassengerMutation['setBasketItemLeadPassenger'];\n}\n\nexport namespace SetBasketItemMiValue {\n  export type Variables = SetBasketItemMiValueMutationVariables;\n  export type Mutation = SetBasketItemMiValueMutation;\n  export type SetBasketItemMiValue = SetBasketItemMiValueMutation['setBasketItemMIValue'];\n}\n\nexport namespace SetBasketItemPaymentMethod {\n  export type Variables = SetBasketItemPaymentMethodMutationVariables;\n  export type Mutation = SetBasketItemPaymentMethodMutation;\n  export type SetBasketItemPaymentMethod = SetBasketItemPaymentMethodMutation['setBasketItemPaymentMethod'];\n}\n\nexport namespace UpdateBasketNotes {\n  export type Variables = UpdateBasketNotesMutationVariables;\n  export type Mutation = UpdateBasketNotesMutation;\n  export type UpdateBasketNotes = UpdateBasketNotesMutation['updateBasketNotes'];\n}\n\nexport namespace UpdateBasketTitle {\n  export type Variables = UpdateBasketTitleMutationVariables;\n  export type Mutation = UpdateBasketTitleMutation;\n  export type UpdateBasketTitle = UpdateBasketTitleMutation['updateBasketTitle'];\n}\n\nexport namespace UserFields {\n  export type Fragment = UserFieldsFragment;\n  export type SelectedLanguage = UserFieldsFragment['selectedLanguage'];\n  export type AvailableLanguages = UserFieldsFragment['availableLanguages'][number];\n  export type Passports = UserFieldsFragment['passports'][number];\n  export type Addresses = UserFieldsFragment['addresses'][number];\n  export type PhoneNumbers = UserFieldsFragment['phoneNumbers'][number];\n}\n\nexport namespace GetUserServices {\n  export type Variables = GetUserServicesQueryVariables;\n  export type Query = GetUserServicesQuery;\n  export type GetUserServices = GetUserServicesQuery['getUserServices'][number];\n}\n\nexport namespace GetUserUiConfigs {\n  export type Variables = GetUserUiConfigsQueryVariables;\n  export type Query = GetUserUiConfigsQuery;\n  export type GetUserUiConfigs = GetUserUiConfigsQuery['getUserUIConfigs'];\n  export type All = GetUserUiConfigsQuery['getUserUIConfigs']['all'][number];\n}\n\nexport namespace GetUserMessages {\n  export type Variables = GetUserMessagesQueryVariables;\n  export type Query = GetUserMessagesQuery;\n  export type GetUserMessages = GetUserMessagesQuery['getUserMessages'][number];\n}\n\nexport namespace GetUserPhoneNumbers {\n  export type Variables = GetUserPhoneNumbersQueryVariables;\n  export type Query = GetUserPhoneNumbersQuery;\n  export type GetUserPhoneNumbers = GetUserPhoneNumbersQuery['getUserPhoneNumbers'][number];\n}\n\nexport namespace SetUserLanguage {\n  export type Variables = SetUserLanguageMutationVariables;\n  export type Mutation = SetUserLanguageMutation;\n  export type SetUserLanguage = SetUserLanguageMutation['setUserLanguage'];\n  export type SelectedLanguage = SetUserLanguageMutation['setUserLanguage']['selectedLanguage'];\n}\n\nexport namespace GetUser {\n  export type Variables = GetUserQueryVariables;\n  export type Query = GetUserQuery;\n  export type GetUser = GetUserQuery['getUser'];\n}\n\nexport namespace SearchUserCanBookFor {\n  export type Variables = SearchUserCanBookForQueryVariables;\n  export type Query = SearchUserCanBookForQuery;\n  export type SearchUserCanBookFor = SearchUserCanBookForQuery['searchUserCanBookFor'][number];\n}\n\nexport namespace ValidateUserMiFreeValue {\n  export type Variables = ValidateUserMiFreeValueQueryVariables;\n  export type Query = ValidateUserMiFreeValueQuery;\n}\n\nexport const OwnerFieldsFragmentDoc = gql`\n    fragment OwnerFields on User {\n  id\n  title\n  forename\n  surname\n  email\n}\n    `;\nexport const TravellerFieldsFragmentDoc = gql`\n    fragment TravellerFields on User {\n  id\n  title\n  forename\n  surname\n  email\n  username\n  employeeId\n}\n    `;\nexport const BasketFieldsFragmentDoc = gql`\n    fragment BasketFields on Basket {\n  id\n  owner {\n    ...OwnerFields\n  }\n  reference\n  title\n  notes\n  createdAt\n  updatedAt\n  bookedAt\n  basketItems {\n    id\n    adults\n    children\n    infants\n    detail\n    detailHash\n    createdAt\n    updatedAt\n    expiry\n    expired\n    searchQuery\n    price\n    currency\n    miGroupsAvailable\n    miGroupSelected\n    validated\n    latestValidation\n    latestValidationPrice\n    latestValidationPriceDifference\n    latestValidationAvailable\n    bookingThirdPartyReference\n    pnrLocator\n    status\n    availablePaymentMethods {\n      id\n      name\n      description\n    }\n    selectedPaymentMethod {\n      id\n      name\n      description\n    }\n    perItemSupplementaryBookingInfoSchema @include(if: $withSupplemental)\n    perPassengerSupplementaryBookingInfoSchema @include(if: $withSupplemental)\n    perItemAddress @include(if: $withSupplemental)\n    perItemPhoneNumber @include(if: $withSupplemental)\n    perPassengerAddress @include(if: $withSupplemental)\n    perPassengerPhoneNumber @include(if: $withSupplemental)\n    cancellable\n    amendable\n    co2PerItem\n    co2PerPassenger\n    outboundDate\n    inboundDate\n    service {\n      id\n      type\n    }\n    users {\n      ...TravellerFields\n    }\n    userPassengerTypes {\n      id\n      passengerType\n    }\n    leadPassenger {\n      ...TravellerFields\n    }\n    managementInfo {\n      id\n      dbId\n      name\n      description\n      handoff\n      valueMask\n      uiPresentation\n      mandatory\n      perPassenger\n      perBooking\n      agentOnly\n      createdAt\n      updatedAt\n      fixed\n      fixedValue {\n        id\n        label\n        value\n        default\n        fixed\n        agentOnly\n      }\n      defaultValue {\n        id\n        label\n        value\n        default\n        fixed\n        agentOnly\n      }\n      values {\n        id\n        label\n        value\n        default\n        fixed\n        agentOnly\n      }\n      group\n      selectedValues {\n        value {\n          id\n          label\n          value\n          default\n          fixed\n          agentOnly\n        }\n        freeValue\n        basketLevelValue\n        userLevelValue\n        user {\n          id\n          title\n          forename\n          surname\n          email\n          username\n          employeeId\n          createdAt\n          updatedAt\n          dob\n          admin\n          companyAdmin\n          bookerType\n          authMethods\n          active\n          passwordLastUpdated\n        }\n      }\n    }\n  }\n  status\n  companyGroup {\n    id\n    name\n    description\n    createdAt\n    updatedAt\n  }\n  validated\n}\n    ${OwnerFieldsFragmentDoc}\n${TravellerFieldsFragmentDoc}`;\nexport const ErrorsFragmentDoc = gql`\n    fragment Errors on SearchError {\n  service {\n    id\n    type\n    name\n    description\n  }\n  errorMessage\n  errorCode\n}\n    `;\nexport const GroupedFieldsFragmentDoc = gql`\n    fragment GroupedFields on GroupFlights {\n  referenceID\n  flightID\n  boundIndicator\n  minPrice\n  maxPrice\n  flights {\n    LiteEconomy\n    EconomyRestricted\n    EconomyNoBags\n    Economy\n    PremiumEconomy\n    Business\n    PremiumBusiness\n    First\n    PremiumFirst\n  }\n}\n    `;\nexport const Location_DetailFragmentDoc = gql`\n    fragment LOCATION_DETAIL on LocationDetail {\n  continent\n  country\n  countryCode\n  state\n  city\n  coordinates {\n    latitude\n    longitude\n    altitude\n  }\n  postcode\n  road\n  gridReference\n  northing\n  easting\n}\n    `;\nexport const UserFieldsFragmentDoc = gql`\n    fragment UserFields on User {\n  id\n  title\n  forename\n  surname\n  email\n  username\n  employeeId\n  createdAt\n  updatedAt\n  dob\n  admin\n  tmcAdmin\n  companyAdmin\n  bookerType\n  authMethods\n  active\n  passwordLastUpdated\n  selectedLanguage {\n    id\n    name\n    isoCode\n  }\n  availableLanguages {\n    id\n    name\n    isoCode\n  }\n  passports {\n    id\n    number\n    codeOfIssuingState\n    nationality\n    sex\n    dob\n    surname\n    givenNames\n    dateOfIssue\n    createdAt\n    updatedAt\n  }\n  addresses {\n    id\n    description\n    numberOrName\n    street\n    town\n    county\n    postcode\n    countryCode\n    userPrimary\n    officePrimary\n  }\n  phoneNumbers {\n    id\n    description\n    countryCode\n    areaCode\n    number\n    extension\n    type\n    officePrimary\n    userPrimary\n  }\n}\n    `;\nexport const AcceptNewPriceDocument = gql`\n    mutation acceptNewPrice($id: ID!, $withSupplemental: Boolean = false) {\n  acceptNewPrice(id: $id) {\n    ...BasketFields\n  }\n}\n    ${BasketFieldsFragmentDoc}`;\n\n  @Injectable({\n    providedIn: 'root'\n  })\n  export class AcceptNewPriceGQL extends Apollo.Mutation<AcceptNewPriceMutation, AcceptNewPriceMutationVariables> {\n    document = AcceptNewPriceDocument;\n    \n    constructor(apollo: Apollo.Apollo) {\n      super(apollo);\n    }\n  }\nexport const AddUsersToBasketItemDocument = gql`\n    mutation addUsersToBasketItem($basketItem: ID!, $users: [UserPassengerTypeInput!]!, $withSupplemental: Boolean!) {\n  addUsersToBasketItem(basketItem: $basketItem, users: $users) {\n    ...BasketFields\n  }\n}\n    ${BasketFieldsFragmentDoc}`;\n\n  @Injectable({\n    providedIn: 'root'\n  })\n  export class AddUsersToBasketItemGQL extends Apollo.Mutation<AddUsersToBasketItemMutation, AddUsersToBasketItemMutationVariables> {\n    document = AddUsersToBasketItemDocument;\n    \n    constructor(apollo: Apollo.Apollo) {\n      super(apollo);\n    }\n  }\nexport const GetUserBasketsDocument = gql`\n    query getUserBaskets($user: ID, $traveller: ID, $basketStatus: BasketStatus, $createdAfter: DateTime, $createdBefore: DateTime, $bookedAfter: DateTime, $bookedBefore: DateTime, $dateOfTravelBefore: DateTime, $dateOfTravelAfter: DateTime, $basketItemBookingReference: String, $basketReference: String, $basketTitle: String, $withSupplemental: Boolean = false) {\n  getUserBaskets(user: $user, traveller: $traveller, basketStatus: $basketStatus, createdAfter: $createdAfter, createdBefore: $createdBefore, bookedAfter: $bookedAfter, bookedBefore: $bookedBefore, dateOfTravelBefore: $dateOfTravelBefore, dateOfTravelAfter: $dateOfTravelAfter, basketItemBookingReference: $basketItemBookingReference, basketReference: $basketReference, basketTitle: $basketTitle) {\n    ...BasketFields\n  }\n}\n    ${BasketFieldsFragmentDoc}`;\n\n  @Injectable({\n    providedIn: 'root'\n  })\n  export class GetUserBasketsGQL extends Apollo.Query<GetUserBasketsQuery, GetUserBasketsQueryVariables> {\n    document = GetUserBasketsDocument;\n    \n    constructor(apollo: Apollo.Apollo) {\n      super(apollo);\n    }\n  }\nexport const DeleteBasketDocument = gql`\n    mutation deleteBasket($id: ID, $reference: String) {\n  deleteBasket(id: $id, reference: $reference)\n}\n    `;\n\n  @Injectable({\n    providedIn: 'root'\n  })\n  export class DeleteBasketGQL extends Apollo.Mutation<DeleteBasketMutation, DeleteBasketMutationVariables> {\n    document = DeleteBasketDocument;\n    \n    constructor(apollo: Apollo.Apollo) {\n      super(apollo);\n    }\n  }\nexport const CreateBasketDocument = gql`\n    mutation createBasket($title: String, $withSupplemental: Boolean = false) {\n  createBasket(title: $title) {\n    ...BasketFields\n  }\n}\n    ${BasketFieldsFragmentDoc}`;\n\n  @Injectable({\n    providedIn: 'root'\n  })\n  export class CreateBasketGQL extends Apollo.Mutation<CreateBasketMutation, CreateBasketMutationVariables> {\n    document = CreateBasketDocument;\n    \n    constructor(apollo: Apollo.Apollo) {\n      super(apollo);\n    }\n  }\nexport const RemoveItemFromBasketDocument = gql`\n    mutation removeItemFromBasket($basketItem: ID!, $withSupplemental: Boolean = false) {\n  removeItemFromBasket(basketItem: $basketItem) {\n    ...BasketFields\n  }\n}\n    ${BasketFieldsFragmentDoc}`;\n\n  @Injectable({\n    providedIn: 'root'\n  })\n  export class RemoveItemFromBasketGQL extends Apollo.Mutation<RemoveItemFromBasketMutation, RemoveItemFromBasketMutationVariables> {\n    document = RemoveItemFromBasketDocument;\n    \n    constructor(apollo: Apollo.Apollo) {\n      super(apollo);\n    }\n  }\nexport const SendBasketForApprovalDocument = gql`\n    mutation sendBasketForApproval($basket: ID!, $withSupplemental: Boolean = true) {\n  sendBasketForApproval(basket: $basket) {\n    ...BasketFields\n  }\n}\n    ${BasketFieldsFragmentDoc}`;\n\n  @Injectable({\n    providedIn: 'root'\n  })\n  export class SendBasketForApprovalGQL extends Apollo.Mutation<SendBasketForApprovalMutation, SendBasketForApprovalMutationVariables> {\n    document = SendBasketForApprovalDocument;\n    \n    constructor(apollo: Apollo.Apollo) {\n      super(apollo);\n    }\n  }\nexport const AddItemToBasketDocument = gql`\n    mutation addItemToBasket($basket: ID, $service: ID!, $detail: JSON!, $adults: Int!, $children: Int, $infants: Int, $price: Float!, $currency: CurrencyCode!, $searchQuery: JSON!, $quickAdd: Boolean, $users: [UserPassengerTypeInput], $leadPassenger: ID, $co2PerItem: Float, $co2PerPassenger: Float, $outboundDate: DateTime!, $inboundDate: DateTime, $withSupplemental: Boolean = false) {\n  addItemToBasket(basket: $basket, service: $service, detail: $detail, adults: $adults, children: $children, infants: $infants, price: $price, currency: $currency, searchQuery: $searchQuery, quickAdd: $quickAdd, users: $users, leadPassenger: $leadPassenger, co2PerItem: $co2PerItem, co2PerPassenger: $co2PerPassenger, outboundDate: $outboundDate, inboundDate: $inboundDate) {\n    ...BasketFields\n  }\n}\n    ${BasketFieldsFragmentDoc}`;\n\n  @Injectable({\n    providedIn: 'root'\n  })\n  export class AddItemToBasketGQL extends Apollo.Mutation<AddItemToBasketMutation, AddItemToBasketMutationVariables> {\n    document = AddItemToBasketDocument;\n    \n    constructor(apollo: Apollo.Apollo) {\n      super(apollo);\n    }\n  }\nexport const GetUserBasketDocument = gql`\n    query getUserBasket($id: ID!, $withSupplemental: Boolean = false) {\n  getUserBasket(id: $id) {\n    ...BasketFields\n  }\n}\n    ${BasketFieldsFragmentDoc}`;\n\n  @Injectable({\n    providedIn: 'root'\n  })\n  export class GetUserBasketGQL extends Apollo.Query<GetUserBasketQuery, GetUserBasketQueryVariables> {\n    document = GetUserBasketDocument;\n    \n    constructor(apollo: Apollo.Apollo) {\n      super(apollo);\n    }\n  }\nexport const RevalidateBasketDocument = gql`\n    mutation revalidateBasket($id: ID!, $withSupplemental: Boolean = false) {\n  revalidateBasket(id: $id) {\n    ...BasketFields\n  }\n}\n    ${BasketFieldsFragmentDoc}`;\n\n  @Injectable({\n    providedIn: 'root'\n  })\n  export class RevalidateBasketGQL extends Apollo.Mutation<RevalidateBasketMutation, RevalidateBasketMutationVariables> {\n    document = RevalidateBasketDocument;\n    \n    constructor(apollo: Apollo.Apollo) {\n      super(apollo);\n    }\n  }\nexport const BookBasketDocument = gql`\n    mutation bookBasket($id: ID!, $supplementaryInfo: [SupplementaryBookingInfo!]!, $withSupplemental: Boolean = false) {\n  bookBasket(id: $id, supplementaryInfo: $supplementaryInfo) {\n    ...BasketFields\n  }\n}\n    ${BasketFieldsFragmentDoc}`;\n\n  @Injectable({\n    providedIn: 'root'\n  })\n  export class BookBasketGQL extends Apollo.Mutation<BookBasketMutation, BookBasketMutationVariables> {\n    document = BookBasketDocument;\n    \n    constructor(apollo: Apollo.Apollo) {\n      super(apollo);\n    }\n  }\nexport const SearchCabHireDocument = gql`\n    query searchCabHire($departs: DateTime!, $fromLocation: CabHireLocationInput!, $toLocation: CabHireLocationInput!, $adults: Int!, $children: Int, $infants: Int, $vias: [CabHireLocationInput], $vehicleType: CabHireVehicleType) {\n  searchCabHire(departs: $departs, fromLocation: $fromLocation, toLocation: $toLocation, adults: $adults, children: $children, infants: $infants, vias: $vias, vehicleType: $vehicleType) {\n    results {\n      id\n      source\n      sourceId\n      supplierName\n      estimatedCO2\n      co2PerItem\n      co2PerPassenger\n      price\n      currency\n      vehicleType\n      tripDistanceMetres\n      tripDurationSeconds\n      departs\n      tmcPreferred\n      companyPreferred\n      officePreferred\n      tmcPreferredMessage\n      companyPreferredMessage\n      officePreferredMessage\n      unavailable\n      unavailableMessage\n      fromLocation {\n        address\n        postcode\n        latitude\n        longitude\n      }\n      toLocation {\n        address\n        postcode\n        latitude\n        longitude\n      }\n      vias {\n        address\n        postcode\n        latitude\n        longitude\n      }\n    }\n    errors {\n      ...Errors\n    }\n  }\n}\n    ${ErrorsFragmentDoc}`;\n\n  @Injectable({\n    providedIn: 'root'\n  })\n  export class SearchCabHireGQL extends Apollo.Query<SearchCabHireQuery, SearchCabHireQueryVariables> {\n    document = SearchCabHireDocument;\n    \n    constructor(apollo: Apollo.Apollo) {\n      super(apollo);\n    }\n  }\nexport const CarHireAvailabilityDetailRequestDocument = gql`\n    query carHireAvailabilityDetailRequest($locationDetails: CarHireInputIdentifiers!) {\n  carHireAvailabilityDetailRequest(locationDetails: $locationDetails) {\n    identifiers {\n      locator\n      rph\n      status\n      vehType\n      locationCode\n      extendedLocationCode\n      locationName\n      dropOffLocation\n      pickupDateTime\n      dropoffDateTime\n      vendor\n    }\n    vendor {\n      name\n      logo\n    }\n    address {\n      name\n      topLine\n      city\n      region\n      postCode\n      country\n      countryCode\n      stateCode\n      latitude\n      longitude\n    }\n    additionalInfo {\n      name\n      text\n      json\n      custom {\n        name\n        text\n      }\n    }\n  }\n}\n    `;\n\n  @Injectable({\n    providedIn: 'root'\n  })\n  export class CarHireAvailabilityDetailRequestGQL extends Apollo.Query<CarHireAvailabilityDetailRequestQuery, CarHireAvailabilityDetailRequestQueryVariables> {\n    document = CarHireAvailabilityDetailRequestDocument;\n    \n    constructor(apollo: Apollo.Apollo) {\n      super(apollo);\n    }\n  }\nexport const SearchCarHireDocument = gql`\n    query searchCarHire($airport: CarHireAirportInput, $city: CarHireCityInput, $location: CarHireLocationInput, $depot: InputCarHireDepot, $pickupDateTime: DateTime!, $dropoffDateTime: DateTime!, $vendor: String, $class: CarHireClass, $type: CarHireType, $transmission: CarHireTransmission, $aircon: Boolean, $estimatedDailyDistance: Float, $estimatedDailyDistanceUnits: DistanceTypes) {\n  searchCarHire(airport: $airport, city: $city, location: $location, depot: $depot, pickupDateTime: $pickupDateTime, dropoffDateTime: $dropoffDateTime, vendor: $vendor, class: $class, type: $type, transmission: $transmission, aircon: $aircon, estimatedDailyDistance: $estimatedDailyDistance, estimatedDailyDistanceUnits: $estimatedDailyDistanceUnits) {\n    results {\n      source\n      sourceId\n      identifiers {\n        locator\n        rph\n        status\n        vehType\n        locationCode\n        extendedLocationCode\n        locationName\n        dropOffLocation\n        pickupDateTime\n        dropoffDateTime\n        vendor\n      }\n      displayRecord {\n        status\n        pickup\n        dropoff\n        vendor {\n          name\n          logo\n        }\n        vehicle {\n          class\n          type\n          transmission\n          aircon\n          description\n          images\n        }\n        charges {\n          label\n          amount\n          currencyCode\n        }\n        pickupLocation {\n          name\n          topLine\n          city\n          region\n          postCode\n          country\n          countryCode\n          stateCode\n          latitude\n          longitude\n        }\n        returnLocation {\n          name\n          topLine\n          city\n          region\n          postCode\n          country\n          countryCode\n          stateCode\n          latitude\n          longitude\n        }\n        additionalInfo {\n          name\n          text\n          json\n          custom {\n            name\n            text\n          }\n        }\n      }\n      tmcPreferred\n      companyPreferred\n      officePreferred\n      tmcPreferredMessage\n      companyPreferredMessage\n      officePreferredMessage\n      unavailable\n      unavailableMessage\n      co2PerPassenger\n      co2PerItem\n    }\n    errors {\n      ...Errors\n    }\n  }\n}\n    ${ErrorsFragmentDoc}`;\n\n  @Injectable({\n    providedIn: 'root'\n  })\n  export class SearchCarHireGQL extends Apollo.Query<SearchCarHireQuery, SearchCarHireQueryVariables> {\n    document = SearchCarHireDocument;\n    \n    constructor(apollo: Apollo.Apollo) {\n      super(apollo);\n    }\n  }\nexport const DeleteRecentSearchDocument = gql`\n    mutation deleteRecentSearch($id: ID!) {\n  deleteRecentSearch(id: $id)\n}\n    `;\n\n  @Injectable({\n    providedIn: 'root'\n  })\n  export class DeleteRecentSearchGQL extends Apollo.Mutation<DeleteRecentSearchMutation, DeleteRecentSearchMutationVariables> {\n    document = DeleteRecentSearchDocument;\n    \n    constructor(apollo: Apollo.Apollo) {\n      super(apollo);\n    }\n  }\nexport const DeleteUserAddressDocument = gql`\n    mutation deleteUserAddress($id: ID!) {\n  deleteUserAddress(id: $id)\n}\n    `;\n\n  @Injectable({\n    providedIn: 'root'\n  })\n  export class DeleteUserAddressGQL extends Apollo.Mutation<DeleteUserAddressMutation, DeleteUserAddressMutationVariables> {\n    document = DeleteUserAddressDocument;\n    \n    constructor(apollo: Apollo.Apollo) {\n      super(apollo);\n    }\n  }\nexport const SearchFlightsV2Document = gql`\n    query searchFlightsV2($passengers: [FlightPassengerObject!]!, $originAirport: String, $destinationAirport: String, $multiDestination: [DestinationEntry], $outboundDate: Date, $outboundDepartureTimeWindow: String, $outboundArrivalTimeWindow: String, $outboundCabinClass: [FlightCabinClass], $returnTrip: Boolean!, $returnDate: Date, $returnDepartureTimeWindow: String, $returnArrivalTimeWindow: String, $returnCabinClass: [FlightCabinClass], $fareType: FareType!, $requireFreeBag: Boolean, $maxConnections: Int, $preferredCarriers: [String], $includeNearbyAirports: Boolean, $asSingles: Boolean, $withGrouped: Boolean!) {\n  searchFlightsV2(passengers: $passengers, originAirport: $originAirport, destinationAirport: $destinationAirport, multiDestination: $multiDestination, outboundDate: $outboundDate, outboundDepartureTimeWindow: $outboundDepartureTimeWindow, outboundArrivalTimeWindow: $outboundArrivalTimeWindow, outboundCabinClass: $outboundCabinClass, returnTrip: $returnTrip, returnDate: $returnDate, returnDepartureTimeWindow: $returnDepartureTimeWindow, returnArrivalTimeWindow: $returnArrivalTimeWindow, returnCabinClass: $returnCabinClass, fareType: $fareType, requireFreeBag: $requireFreeBag, maxConnections: $maxConnections, preferredCarriers: $preferredCarriers, includeNearbyAirports: $includeNearbyAirports, asSingles: $asSingles) {\n    results {\n      journeys {\n        uid\n        passengerCount\n        outboundFlights {\n          originAirport\n          originTerminal\n          originAirportName\n          originAirportDetail {\n            iata\n            icao\n            latitude\n            longitude\n            altitude\n            state\n            city\n            road\n            popularity\n            area\n            location\n            offset\n            airportName\n            countryName\n            countryCode\n            postcode\n          }\n          destinationAirport\n          destinationTerminal\n          destinationAirportName\n          destinationAirportDetail {\n            iata\n            icao\n            latitude\n            longitude\n            altitude\n            state\n            city\n            road\n            popularity\n            area\n            location\n            offset\n            airportName\n            countryName\n            countryCode\n            postcode\n          }\n          dateTimeDeparting\n          dateTimeDepartingUTC\n          dateTimeArriving\n          dateTimeArrivingUTC\n          marketingCarrier\n          marketingCarrierName\n          marketingCarrierDetail {\n            name\n            alias\n            callsign\n            iata\n            icao\n            logo\n            banner\n            popularity\n          }\n          marketingFlightNumber\n          operatingCarrier\n          operatingCarrierName\n          operatingCarrierDetail {\n            name\n            alias\n            callsign\n            iata\n            icao\n            logo\n            banner\n            popularity\n          }\n          operatingFlightNumber\n          equipmentCode\n          equipmentName\n          totalDuration\n          cabinClass\n          marketingNames\n          fareConditions {\n            cancellation {\n              name\n              type\n              currency\n              amount\n              remark\n              changeFeeInd\n              cancelFeeInd\n              refundableInd\n            }\n            change {\n              name\n              type\n              currency\n              amount\n              remark\n              changeFeeInd\n              cancelFeeInd\n              refundableInd\n            }\n            noShow {\n              name\n              type\n              currency\n              amount\n              remark\n              changeFeeInd\n              cancelFeeInd\n              refundableInd\n            }\n            upgrade {\n              name\n              type\n              currency\n              amount\n              remark\n              changeFeeInd\n              cancelFeeInd\n              refundableInd\n            }\n            other {\n              name\n              type\n              currency\n              amount\n              remark\n              changeFeeInd\n              cancelFeeInd\n              refundableInd\n            }\n          }\n          vendorCode\n          stops\n          bookingCode\n          marriageGroup\n          fareBasisCode\n          additional\n        }\n        inboundFlights {\n          originAirport\n          originTerminal\n          originAirportName\n          originAirportDetail {\n            iata\n            icao\n            latitude\n            longitude\n            altitude\n            state\n            city\n            road\n            popularity\n            area\n            location\n            offset\n            airportName\n            countryName\n            countryCode\n            postcode\n          }\n          destinationAirport\n          destinationTerminal\n          destinationAirportName\n          destinationAirportDetail {\n            iata\n            icao\n            latitude\n            longitude\n            altitude\n            state\n            city\n            road\n            popularity\n            area\n            location\n            offset\n            airportName\n            countryName\n            countryCode\n            postcode\n          }\n          dateTimeDeparting\n          dateTimeDepartingUTC\n          dateTimeArriving\n          dateTimeArrivingUTC\n          marketingCarrier\n          marketingCarrierName\n          marketingCarrierDetail {\n            name\n            alias\n            callsign\n            iata\n            icao\n            logo\n            banner\n            popularity\n          }\n          marketingFlightNumber\n          operatingCarrier\n          operatingCarrierName\n          operatingCarrierDetail {\n            name\n            alias\n            callsign\n            iata\n            icao\n            logo\n            banner\n            popularity\n          }\n          operatingFlightNumber\n          equipmentCode\n          equipmentName\n          totalDuration\n          cabinClass\n          marketingNames\n          fareConditions {\n            cancellation {\n              name\n              type\n              currency\n              amount\n              remark\n              changeFeeInd\n              cancelFeeInd\n              refundableInd\n            }\n            change {\n              name\n              type\n              currency\n              amount\n              remark\n              changeFeeInd\n              cancelFeeInd\n              refundableInd\n            }\n            noShow {\n              name\n              type\n              currency\n              amount\n              remark\n              changeFeeInd\n              cancelFeeInd\n              refundableInd\n            }\n            upgrade {\n              name\n              type\n              currency\n              amount\n              remark\n              changeFeeInd\n              cancelFeeInd\n              refundableInd\n            }\n            other {\n              name\n              type\n              currency\n              amount\n              remark\n              changeFeeInd\n              cancelFeeInd\n              refundableInd\n            }\n          }\n          vendorCode\n          stops\n          bookingCode\n          marriageGroup\n          fareBasisCode\n          additional\n        }\n        outboundTotalDuration\n        outboundCarbonEmissions {\n          amount\n          unit\n        }\n        inboundTotalDuration\n        inboundCarbonEmissions {\n          amount\n          unit\n        }\n        taxes {\n          description\n          amount\n          currency\n        }\n        discounts {\n          description\n          amount\n          currency\n        }\n        total {\n          price\n          tax\n          discount\n          currency\n        }\n        fareConditions {\n          cancellation {\n            name\n            type\n            currency\n            amount\n            remark\n            changeFeeInd\n            cancelFeeInd\n            refundableInd\n          }\n          change {\n            name\n            type\n            currency\n            amount\n            remark\n            changeFeeInd\n            cancelFeeInd\n            refundableInd\n          }\n          noShow {\n            name\n            type\n            currency\n            amount\n            remark\n            changeFeeInd\n            cancelFeeInd\n            refundableInd\n          }\n          upgrade {\n            name\n            type\n            currency\n            amount\n            remark\n            changeFeeInd\n            cancelFeeInd\n            refundableInd\n          }\n          other {\n            name\n            type\n            currency\n            amount\n            remark\n            changeFeeInd\n            cancelFeeInd\n            refundableInd\n          }\n        }\n        baggageAllowance {\n          type\n          qty\n          maxKG\n          maxLBS\n        }\n        additional\n        source\n        sourceId\n        version\n        tmcPreferred\n        companyPreferred\n        officePreferred\n        tmcPreferredMessage\n        companyPreferredMessage\n        officePreferredMessage\n        unavailable\n        unavailableMessage\n        co2PerItem\n        co2PerPassenger\n      }\n      multi {\n        order\n        origin\n        destination\n        results {\n          uid\n          passengerCount\n          outboundFlights {\n            originAirport\n            originTerminal\n            originAirportName\n            originAirportDetail {\n              iata\n              icao\n              latitude\n              longitude\n              altitude\n              state\n              city\n              road\n              popularity\n              area\n              location\n              offset\n              airportName\n              countryName\n              countryCode\n              postcode\n            }\n            destinationAirport\n            destinationTerminal\n            destinationAirportName\n            destinationAirportDetail {\n              iata\n              icao\n              latitude\n              longitude\n              altitude\n              state\n              city\n              road\n              popularity\n              area\n              location\n              offset\n              airportName\n              countryName\n              countryCode\n              postcode\n            }\n            dateTimeDeparting\n            dateTimeDepartingUTC\n            dateTimeArriving\n            dateTimeArrivingUTC\n            marketingCarrier\n            marketingCarrierName\n            marketingCarrierDetail {\n              name\n              alias\n              callsign\n              iata\n              icao\n              logo\n              banner\n              popularity\n            }\n            marketingFlightNumber\n            operatingCarrier\n            operatingCarrierName\n            operatingCarrierDetail {\n              name\n              alias\n              callsign\n              iata\n              icao\n              logo\n              banner\n              popularity\n            }\n            operatingFlightNumber\n            equipmentCode\n            equipmentName\n            totalDuration\n            cabinClass\n            marketingNames\n            fareConditions {\n              cancellation {\n                name\n                type\n                currency\n                amount\n                remark\n                changeFeeInd\n                cancelFeeInd\n                refundableInd\n              }\n              change {\n                name\n                type\n                currency\n                amount\n                remark\n                changeFeeInd\n                cancelFeeInd\n                refundableInd\n              }\n              noShow {\n                name\n                type\n                currency\n                amount\n                remark\n                changeFeeInd\n                cancelFeeInd\n                refundableInd\n              }\n              upgrade {\n                name\n                type\n                currency\n                amount\n                remark\n                changeFeeInd\n                cancelFeeInd\n                refundableInd\n              }\n              other {\n                name\n                type\n                currency\n                amount\n                remark\n                changeFeeInd\n                cancelFeeInd\n                refundableInd\n              }\n            }\n            vendorCode\n            stops\n            bookingCode\n            marriageGroup\n            fareBasisCode\n            additional\n          }\n          inboundFlights {\n            originAirport\n            originTerminal\n            originAirportName\n            originAirportDetail {\n              iata\n              icao\n              latitude\n              longitude\n              altitude\n              state\n              city\n              road\n              popularity\n              area\n              location\n              offset\n              airportName\n              countryName\n              countryCode\n              postcode\n            }\n            destinationAirport\n            destinationTerminal\n            destinationAirportName\n            destinationAirportDetail {\n              iata\n              icao\n              latitude\n              longitude\n              altitude\n              state\n              city\n              road\n              popularity\n              area\n              location\n              offset\n              airportName\n              countryName\n              countryCode\n              postcode\n            }\n            dateTimeDeparting\n            dateTimeDepartingUTC\n            dateTimeArriving\n            dateTimeArrivingUTC\n            marketingCarrier\n            marketingCarrierName\n            marketingCarrierDetail {\n              name\n              alias\n              callsign\n              iata\n              icao\n              logo\n              banner\n              popularity\n            }\n            marketingFlightNumber\n            operatingCarrier\n            operatingCarrierName\n            operatingCarrierDetail {\n              name\n              alias\n              callsign\n              iata\n              icao\n              logo\n              banner\n              popularity\n            }\n            operatingFlightNumber\n            equipmentCode\n            equipmentName\n            totalDuration\n            cabinClass\n            marketingNames\n            fareConditions {\n              cancellation {\n                name\n                type\n                currency\n                amount\n                remark\n                changeFeeInd\n                cancelFeeInd\n                refundableInd\n              }\n              change {\n                name\n                type\n                currency\n                amount\n                remark\n                changeFeeInd\n                cancelFeeInd\n                refundableInd\n              }\n              noShow {\n                name\n                type\n                currency\n                amount\n                remark\n                changeFeeInd\n                cancelFeeInd\n                refundableInd\n              }\n              upgrade {\n                name\n                type\n                currency\n                amount\n                remark\n                changeFeeInd\n                cancelFeeInd\n                refundableInd\n              }\n              other {\n                name\n                type\n                currency\n                amount\n                remark\n                changeFeeInd\n                cancelFeeInd\n                refundableInd\n              }\n            }\n            vendorCode\n            stops\n            bookingCode\n            marriageGroup\n            fareBasisCode\n            additional\n          }\n          outboundTotalDuration\n          outboundCarbonEmissions {\n            amount\n            unit\n          }\n          inboundTotalDuration\n          inboundCarbonEmissions {\n            amount\n            unit\n          }\n          taxes {\n            description\n            amount\n            currency\n          }\n          discounts {\n            description\n            amount\n            currency\n          }\n          total {\n            price\n            tax\n            discount\n            currency\n          }\n          fareConditions {\n            cancellation {\n              name\n              type\n              currency\n              amount\n              remark\n              changeFeeInd\n              cancelFeeInd\n              refundableInd\n            }\n            change {\n              name\n              type\n              currency\n              amount\n              remark\n              changeFeeInd\n              cancelFeeInd\n              refundableInd\n            }\n            noShow {\n              name\n              type\n              currency\n              amount\n              remark\n              changeFeeInd\n              cancelFeeInd\n              refundableInd\n            }\n            upgrade {\n              name\n              type\n              currency\n              amount\n              remark\n              changeFeeInd\n              cancelFeeInd\n              refundableInd\n            }\n            other {\n              name\n              type\n              currency\n              amount\n              remark\n              changeFeeInd\n              cancelFeeInd\n              refundableInd\n            }\n          }\n          baggageAllowance {\n            type\n            qty\n            maxKG\n            maxLBS\n          }\n          additional\n          source\n          sourceId\n          version\n          tmcPreferred\n          companyPreferred\n          officePreferred\n          tmcPreferredMessage\n          companyPreferredMessage\n          officePreferredMessage\n          unavailable\n          unavailableMessage\n          co2PerItem\n          co2PerPassenger\n        }\n        minPrice\n        maxPrice\n      }\n      grouped {\n        ...GroupedFields @include(if: $withGrouped)\n      }\n    }\n    errors {\n      ...Errors\n    }\n  }\n}\n    ${GroupedFieldsFragmentDoc}\n${ErrorsFragmentDoc}`;\n\n  @Injectable({\n    providedIn: 'root'\n  })\n  export class SearchFlightsV2GQL extends Apollo.Query<SearchFlightsV2Query, SearchFlightsV2QueryVariables> {\n    document = SearchFlightsV2Document;\n    \n    constructor(apollo: Apollo.Apollo) {\n      super(apollo);\n    }\n  }\nexport const GetCarHireDepotsDocument = gql`\n    query getCarHireDepots($latitude: Float!, $longitude: Float!, $vendorCode: String) {\n  getCarHireDepots(latitude: $latitude, longitude: $longitude, vendorCode: $vendorCode) {\n    countryCode\n    locationCode\n    extendedLocationCode\n    vendorCode\n    latitude\n    longitude\n    vendor\n    addressLines\n    cityName\n  }\n}\n    `;\n\n  @Injectable({\n    providedIn: 'root'\n  })\n  export class GetCarHireDepotsGQL extends Apollo.Query<GetCarHireDepotsQuery, GetCarHireDepotsQueryVariables> {\n    document = GetCarHireDepotsDocument;\n    \n    constructor(apollo: Apollo.Apollo) {\n      super(apollo);\n    }\n  }\nexport const GetConfermaOfficeNamesDocument = gql`\n    query getConfermaOfficeNames {\n  getConfermaOfficeNames {\n    results {\n      id\n      name\n    }\n    errors {\n      ...Errors\n    }\n  }\n}\n    ${ErrorsFragmentDoc}`;\n\n  @Injectable({\n    providedIn: 'root'\n  })\n  export class GetConfermaOfficeNamesGQL extends Apollo.Query<GetConfermaOfficeNamesQuery, GetConfermaOfficeNamesQueryVariables> {\n    document = GetConfermaOfficeNamesDocument;\n    \n    constructor(apollo: Apollo.Apollo) {\n      super(apollo);\n    }\n  }\nexport const GetConfermaQuicklistDocument = gql`\n    query getConfermaQuicklist($countryCode: String!) {\n  getConfermaQuicklist(countryCode: $countryCode) {\n    results {\n      id\n      name\n      imageUrl\n      group\n      location {\n        distance\n        distanceType\n        longitude\n        latitude\n      }\n      address {\n        addressLine1\n        addressLine2\n        addressLine3\n        postOrZipCode\n        countryCode\n        telephone\n        facsimile\n      }\n      transports {\n        type\n        name\n        code\n        distance\n        distanceType\n        longitude\n        latitude\n      }\n      preferred {\n        client\n        consumer\n      }\n      tags {\n        name\n        display\n        type\n        icon\n      }\n      availableRates {\n        hotelId\n        imageUrl\n        rooms {\n          roomId\n          roomType\n          roomDescription\n          rateCode\n          rateDescription\n          total\n          currencyCode\n          currencyConversion {\n            rate\n            localCode\n            localTotal\n            convertedCode\n            convertedTotal\n          }\n          deposit {\n            amount\n            policy\n            required\n          }\n          nights {\n            night\n            rate\n            info\n            date\n          }\n          policies {\n            cancellation\n            deposit\n            disabledAccess\n            general\n            guarantee\n            refundAvailable\n          }\n          tax {\n            included\n            rate\n          }\n          acceptedCards {\n            id\n            name\n          }\n          paymentTypes {\n            type\n            name\n          }\n        }\n        prpn\n        currencyCode\n        isBusy\n        source\n        version\n      }\n      version\n      tmcPreferredMessage\n      companyPreferredMessage\n      officePreferredMessage\n      unavailableMessage\n    }\n    errors {\n      ...Errors\n    }\n  }\n}\n    ${ErrorsFragmentDoc}`;\n\n  @Injectable({\n    providedIn: 'root'\n  })\n  export class GetConfermaQuicklistGQL extends Apollo.Query<GetConfermaQuicklistQuery, GetConfermaQuicklistQueryVariables> {\n    document = GetConfermaQuicklistDocument;\n    \n    constructor(apollo: Apollo.Apollo) {\n      super(apollo);\n    }\n  }\nexport const GetRailStationDocument = gql`\n    query getRailStation($id: ID, $code: String) {\n  getRailStation(id: $id, code: $code) {\n    id\n    name\n    stationCode\n    nlcCode\n    trainlineCode\n    trainlineUniqueCode\n    locationDetails {\n      continent\n      country\n      countryCode\n      state\n      city\n      coordinates {\n        latitude\n        longitude\n        altitude\n      }\n      postcode\n      road\n      gridReference\n      northing\n      easting\n    }\n  }\n}\n    `;\n\n  @Injectable({\n    providedIn: 'root'\n  })\n  export class GetRailStationGQL extends Apollo.Query<GetRailStationQuery, GetRailStationQueryVariables> {\n    document = GetRailStationDocument;\n    \n    constructor(apollo: Apollo.Apollo) {\n      super(apollo);\n    }\n  }\nexport const GetRailcardsDocument = gql`\n    query getRailcards {\n  getRailcards {\n    name\n    code\n  }\n}\n    `;\n\n  @Injectable({\n    providedIn: 'root'\n  })\n  export class GetRailcardsGQL extends Apollo.Query<GetRailcardsQuery, GetRailcardsQueryVariables> {\n    document = GetRailcardsDocument;\n    \n    constructor(apollo: Apollo.Apollo) {\n      super(apollo);\n    }\n  }\nexport const GetRiskAlertsDocument = gql`\n    query getRiskAlerts($minLevel: RiskLevel!, $maxLevel: RiskLevel!, $countryIsoCode: String, $airport: ID, $railStation: ID, $airportIata: String) {\n  getRiskAlerts(minLevel: $minLevel, maxLevel: $maxLevel, countryIsoCode: $countryIsoCode, airport: $airport, railStation: $railStation, airportIata: $airportIata) {\n    id\n    title\n    description\n    breaking\n    risk\n    category\n    country\n    location\n    latitude\n    longitude\n    startDate\n    endDate\n    receivedDate\n  }\n}\n    `;\n\n  @Injectable({\n    providedIn: 'root'\n  })\n  export class GetRiskAlertsGQL extends Apollo.Query<GetRiskAlertsQuery, GetRiskAlertsQueryVariables> {\n    document = GetRiskAlertsDocument;\n    \n    constructor(apollo: Apollo.Apollo) {\n      super(apollo);\n    }\n  }\nexport const GetUserAddressesDocument = gql`\n    query getUserAddresses {\n  getUserAddresses {\n    id\n    description\n    numberOrName\n    street\n    town\n    county\n    postcode\n    countryCode\n    userPrimary\n    officePrimary\n  }\n}\n    `;\n\n  @Injectable({\n    providedIn: 'root'\n  })\n  export class GetUserAddressesGQL extends Apollo.Query<GetUserAddressesQuery, GetUserAddressesQueryVariables> {\n    document = GetUserAddressesDocument;\n    \n    constructor(apollo: Apollo.Apollo) {\n      super(apollo);\n    }\n  }\nexport const GetUserCompanyOfficesDocument = gql`\n    query getUserCompanyOffices {\n  getUserCompanyOffices {\n    id\n    name\n    addresses {\n      id\n      description\n      numberOrName\n      street\n      town\n      county\n      postcode\n      countryCode\n      userPrimary\n      officePrimary\n    }\n  }\n}\n    `;\n\n  @Injectable({\n    providedIn: 'root'\n  })\n  export class GetUserCompanyOfficesGQL extends Apollo.Query<GetUserCompanyOfficesQuery, GetUserCompanyOfficesQueryVariables> {\n    document = GetUserCompanyOfficesDocument;\n    \n    constructor(apollo: Apollo.Apollo) {\n      super(apollo);\n    }\n  }\nexport const GetUserCurrentCarbonAllowanceDocument = gql`\n    query getUserCurrentCarbonAllowance($user: ID) {\n  getUserCurrentCarbonAllowance(user: $user) {\n    id\n    startOfPeriod\n    endOfPeriod\n    remainingCo2\n    totalCo2\n    carbonPolicySource\n    company {\n      id\n      name\n    }\n    office {\n      id\n      name\n    }\n    user {\n      id\n      forename\n      surname\n      email\n    }\n    periodConsumption {\n      id\n      consumed\n      datetime\n    }\n  }\n}\n    `;\n\n  @Injectable({\n    providedIn: 'root'\n  })\n  export class GetUserCurrentCarbonAllowanceGQL extends Apollo.Query<GetUserCurrentCarbonAllowanceQuery, GetUserCurrentCarbonAllowanceQueryVariables> {\n    document = GetUserCurrentCarbonAllowanceDocument;\n    \n    constructor(apollo: Apollo.Apollo) {\n      super(apollo);\n    }\n  }\nexport const GetUserMiAutoSuggestValuesDocument = gql`\n    query getUserMIAutoSuggestValues($mi: ID!, $partialLabel: String!) {\n  getUserMIAutoSuggestValues(mi: $mi, partialLabel: $partialLabel) {\n    id\n    label\n    value\n    default\n    fixed\n    agentOnly\n  }\n}\n    `;\n\n  @Injectable({\n    providedIn: 'root'\n  })\n  export class GetUserMiAutoSuggestValuesGQL extends Apollo.Query<GetUserMiAutoSuggestValuesQuery, GetUserMiAutoSuggestValuesQueryVariables> {\n    document = GetUserMiAutoSuggestValuesDocument;\n    \n    constructor(apollo: Apollo.Apollo) {\n      super(apollo);\n    }\n  }\nexport const GetUserPhoneDocument = gql`\n    query getUserPhone {\n  getUserPhoneNumbers {\n    id\n    description\n    countryCode\n    areaCode\n    number\n    extension\n    type\n    officePrimary\n    userPrimary\n  }\n}\n    `;\n\n  @Injectable({\n    providedIn: 'root'\n  })\n  export class GetUserPhoneGQL extends Apollo.Query<GetUserPhoneQuery, GetUserPhoneQueryVariables> {\n    document = GetUserPhoneDocument;\n    \n    constructor(apollo: Apollo.Apollo) {\n      super(apollo);\n    }\n  }\nexport const GetUserRecentSearchesDocument = gql`\n    query getUserRecentSearches($serviceType: ServiceType) {\n  getUserRecentSearches(serviceType: $serviceType) {\n    id\n    name\n    serviceType\n    searchArgs\n    createdAt\n    updatedAt\n    travelDate\n    travellers {\n      id\n      title\n      forename\n      surname\n      email\n      username\n      dob\n    }\n  }\n}\n    `;\n\n  @Injectable({\n    providedIn: 'root'\n  })\n  export class GetUserRecentSearchesGQL extends Apollo.Query<GetUserRecentSearchesQuery, GetUserRecentSearchesQueryVariables> {\n    document = GetUserRecentSearchesDocument;\n    \n    constructor(apollo: Apollo.Apollo) {\n      super(apollo);\n    }\n  }\nexport const SearchHotelsDocument = gql`\n    query searchHotels($startDate: Date!, $endDate: Date!, $cityName: String, $postOrZipCode: String, $countryCode: String, $latitude: Float, $longitude: Float, $trainStationCode: String, $iata: String, $officeId: Int, $rooms: Int!, $adults: Int!, $children: Int, $currency: String!, $distanceType: DistanceTypes!, $distance: Int!, $maxResults: Int, $hotelName: String, $groupName: String) {\n  searchHotels(startDate: $startDate, endDate: $endDate, cityName: $cityName, postOrZipCode: $postOrZipCode, countryCode: $countryCode, latitude: $latitude, longitude: $longitude, trainStationCode: $trainStationCode, iata: $iata, officeId: $officeId, rooms: $rooms, adults: $adults, children: $children, currency: $currency, distanceType: $distanceType, distance: $distance, maxResults: $maxResults, hotelName: $hotelName, groupName: $groupName) {\n    results {\n      id\n      name\n      imageUrl\n      group\n      location {\n        distance\n        distanceType\n        longitude\n        latitude\n      }\n      address {\n        addressLine1\n        addressLine2\n        addressLine3\n        postOrZipCode\n        countryCode\n        telephone\n        facsimile\n      }\n      transports {\n        type\n        name\n        code\n        distance\n        distanceType\n        longitude\n        latitude\n      }\n      preferred {\n        client\n        consumer\n      }\n      tags {\n        name\n        display\n        type\n        icon\n      }\n      availableRates {\n        hotelId\n        imageUrl\n        rooms {\n          roomId\n          roomType\n          roomDescription\n          rateCode\n          rateDescription\n          total\n          currencyCode\n          currencyConversion {\n            rate\n            localCode\n            localTotal\n            convertedCode\n            convertedTotal\n          }\n          deposit {\n            amount\n            policy\n            required\n          }\n          nights {\n            night\n            rate\n            info\n            date\n          }\n          policies {\n            cancellation\n            deposit\n            disabledAccess\n            general\n            guarantee\n            refundAvailable\n          }\n          tax {\n            included\n            rate\n          }\n          acceptedCards {\n            id\n            name\n          }\n          paymentTypes {\n            type\n            name\n          }\n        }\n        prpn\n        currencyCode\n        isBusy\n        source\n        version\n      }\n      co2PerPassenger\n      co2PerItem\n      source\n      sourceId\n      version\n      tmcPreferred\n      companyPreferred\n      officePreferred\n      tmcPreferredMessage\n      companyPreferredMessage\n      officePreferredMessage\n      unavailable\n      unavailableMessage\n    }\n    errors {\n      service {\n        id\n        type\n        name\n        description\n        detailSchema\n        searchQuerySchema\n      }\n      errorMessage\n      errorCode\n    }\n  }\n}\n    `;\n\n  @Injectable({\n    providedIn: 'root'\n  })\n  export class SearchHotelsGQL extends Apollo.Query<SearchHotelsQuery, SearchHotelsQueryVariables> {\n    document = SearchHotelsDocument;\n    \n    constructor(apollo: Apollo.Apollo) {\n      super(apollo);\n    }\n  }\nexport const GetMultipleHotelsAvailabilityDocument = gql`\n    query getMultipleHotelsAvailability($hotel: [String!]!, $startDate: Date!, $endDate: Date!, $currency: String!, $occupants: Int!, $rooms: Int) {\n  getMultipleHotelsAvailability(hotel: $hotel, startDate: $startDate, endDate: $endDate, currency: $currency, occupants: $occupants, rooms: $rooms) {\n    results {\n      hotelId\n      rooms {\n        roomId\n        roomType\n        roomDescription\n        rateCode\n        rateDescription\n        total\n        currencyCode\n        currencyConversion {\n          rate\n          localCode\n          localTotal\n          convertedCode\n          convertedTotal\n        }\n        deposit {\n          amount\n          policy\n          required\n        }\n        nights {\n          night\n          rate\n          info\n          date\n        }\n        policies {\n          cancellation\n          deposit\n          disabledAccess\n          general\n          guarantee\n          refundAvailable\n        }\n        tax {\n          included\n          rate\n        }\n        acceptedCards {\n          id\n          name\n        }\n        paymentTypes {\n          type\n          name\n        }\n      }\n      prpn\n      currencyCode\n      isBusy\n      source\n      version\n    }\n    errors {\n      ...Errors\n    }\n  }\n}\n    ${ErrorsFragmentDoc}`;\n\n  @Injectable({\n    providedIn: 'root'\n  })\n  export class GetMultipleHotelsAvailabilityGQL extends Apollo.Query<GetMultipleHotelsAvailabilityQuery, GetMultipleHotelsAvailabilityQueryVariables> {\n    document = GetMultipleHotelsAvailabilityDocument;\n    \n    constructor(apollo: Apollo.Apollo) {\n      super(apollo);\n    }\n  }\nexport const IsPostcodeValidDocument = gql`\n    query isPostcodeValid($postcode: String!) {\n  isPostcodeValid(postcode: $postcode)\n}\n    `;\n\n  @Injectable({\n    providedIn: 'root'\n  })\n  export class IsPostcodeValidGQL extends Apollo.Query<IsPostcodeValidQuery, IsPostcodeValidQueryVariables> {\n    document = IsPostcodeValidDocument;\n    \n    constructor(apollo: Apollo.Apollo) {\n      super(apollo);\n    }\n  }\nexport const SearchAirportsDocument = gql`\n    query searchAirports($query: String!, $countryCode: String, $hasLounge: Boolean, $hasParking: Boolean, $hasFastTrack: Boolean) {\n  searchAirports(query: $query, countryCode: $countryCode, hasLounge: $hasLounge, hasParking: $hasParking, hasFastTrack: $hasFastTrack) {\n    iataMatch {\n      id\n      name\n      iata\n      icao\n      terminals\n      locationDetails {\n        ...LOCATION_DETAIL\n      }\n    }\n    generalMatches {\n      id\n      name\n      iata\n      icao\n      terminals\n      locationDetails {\n        ...LOCATION_DETAIL\n      }\n    }\n  }\n}\n    ${Location_DetailFragmentDoc}`;\n\n  @Injectable({\n    providedIn: 'root'\n  })\n  export class SearchAirportsGQL extends Apollo.Query<SearchAirportsQuery, SearchAirportsQueryVariables> {\n    document = SearchAirportsDocument;\n    \n    constructor(apollo: Apollo.Apollo) {\n      super(apollo);\n    }\n  }\nexport const SearchLoungesDocument = gql`\n    query searchLounges($locationCode: String!, $arrivalDatetime: DateTime!, $adults: Int!, $children: Int, $infants: Int, $terminal: String) {\n  searchLounges(locationCode: $locationCode, arrivalDatetime: $arrivalDatetime, adults: $adults, children: $children, infants: $infants, terminal: $terminal) {\n    results {\n      source\n      sourceId\n      name\n      code\n      price\n      currency\n      lounge {\n        code\n        name\n        airport\n        terminal\n        address\n        telephone\n        fax\n        directions\n        introduction\n        logo\n        mobileImage\n        furtherImages\n        adultAge\n        childAge\n        infantAge\n        landside\n        airside\n        facilities\n        openTime\n        closeTime\n        wifi\n        tv\n        snacks\n        phone\n        internet\n        childrenAllowed\n        disabledAccess\n        drinks\n        freeDrinks\n        freeFood\n        smokingPermitted\n        magazines\n        includedDrinks\n        menuFood\n        menuDrinks\n        menuExtras\n        whatsIncludedDrinks\n        whatsIncludedExtras\n        whatsIncludedFood\n        groupInfo\n        checkInInfo\n        dressCode\n        facilitiesInfo\n        foodAndBeverage\n        cancellationInfo\n        amendmentsInfo\n        misc\n      }\n      tmcPreferred\n      companyPreferred\n      officePreferred\n      tmcPreferredMessage\n      companyPreferredMessage\n      officePreferredMessage\n      unavailable\n      unavailableMessage\n      co2PerPassenger\n      co2PerItem\n    }\n    errors {\n      ...Errors\n    }\n  }\n}\n    ${ErrorsFragmentDoc}`;\n\n  @Injectable({\n    providedIn: 'root'\n  })\n  export class SearchLoungesGQL extends Apollo.Query<SearchLoungesQuery, SearchLoungesQueryVariables> {\n    document = SearchLoungesDocument;\n    \n    constructor(apollo: Apollo.Apollo) {\n      super(apollo);\n    }\n  }\nexport const MoveItemToADifferentBasketDocument = gql`\n    mutation moveItemToADifferentBasket($basketItem: ID!, $newBasket: ID!, $withSupplemental: Boolean = false) {\n  moveItemToADifferentBasket(basketItem: $basketItem, newBasket: $newBasket) {\n    ...BasketFields\n  }\n}\n    ${BasketFieldsFragmentDoc}`;\n\n  @Injectable({\n    providedIn: 'root'\n  })\n  export class MoveItemToADifferentBasketGQL extends Apollo.Mutation<MoveItemToADifferentBasketMutation, MoveItemToADifferentBasketMutationVariables> {\n    document = MoveItemToADifferentBasketDocument;\n    \n    constructor(apollo: Apollo.Apollo) {\n      super(apollo);\n    }\n  }\nexport const SearchParkingDocument = gql`\n    query searchParking($arrivalDatetime: DateTime!, $departDatetime: DateTime!, $locationCode: String!, $outFlightNumber: String, $recommended: Boolean, $onAirport: Boolean, $meetAndGreet: Boolean, $parkAndRide: Boolean, $parkAndStroll: Boolean, $carParkedForYou: Boolean, $terminal: String) {\n  searchParking(arrivalDatetime: $arrivalDatetime, departDatetime: $departDatetime, locationCode: $locationCode, outFlightNumber: $outFlightNumber, recommended: $recommended, onAirport: $onAirport, meetAndGreet: $meetAndGreet, parkAndRide: $parkAndRide, parkAndStroll: $parkAndStroll, carParkedForYou: $carParkedForYou, terminal: $terminal) {\n    results {\n      source\n      sourceId\n      carPark {\n        code\n        name\n        airport\n        terminal\n        latitude\n        longitude\n        address\n        distanceToAirport\n        onAirport\n        carParkedForYou\n        meetAndGreet\n        telephone\n        fax\n        directions\n        arrivalProcedure\n        departureProcedure\n        maximumCarSize\n        introduction\n        information\n        transferInformation\n        transferOperatingTimes\n        transferTime\n        logo\n        defaultImage\n        brandImage\n        mobileImage\n        furtherImages\n        misc\n      }\n      requiredInfo\n      price\n      currency\n      misc\n      tmcPreferred\n      companyPreferred\n      officePreferred\n      tmcPreferredMessage\n      companyPreferredMessage\n      officePreferredMessage\n      unavailable\n      unavailableMessage\n      co2PerPassenger\n      co2PerItem\n    }\n    errors {\n      ...Errors\n    }\n  }\n}\n    ${ErrorsFragmentDoc}`;\n\n  @Injectable({\n    providedIn: 'root'\n  })\n  export class SearchParkingGQL extends Apollo.Query<SearchParkingQuery, SearchParkingQueryVariables> {\n    document = SearchParkingDocument;\n    \n    constructor(apollo: Apollo.Apollo) {\n      super(apollo);\n    }\n  }\nexport const SearchRailDocument = gql`\n    query searchRail($countryCode: String!, $journeyType: RailJourneyType!, $class: RailClass, $outboundArrivalDateTime: DateTime, $outboundDepartureDateTime: DateTime, $departureLocationId: ID!, $arrivalLocationId: ID!, $adults: Int!, $children: Int, $returnArrivalDateTime: DateTime, $returnDepartureDateTime: DateTime, $railCardQualifiers: [String!], $viaLocationId: ID, $extraTimeToChange: Boolean, $plusBusOut: RailPlusBusAvail, $plusBusReturn: RailPlusBusAvail) {\n  searchRail(countryCode: $countryCode, journeyType: $journeyType, class: $class, outboundArrivalDateTime: $outboundArrivalDateTime, outboundDepartureDateTime: $outboundDepartureDateTime, departureLocationId: $departureLocationId, arrivalLocationId: $arrivalLocationId, adults: $adults, children: $children, returnArrivalDateTime: $returnArrivalDateTime, returnDepartureDateTime: $returnDepartureDateTime, railCardQualifiers: $railCardQualifiers, viaLocationId: $viaLocationId, extraTimeToChange: $extraTimeToChange, plusBusOut: $plusBusOut, plusBusReturn: $plusBusReturn) {\n    results {\n      source\n      sourceId\n      outbound {\n        identifiers {\n          transactionIdentifier\n          journeyIdentifier\n          provider\n          fareIdentifier\n          direction\n          singleOrReturn\n          bookingRef\n        }\n        travellers {\n          status\n          id\n          dob\n          railcard\n          givenName\n          surname\n          nameTitle\n          contactInfo\n          deliveryEmailAddress\n          fare\n        }\n        co2PerItem\n        from\n        fromCode\n        to\n        toCode\n        co2PerPassenger\n        departDateTime\n        arriveDateTime\n        changes\n        segments {\n          id\n          operator\n          depart\n          departDateTime\n          arrive\n          arriveDateTime\n          reservableStatus\n          seatPreferenceTypes {\n            name\n            allowedValues\n          }\n          seatPreferenceGroup\n          seats {\n            location\n            coach\n            number\n            direction\n            position\n            deck\n            seatType\n            seatSelection\n            facilities\n            note\n          }\n          callingPoints {\n            stationName\n            stationCode\n            arrivalDateTime\n            departureDateTime\n            scheduledPlatform\n            stationClassification\n            stoppingPattern\n          }\n        }\n        providers {\n          providerId\n          name\n          cheapestTicket {\n            identifiers {\n              transactionIdentifier\n              journeyIdentifier\n              provider\n              fareIdentifier\n              direction\n              singleOrReturn\n              bookingRef\n            }\n            type\n            terms {\n              error\n              ticketTypeCode\n              trainOperatingCompanyCode\n              ticketTypeName\n              ticketTypeAltName\n              ticketTypeClass\n              reservationRule\n              journeyType\n              preBookingRequirement\n              generalValidity\n              validOutRule\n              validReturnRule\n              generalDiscount\n              childDiscount\n              railcardDiscount\n              refundCancellationRule\n              changeRule\n              ticketTypeConditionsDescription\n              journeyBreakRule\n              availabilityRule\n              todAvailable\n              kioskAvailable\n              startDate\n              endDate\n              dynamicConditions {\n                name\n                description\n              }\n            }\n            class\n            singleOrReturn\n            price\n            reservableStatus\n            currency\n            route\n            routeCode\n            tickets {\n              price\n              type\n              route\n              segments {\n                id\n                operator\n                depart\n                departDateTime\n                arrive\n                arriveDateTime\n                reservableStatus\n                seatPreferenceGroup\n              }\n              numChildren\n              numAdults\n            }\n            availableSeats\n            ticketQueueList {\n              id\n              name\n              type\n            }\n            accountsList {\n              id\n              reference\n              description\n              isDefault\n              type\n            }\n          }\n          ticketOptions {\n            identifiers {\n              transactionIdentifier\n              journeyIdentifier\n              provider\n              fareIdentifier\n              direction\n              singleOrReturn\n              bookingRef\n              allowedWith {\n                transactionIdentifier\n                journeyIdentifier\n                provider\n                fareIdentifier\n                direction\n                singleOrReturn\n                bookingRef\n              }\n            }\n            type\n            terms {\n              error\n              ticketTypeCode\n              trainOperatingCompanyCode\n              ticketTypeName\n              ticketTypeAltName\n              ticketTypeClass\n              reservationRule\n              journeyType\n              preBookingRequirement\n              generalValidity\n              validOutRule\n              validReturnRule\n              generalDiscount\n              childDiscount\n              railcardDiscount\n              refundCancellationRule\n              changeRule\n              ticketTypeConditionsDescription\n              journeyBreakRule\n              availabilityRule\n              todAvailable\n              kioskAvailable\n              startDate\n              endDate\n            }\n            class\n            singleOrReturn\n            price\n            reservableStatus\n            currency\n            route\n            routeCode\n            tickets {\n              price\n              type\n              route\n              numChildren\n              numAdults\n            }\n            availableSeats\n            ticketQueueList {\n              id\n              name\n              type\n            }\n            accountsList {\n              id\n              reference\n              description\n              isDefault\n              type\n            }\n          }\n          bookedTicket {\n            identifiers {\n              transactionIdentifier\n              journeyIdentifier\n              provider\n              fareIdentifier\n              direction\n              singleOrReturn\n              bookingRef\n            }\n            type\n            terms {\n              error\n              ticketTypeCode\n              trainOperatingCompanyCode\n              ticketTypeName\n              ticketTypeAltName\n              ticketTypeClass\n              reservationRule\n              journeyType\n              preBookingRequirement\n              generalValidity\n              validOutRule\n              validReturnRule\n              generalDiscount\n              childDiscount\n              railcardDiscount\n              refundCancellationRule\n              changeRule\n              ticketTypeConditionsDescription\n              journeyBreakRule\n              availabilityRule\n              todAvailable\n              kioskAvailable\n              startDate\n              endDate\n            }\n            class\n            singleOrReturn\n            price\n            reservableStatus\n            currency\n            route\n            routeCode\n            tickets {\n              price\n              type\n              route\n              numChildren\n              numAdults\n            }\n            ticketQueueList {\n              id\n              name\n              type\n            }\n            accountsList {\n              id\n              reference\n              description\n              isDefault\n              type\n            }\n          }\n        }\n        unsellable\n        ticketExtras {\n          identifiers {\n            type\n            location\n            date\n            journeyId\n            isOrigin\n          }\n          type\n          location\n          date\n          description\n          amount\n          adultAmount\n          childAmount\n          currency\n        }\n        plusBus {\n          originPlusBusNLC\n          originStationNLC\n          destinationPlusBusNLC\n          destinationStationNLC\n        }\n      }\n      return {\n        identifiers {\n          transactionIdentifier\n          journeyIdentifier\n          provider\n          fareIdentifier\n          direction\n          singleOrReturn\n          bookingRef\n        }\n        travellers {\n          status\n          id\n          dob\n          railcard\n          givenName\n          surname\n          nameTitle\n          contactInfo\n          deliveryEmailAddress\n          fare\n        }\n        co2PerItem\n        from\n        fromCode\n        to\n        toCode\n        departDateTime\n        arriveDateTime\n        changes\n        segments {\n          id\n          operator\n          depart\n          departDateTime\n          arrive\n          arriveDateTime\n          reservableStatus\n          seatPreferenceGroup\n          callingPoints {\n            stationName\n            stationCode\n            arrivalDateTime\n            departureDateTime\n            scheduledPlatform\n            stationClassification\n            stoppingPattern\n          }\n        }\n        providers {\n          providerId\n          name\n          cheapestTicket {\n            identifiers {\n              transactionIdentifier\n              journeyIdentifier\n              provider\n              fareIdentifier\n              direction\n              singleOrReturn\n              bookingRef\n            }\n            type\n            terms {\n              error\n              ticketTypeCode\n              trainOperatingCompanyCode\n              ticketTypeName\n              ticketTypeAltName\n              ticketTypeClass\n              reservationRule\n              journeyType\n              preBookingRequirement\n              generalValidity\n              validOutRule\n              validReturnRule\n              generalDiscount\n              childDiscount\n              railcardDiscount\n              refundCancellationRule\n              changeRule\n              ticketTypeConditionsDescription\n              journeyBreakRule\n              availabilityRule\n              todAvailable\n              kioskAvailable\n              startDate\n              endDate\n              dynamicConditions {\n                name\n                description\n              }\n            }\n            class\n            singleOrReturn\n            price\n            reservableStatus\n            currency\n            route\n            routeCode\n            tickets {\n              price\n              type\n              route\n              segments {\n                id\n                operator\n                depart\n                departDateTime\n                arrive\n                arriveDateTime\n                reservableStatus\n                seatPreferenceGroup\n              }\n              numChildren\n              numAdults\n            }\n            availableSeats\n            ticketQueueList {\n              id\n              name\n              type\n            }\n            accountsList {\n              id\n              reference\n              description\n              isDefault\n              type\n            }\n          }\n          ticketOptions {\n            identifiers {\n              transactionIdentifier\n              journeyIdentifier\n              provider\n              fareIdentifier\n              direction\n              singleOrReturn\n              bookingRef\n              allowedWith {\n                transactionIdentifier\n                journeyIdentifier\n                provider\n                fareIdentifier\n                direction\n                singleOrReturn\n                bookingRef\n              }\n            }\n            type\n            terms {\n              error\n              ticketTypeCode\n              trainOperatingCompanyCode\n              ticketTypeName\n              ticketTypeAltName\n              ticketTypeClass\n              reservationRule\n              journeyType\n              preBookingRequirement\n              generalValidity\n              validOutRule\n              validReturnRule\n              generalDiscount\n              childDiscount\n              railcardDiscount\n              refundCancellationRule\n              changeRule\n              ticketTypeConditionsDescription\n              journeyBreakRule\n              availabilityRule\n              todAvailable\n              kioskAvailable\n              startDate\n              endDate\n            }\n            class\n            singleOrReturn\n            price\n            reservableStatus\n            currency\n            route\n            routeCode\n            tickets {\n              price\n              type\n              route\n              numChildren\n              numAdults\n            }\n            availableSeats\n            ticketQueueList {\n              id\n              name\n              type\n            }\n            accountsList {\n              id\n              reference\n              description\n              isDefault\n              type\n            }\n          }\n          bookedTicket {\n            identifiers {\n              transactionIdentifier\n              journeyIdentifier\n              provider\n              fareIdentifier\n              direction\n              singleOrReturn\n              bookingRef\n            }\n            type\n            terms {\n              error\n              ticketTypeCode\n              trainOperatingCompanyCode\n              ticketTypeName\n              ticketTypeAltName\n              ticketTypeClass\n              reservationRule\n              journeyType\n              preBookingRequirement\n              generalValidity\n              validOutRule\n              validReturnRule\n              generalDiscount\n              childDiscount\n              railcardDiscount\n              refundCancellationRule\n              changeRule\n              ticketTypeConditionsDescription\n              journeyBreakRule\n              availabilityRule\n              todAvailable\n              kioskAvailable\n              startDate\n              endDate\n            }\n            class\n            singleOrReturn\n            price\n            reservableStatus\n            currency\n            route\n            routeCode\n            tickets {\n              price\n              type\n              route\n              numChildren\n              numAdults\n            }\n            ticketQueueList {\n              id\n              name\n              type\n            }\n            accountsList {\n              id\n              reference\n              description\n              isDefault\n              type\n            }\n          }\n        }\n        unsellable\n        ticketExtras {\n          type\n          location\n          date\n          description\n          amount\n          adultAmount\n          childAmount\n          currency\n        }\n        plusBus {\n          originPlusBusNLC\n          originStationNLC\n          destinationPlusBusNLC\n          destinationStationNLC\n        }\n      }\n    }\n    errors {\n      ...Errors\n    }\n  }\n}\n    ${ErrorsFragmentDoc}`;\n\n  @Injectable({\n    providedIn: 'root'\n  })\n  export class SearchRailGQL extends Apollo.Query<SearchRailQuery, SearchRailQueryVariables> {\n    document = SearchRailDocument;\n    \n    constructor(apollo: Apollo.Apollo) {\n      super(apollo);\n    }\n  }\nexport const SaveRecentSearchDocument = gql`\n    mutation saveRecentSearch($serviceType: ServiceType!, $searchArgs: JSON!, $travelDate: DateTime!, $travellers: [ID]) {\n  saveRecentSearch(serviceType: $serviceType, searchArgs: $searchArgs, travelDate: $travelDate, travellers: $travellers) {\n    id\n  }\n}\n    `;\n\n  @Injectable({\n    providedIn: 'root'\n  })\n  export class SaveRecentSearchGQL extends Apollo.Mutation<SaveRecentSearchMutation, SaveRecentSearchMutationVariables> {\n    document = SaveRecentSearchDocument;\n    \n    constructor(apollo: Apollo.Apollo) {\n      super(apollo);\n    }\n  }\nexport const SaveUserAddressDocument = gql`\n    mutation saveUserAddress($description: String!, $numberOrName: String, $street: String, $town: String, $county: String, $postcode: String, $countryCode: String, $userPrimary: Boolean) {\n  saveUserAddress(description: $description, numberOrName: $numberOrName, street: $street, town: $town, county: $county, postcode: $postcode, countryCode: $countryCode, userPrimary: $userPrimary) {\n    id\n    description\n    numberOrName\n    street\n    town\n    county\n    postcode\n    countryCode\n    userPrimary\n    officePrimary\n  }\n}\n    `;\n\n  @Injectable({\n    providedIn: 'root'\n  })\n  export class SaveUserAddressGQL extends Apollo.Mutation<SaveUserAddressMutation, SaveUserAddressMutationVariables> {\n    document = SaveUserAddressDocument;\n    \n    constructor(apollo: Apollo.Apollo) {\n      super(apollo);\n    }\n  }\nexport const SearchAirlinesDocument = gql`\n    query searchAirlines($query: String!) {\n  searchAirlines(query: $query) {\n    iataMatch {\n      id\n      name\n      iata\n      icao\n      alias\n      callsign\n      active\n      continent\n      country\n      countryCode\n      bannerImage\n      logoImage\n    }\n    generalMatches {\n      id\n      name\n      iata\n      icao\n      alias\n      callsign\n      active\n      continent\n      country\n      countryCode\n      bannerImage\n      logoImage\n    }\n  }\n}\n    `;\n\n  @Injectable({\n    providedIn: 'root'\n  })\n  export class SearchAirlinesGQL extends Apollo.Query<SearchAirlinesQuery, SearchAirlinesQueryVariables> {\n    document = SearchAirlinesDocument;\n    \n    constructor(apollo: Apollo.Apollo) {\n      super(apollo);\n    }\n  }\nexport const SearchCitiesDocument = gql`\n    query searchCities($query: String!, $countryCode: String) {\n  searchCities(query: $query, countryCode: $countryCode) {\n    id\n    name\n    country\n    countryCode\n    coordinates {\n      latitude\n      longitude\n      altitude\n    }\n    continentName\n  }\n}\n    `;\n\n  @Injectable({\n    providedIn: 'root'\n  })\n  export class SearchCitiesGQL extends Apollo.Query<SearchCitiesQuery, SearchCitiesQueryVariables> {\n    document = SearchCitiesDocument;\n    \n    constructor(apollo: Apollo.Apollo) {\n      super(apollo);\n    }\n  }\nexport const SearchConfermaCitiesDocument = gql`\n    query searchConfermaCities($cityName: String!, $countryCode: String!) {\n  searchConfermaCities(cityName: $cityName, countryCode: $countryCode) {\n    foundExact\n    suggestions {\n      name\n      countryCode\n      latitude\n      longitude\n    }\n  }\n}\n    `;\n\n  @Injectable({\n    providedIn: 'root'\n  })\n  export class SearchConfermaCitiesGQL extends Apollo.Query<SearchConfermaCitiesQuery, SearchConfermaCitiesQueryVariables> {\n    document = SearchConfermaCitiesDocument;\n    \n    constructor(apollo: Apollo.Apollo) {\n      super(apollo);\n    }\n  }\nexport const SearchEurostarDocument = gql`\n    query searchEurostar($passengers: [FlightPassengerObject!]!, $originAirport: String, $destinationAirport: String, $multiDestination: [DestinationEntry], $outboundDate: Date, $outboundDepartureTimeWindow: String, $outboundArrivalTimeWindow: String, $outboundCabinClass: [FlightCabinClass], $returnTrip: Boolean!, $returnDate: Date, $returnDepartureTimeWindow: String, $returnArrivalTimeWindow: String, $returnCabinClass: [FlightCabinClass], $fareType: FareType!, $requireFreeBag: Boolean, $maxConnections: Int, $preferredCarriers: [String], $includeNearbyAirports: Boolean, $asSingles: Boolean) {\n  searchEurostar(passengers: $passengers, originAirport: $originAirport, destinationAirport: $destinationAirport, multiDestination: $multiDestination, outboundDate: $outboundDate, outboundDepartureTimeWindow: $outboundDepartureTimeWindow, outboundArrivalTimeWindow: $outboundArrivalTimeWindow, outboundCabinClass: $outboundCabinClass, returnTrip: $returnTrip, returnDate: $returnDate, returnDepartureTimeWindow: $returnDepartureTimeWindow, returnArrivalTimeWindow: $returnArrivalTimeWindow, returnCabinClass: $returnCabinClass, fareType: $fareType, requireFreeBag: $requireFreeBag, maxConnections: $maxConnections, preferredCarriers: $preferredCarriers, includeNearbyAirports: $includeNearbyAirports, asSingles: $asSingles) {\n    results {\n      journeys {\n        uid\n        passengerCount\n        outboundFlights {\n          fareInfo {\n            title\n            type\n            code\n            supplierCode\n          }\n          originAirport\n          originTerminal\n          originAirportName\n          originAirportDetail {\n            iata\n            icao\n            latitude\n            longitude\n            altitude\n            state\n            city\n            road\n            popularity\n            area\n            location\n            offset\n            airportName\n            countryName\n            countryCode\n            postcode\n          }\n          destinationAirport\n          destinationTerminal\n          destinationAirportName\n          destinationAirportDetail {\n            iata\n            icao\n            latitude\n            longitude\n            altitude\n            state\n            city\n            road\n            popularity\n            area\n            location\n            offset\n            airportName\n            countryName\n            countryCode\n            postcode\n          }\n          dateTimeDeparting\n          dateTimeDepartingUTC\n          dateTimeArriving\n          dateTimeArrivingUTC\n          marketingCarrier\n          marketingCarrierName\n          marketingCarrierDetail {\n            name\n            alias\n            callsign\n            iata\n            icao\n            logo\n            banner\n            popularity\n          }\n          marketingFlightNumber\n          operatingCarrier\n          operatingCarrierName\n          operatingCarrierDetail {\n            name\n            alias\n            callsign\n            iata\n            icao\n            logo\n            banner\n            popularity\n          }\n          operatingFlightNumber\n          equipmentCode\n          equipmentName\n          totalDuration\n          cabinClass\n          marketingNames\n          fareConditions {\n            cancellation {\n              name\n              type\n              currency\n              amount\n              remark\n              changeFeeInd\n              cancelFeeInd\n              refundableInd\n            }\n            change {\n              name\n              type\n              currency\n              amount\n              remark\n              changeFeeInd\n              cancelFeeInd\n              refundableInd\n            }\n            noShow {\n              name\n              type\n              currency\n              amount\n              remark\n              changeFeeInd\n              cancelFeeInd\n              refundableInd\n            }\n            upgrade {\n              name\n              type\n              currency\n              amount\n              remark\n              changeFeeInd\n              cancelFeeInd\n              refundableInd\n            }\n            other {\n              name\n              type\n              currency\n              amount\n              remark\n              changeFeeInd\n              cancelFeeInd\n              refundableInd\n            }\n          }\n          vendorCode\n          stops\n          bookingCode\n          marriageGroup\n          fareBasisCode\n          additional\n        }\n        inboundFlights {\n          fareInfo {\n            title\n            type\n            code\n            supplierCode\n          }\n          originAirport\n          originTerminal\n          originAirportName\n          originAirportDetail {\n            iata\n            icao\n            latitude\n            longitude\n            altitude\n            state\n            city\n            road\n            popularity\n            area\n            location\n            offset\n            airportName\n            countryName\n            countryCode\n            postcode\n          }\n          destinationAirport\n          destinationTerminal\n          destinationAirportName\n          destinationAirportDetail {\n            iata\n            icao\n            latitude\n            longitude\n            altitude\n            state\n            city\n            road\n            popularity\n            area\n            location\n            offset\n            airportName\n            countryName\n            countryCode\n            postcode\n          }\n          dateTimeDeparting\n          dateTimeDepartingUTC\n          dateTimeArriving\n          dateTimeArrivingUTC\n          marketingCarrier\n          marketingCarrierName\n          marketingCarrierDetail {\n            name\n            alias\n            callsign\n            iata\n            icao\n            logo\n            banner\n            popularity\n          }\n          marketingFlightNumber\n          operatingCarrier\n          operatingCarrierName\n          operatingCarrierDetail {\n            name\n            alias\n            callsign\n            iata\n            icao\n            logo\n            banner\n            popularity\n          }\n          operatingFlightNumber\n          equipmentCode\n          equipmentName\n          totalDuration\n          cabinClass\n          marketingNames\n          fareConditions {\n            cancellation {\n              name\n              type\n              currency\n              amount\n              remark\n              changeFeeInd\n              cancelFeeInd\n              refundableInd\n            }\n            change {\n              name\n              type\n              currency\n              amount\n              remark\n              changeFeeInd\n              cancelFeeInd\n              refundableInd\n            }\n            noShow {\n              name\n              type\n              currency\n              amount\n              remark\n              changeFeeInd\n              cancelFeeInd\n              refundableInd\n            }\n            upgrade {\n              name\n              type\n              currency\n              amount\n              remark\n              changeFeeInd\n              cancelFeeInd\n              refundableInd\n            }\n            other {\n              name\n              type\n              currency\n              amount\n              remark\n              changeFeeInd\n              cancelFeeInd\n              refundableInd\n            }\n          }\n          vendorCode\n          stops\n          bookingCode\n          marriageGroup\n          fareBasisCode\n          additional\n        }\n        outboundTotalDuration\n        outboundCarbonEmissions {\n          amount\n          unit\n        }\n        inboundTotalDuration\n        inboundCarbonEmissions {\n          amount\n          unit\n        }\n        taxes {\n          description\n          amount\n          currency\n        }\n        discounts {\n          description\n          amount\n          currency\n        }\n        total {\n          price\n          tax\n          discount\n          currency\n        }\n        fareConditions {\n          cancellation {\n            name\n            type\n            currency\n            amount\n            remark\n            changeFeeInd\n            cancelFeeInd\n            refundableInd\n          }\n          change {\n            name\n            type\n            currency\n            amount\n            remark\n            changeFeeInd\n            cancelFeeInd\n            refundableInd\n          }\n          noShow {\n            name\n            type\n            currency\n            amount\n            remark\n            changeFeeInd\n            cancelFeeInd\n            refundableInd\n          }\n          upgrade {\n            name\n            type\n            currency\n            amount\n            remark\n            changeFeeInd\n            cancelFeeInd\n            refundableInd\n          }\n          other {\n            name\n            type\n            currency\n            amount\n            remark\n            changeFeeInd\n            cancelFeeInd\n            refundableInd\n          }\n        }\n        baggageAllowance {\n          type\n          qty\n          maxKG\n          maxLBS\n        }\n        additional\n        source\n        sourceId\n        version\n        tmcPreferred\n        companyPreferred\n        officePreferred\n        tmcPreferredMessage\n        companyPreferredMessage\n        officePreferredMessage\n        unavailable\n        unavailableMessage\n        co2PerItem\n        co2PerPassenger\n      }\n      multi {\n        order\n        origin\n        destination\n        results {\n          uid\n          passengerCount\n          outboundFlights {\n            fareInfo {\n              title\n              type\n              code\n              supplierCode\n            }\n            originAirport\n            originTerminal\n            originAirportName\n            originAirportDetail {\n              iata\n              icao\n              latitude\n              longitude\n              altitude\n              state\n              city\n              road\n              popularity\n              area\n              location\n              offset\n              airportName\n              countryName\n              countryCode\n              postcode\n            }\n            destinationAirport\n            destinationTerminal\n            destinationAirportName\n            destinationAirportDetail {\n              iata\n              icao\n              latitude\n              longitude\n              altitude\n              state\n              city\n              road\n              popularity\n              area\n              location\n              offset\n              airportName\n              countryName\n              countryCode\n              postcode\n            }\n            dateTimeDeparting\n            dateTimeDepartingUTC\n            dateTimeArriving\n            dateTimeArrivingUTC\n            marketingCarrier\n            marketingCarrierName\n            marketingCarrierDetail {\n              name\n              alias\n              callsign\n              iata\n              icao\n              logo\n              banner\n              popularity\n            }\n            marketingFlightNumber\n            operatingCarrier\n            operatingCarrierName\n            operatingCarrierDetail {\n              name\n              alias\n              callsign\n              iata\n              icao\n              logo\n              banner\n              popularity\n            }\n            operatingFlightNumber\n            equipmentCode\n            equipmentName\n            totalDuration\n            cabinClass\n            marketingNames\n            fareConditions {\n              cancellation {\n                name\n                type\n                currency\n                amount\n                remark\n                changeFeeInd\n                cancelFeeInd\n                refundableInd\n              }\n              change {\n                name\n                type\n                currency\n                amount\n                remark\n                changeFeeInd\n                cancelFeeInd\n                refundableInd\n              }\n              noShow {\n                name\n                type\n                currency\n                amount\n                remark\n                changeFeeInd\n                cancelFeeInd\n                refundableInd\n              }\n              upgrade {\n                name\n                type\n                currency\n                amount\n                remark\n                changeFeeInd\n                cancelFeeInd\n                refundableInd\n              }\n              other {\n                name\n                type\n                currency\n                amount\n                remark\n                changeFeeInd\n                cancelFeeInd\n                refundableInd\n              }\n            }\n            vendorCode\n            stops\n            bookingCode\n            marriageGroup\n            fareBasisCode\n            additional\n          }\n          inboundFlights {\n            fareInfo {\n              title\n              type\n              code\n              supplierCode\n            }\n            originAirport\n            originTerminal\n            originAirportName\n            originAirportDetail {\n              iata\n              icao\n              latitude\n              longitude\n              altitude\n              state\n              city\n              road\n              popularity\n              area\n              location\n              offset\n              airportName\n              countryName\n              countryCode\n              postcode\n            }\n            destinationAirport\n            destinationTerminal\n            destinationAirportName\n            destinationAirportDetail {\n              iata\n              icao\n              latitude\n              longitude\n              altitude\n              state\n              city\n              road\n              popularity\n              area\n              location\n              offset\n              airportName\n              countryName\n              countryCode\n              postcode\n            }\n            dateTimeDeparting\n            dateTimeDepartingUTC\n            dateTimeArriving\n            dateTimeArrivingUTC\n            marketingCarrier\n            marketingCarrierName\n            marketingCarrierDetail {\n              name\n              alias\n              callsign\n              iata\n              icao\n              logo\n              banner\n              popularity\n            }\n            marketingFlightNumber\n            operatingCarrier\n            operatingCarrierName\n            operatingCarrierDetail {\n              name\n              alias\n              callsign\n              iata\n              icao\n              logo\n              banner\n              popularity\n            }\n            operatingFlightNumber\n            equipmentCode\n            equipmentName\n            totalDuration\n            cabinClass\n            marketingNames\n            fareConditions {\n              cancellation {\n                name\n                type\n                currency\n                amount\n                remark\n                changeFeeInd\n                cancelFeeInd\n                refundableInd\n              }\n              change {\n                name\n                type\n                currency\n                amount\n                remark\n                changeFeeInd\n                cancelFeeInd\n                refundableInd\n              }\n              noShow {\n                name\n                type\n                currency\n                amount\n                remark\n                changeFeeInd\n                cancelFeeInd\n                refundableInd\n              }\n              upgrade {\n                name\n                type\n                currency\n                amount\n                remark\n                changeFeeInd\n                cancelFeeInd\n                refundableInd\n              }\n              other {\n                name\n                type\n                currency\n                amount\n                remark\n                changeFeeInd\n                cancelFeeInd\n                refundableInd\n              }\n            }\n            vendorCode\n            stops\n            bookingCode\n            marriageGroup\n            fareBasisCode\n            additional\n          }\n          outboundTotalDuration\n          outboundCarbonEmissions {\n            amount\n            unit\n          }\n          inboundTotalDuration\n          inboundCarbonEmissions {\n            amount\n            unit\n          }\n          taxes {\n            description\n            amount\n            currency\n          }\n          discounts {\n            description\n            amount\n            currency\n          }\n          total {\n            price\n            tax\n            discount\n            currency\n          }\n          fareConditions {\n            cancellation {\n              name\n              type\n              currency\n              amount\n              remark\n              changeFeeInd\n              cancelFeeInd\n              refundableInd\n            }\n            change {\n              name\n              type\n              currency\n              amount\n              remark\n              changeFeeInd\n              cancelFeeInd\n              refundableInd\n            }\n            noShow {\n              name\n              type\n              currency\n              amount\n              remark\n              changeFeeInd\n              cancelFeeInd\n              refundableInd\n            }\n            upgrade {\n              name\n              type\n              currency\n              amount\n              remark\n              changeFeeInd\n              cancelFeeInd\n              refundableInd\n            }\n            other {\n              name\n              type\n              currency\n              amount\n              remark\n              changeFeeInd\n              cancelFeeInd\n              refundableInd\n            }\n          }\n          baggageAllowance {\n            type\n            qty\n            maxKG\n            maxLBS\n          }\n          additional\n          source\n          sourceId\n          version\n          tmcPreferred\n          companyPreferred\n          officePreferred\n          tmcPreferredMessage\n          companyPreferredMessage\n          officePreferredMessage\n          unavailable\n          unavailableMessage\n          co2PerItem\n          co2PerPassenger\n        }\n        minPrice\n        maxPrice\n      }\n      grouped {\n        referenceID\n        flightID\n        boundIndicator\n        minPrice\n        maxPrice\n        flights {\n          LiteEconomy\n          EconomyRestricted\n          EconomyNoBags\n          Economy\n          PremiumEconomy\n          Business\n          PremiumBusiness\n          First\n          PremiumFirst\n        }\n      }\n    }\n    errors {\n      ...Errors\n    }\n  }\n}\n    ${ErrorsFragmentDoc}`;\n\n  @Injectable({\n    providedIn: 'root'\n  })\n  export class SearchEurostarGQL extends Apollo.Query<SearchEurostarQuery, SearchEurostarQueryVariables> {\n    document = SearchEurostarDocument;\n    \n    constructor(apollo: Apollo.Apollo) {\n      super(apollo);\n    }\n  }\nexport const SearchHotelChainsDocument = gql`\n    query searchHotelChains($query: String!) {\n  searchHotelChains(query: $query)\n}\n    `;\n\n  @Injectable({\n    providedIn: 'root'\n  })\n  export class SearchHotelChainsGQL extends Apollo.Query<SearchHotelChainsQuery, SearchHotelChainsQueryVariables> {\n    document = SearchHotelChainsDocument;\n    \n    constructor(apollo: Apollo.Apollo) {\n      super(apollo);\n    }\n  }\nexport const SearchIrlDocument = gql`\n    query searchIRL($supplier: IRLSupplier!, $countryCode: String!, $journeyType: IRLJourneyType!, $class: IRLClass, $outboundDepartureDateTime: DateTime!, $departureLocationId: ID!, $arrivalLocationId: ID!, $adults: Int!, $children: Int, $returnDepartureDateTime: DateTime) {\n  searchIRL(supplier: $supplier, countryCode: $countryCode, journeyType: $journeyType, class: $class, outboundDepartureDateTime: $outboundDepartureDateTime, departureLocationId: $departureLocationId, arrivalLocationId: $arrivalLocationId, adults: $adults, children: $children, returnDepartureDateTime: $returnDepartureDateTime) {\n    results {\n      source\n      sourceId\n      outbound {\n        identifiers {\n          transactionIdentifier\n          signature\n          journeyIdentifier\n          provider\n          fareIdentifier\n          direction\n          singleOrReturn\n          bookingRef\n        }\n        travellers {\n          status\n          id\n          dob\n          railcard\n          givenName\n          surname\n          nameTitle\n          contactInfo\n          deliveryEmailAddress\n          fare\n        }\n        from\n        fromCode\n        to\n        toCode\n        departDateTime\n        arriveDateTime\n        changes\n        segments {\n          id\n          operator\n          depart\n          departDateTime\n          arrive\n          arriveDateTime\n          reservableStatus\n          seatPreferenceTypes {\n            name\n            allowedValues\n          }\n          seatPreferenceGroup\n          seats {\n            location\n            coach\n            number\n            direction\n            position\n            deck\n            seatType\n            seatSelection\n            facilities\n            note\n          }\n        }\n        providers {\n          providerId\n          name\n          cheapestTicket {\n            identifiers {\n              transactionIdentifier\n              signature\n              journeyIdentifier\n              provider\n              fareIdentifier\n              direction\n              singleOrReturn\n              bookingRef\n            }\n            type\n            class\n            singleOrReturn\n            price\n            reservableStatus\n            currency\n            route\n            routeCode\n            tickets {\n              price\n              type\n              route\n              segments {\n                id\n                operator\n                depart\n                departDateTime\n                arrive\n                arriveDateTime\n                reservableStatus\n                seatPreferenceTypes {\n                  name\n                  allowedValues\n                }\n                seatPreferenceGroup\n                seats {\n                  location\n                  coach\n                  number\n                  direction\n                  position\n                  deck\n                  seatType\n                  seatSelection\n                  facilities\n                  note\n                }\n              }\n              numChildren\n              numAdults\n            }\n          }\n          ticketOptions {\n            identifiers {\n              transactionIdentifier\n              signature\n              journeyIdentifier\n              provider\n              fareIdentifier\n              direction\n              singleOrReturn\n              bookingRef\n            }\n            type\n            class\n            singleOrReturn\n            price\n            reservableStatus\n            currency\n            route\n            routeCode\n            tickets {\n              price\n              type\n              route\n              segments {\n                id\n                operator\n                depart\n                departDateTime\n                arrive\n                arriveDateTime\n                reservableStatus\n                seatPreferenceTypes {\n                  name\n                  allowedValues\n                }\n                seatPreferenceGroup\n                seats {\n                  location\n                  coach\n                  number\n                  direction\n                  position\n                  deck\n                  seatType\n                  seatSelection\n                  facilities\n                  note\n                }\n              }\n              numChildren\n              numAdults\n            }\n          }\n          bookedTicket {\n            identifiers {\n              transactionIdentifier\n              signature\n              journeyIdentifier\n              provider\n              fareIdentifier\n              direction\n              singleOrReturn\n              bookingRef\n            }\n            type\n            class\n            singleOrReturn\n            price\n            reservableStatus\n            currency\n            route\n            routeCode\n            tickets {\n              price\n              type\n              route\n              segments {\n                id\n                operator\n                depart\n                departDateTime\n                arrive\n                arriveDateTime\n                reservableStatus\n                seatPreferenceTypes {\n                  name\n                  allowedValues\n                }\n                seatPreferenceGroup\n                seats {\n                  location\n                  coach\n                  number\n                  direction\n                  position\n                  deck\n                  seatType\n                  seatSelection\n                  facilities\n                  note\n                }\n              }\n              numChildren\n              numAdults\n            }\n          }\n        }\n        unsellable\n        ticketExtras {\n          identifiers {\n            type\n            location\n            date\n            journeyId\n            isOrigin\n          }\n          type\n          location\n          date\n          description\n          amount\n          adultAmount\n          childAmount\n          currency\n        }\n        plusBus {\n          originPlusBusNLC\n          originStationNLC\n          destinationPlusBusNLC\n          destinationStationNLC\n        }\n      }\n      return {\n        identifiers {\n          transactionIdentifier\n          signature\n          journeyIdentifier\n          provider\n          fareIdentifier\n          direction\n          singleOrReturn\n          bookingRef\n        }\n        travellers {\n          status\n          id\n          dob\n          railcard\n          givenName\n          surname\n          nameTitle\n          contactInfo\n          deliveryEmailAddress\n          fare\n        }\n        from\n        fromCode\n        to\n        toCode\n        departDateTime\n        arriveDateTime\n        changes\n        segments {\n          id\n          operator\n          depart\n          departDateTime\n          arrive\n          arriveDateTime\n          reservableStatus\n          seatPreferenceTypes {\n            name\n            allowedValues\n          }\n          seatPreferenceGroup\n          seats {\n            location\n            coach\n            number\n            direction\n            position\n            deck\n            seatType\n            seatSelection\n            facilities\n            note\n          }\n        }\n        providers {\n          providerId\n          name\n          cheapestTicket {\n            identifiers {\n              transactionIdentifier\n              signature\n              journeyIdentifier\n              provider\n              fareIdentifier\n              direction\n              singleOrReturn\n              bookingRef\n            }\n            type\n            class\n            singleOrReturn\n            price\n            reservableStatus\n            currency\n            route\n            routeCode\n            tickets {\n              price\n              type\n              route\n              segments {\n                id\n                operator\n                depart\n                departDateTime\n                arrive\n                arriveDateTime\n                reservableStatus\n                seatPreferenceTypes {\n                  name\n                  allowedValues\n                }\n                seatPreferenceGroup\n                seats {\n                  location\n                  coach\n                  number\n                  direction\n                  position\n                  deck\n                  seatType\n                  seatSelection\n                  facilities\n                  note\n                }\n              }\n              numChildren\n              numAdults\n            }\n          }\n          ticketOptions {\n            identifiers {\n              transactionIdentifier\n              signature\n              journeyIdentifier\n              provider\n              fareIdentifier\n              direction\n              singleOrReturn\n              bookingRef\n            }\n            type\n            class\n            singleOrReturn\n            price\n            reservableStatus\n            currency\n            route\n            routeCode\n            tickets {\n              price\n              type\n              route\n              segments {\n                id\n                operator\n                depart\n                departDateTime\n                arrive\n                arriveDateTime\n                reservableStatus\n                seatPreferenceTypes {\n                  name\n                  allowedValues\n                }\n                seatPreferenceGroup\n                seats {\n                  location\n                  coach\n                  number\n                  direction\n                  position\n                  deck\n                  seatType\n                  seatSelection\n                  facilities\n                  note\n                }\n              }\n              numChildren\n              numAdults\n            }\n          }\n          bookedTicket {\n            identifiers {\n              transactionIdentifier\n              signature\n              journeyIdentifier\n              provider\n              fareIdentifier\n              direction\n              singleOrReturn\n              bookingRef\n            }\n            type\n            class\n            singleOrReturn\n            price\n            reservableStatus\n            currency\n            route\n            routeCode\n            tickets {\n              price\n              type\n              route\n              segments {\n                id\n                operator\n                depart\n                departDateTime\n                arrive\n                arriveDateTime\n                reservableStatus\n                seatPreferenceTypes {\n                  name\n                  allowedValues\n                }\n                seatPreferenceGroup\n                seats {\n                  location\n                  coach\n                  number\n                  direction\n                  position\n                  deck\n                  seatType\n                  seatSelection\n                  facilities\n                  note\n                }\n              }\n              numChildren\n              numAdults\n            }\n          }\n        }\n        unsellable\n        ticketExtras {\n          identifiers {\n            type\n            location\n            date\n            journeyId\n            isOrigin\n          }\n          type\n          location\n          date\n          description\n          amount\n          adultAmount\n          childAmount\n          currency\n        }\n        plusBus {\n          originPlusBusNLC\n          originStationNLC\n          destinationPlusBusNLC\n          destinationStationNLC\n        }\n      }\n    }\n    errors {\n      ...Errors\n    }\n  }\n}\n    ${ErrorsFragmentDoc}`;\n\n  @Injectable({\n    providedIn: 'root'\n  })\n  export class SearchIrlGQL extends Apollo.Query<SearchIrlQuery, SearchIrlQueryVariables> {\n    document = SearchIrlDocument;\n    \n    constructor(apollo: Apollo.Apollo) {\n      super(apollo);\n    }\n  }\nexport const SearchPostcodesDocument = gql`\n    query searchPostcodes($postcode: String!) {\n  getPostcodeDetails(postcode: $postcode) {\n    postcode\n    latitude\n    longitude\n  }\n}\n    `;\n\n  @Injectable({\n    providedIn: 'root'\n  })\n  export class SearchPostcodesGQL extends Apollo.Query<SearchPostcodesQuery, SearchPostcodesQueryVariables> {\n    document = SearchPostcodesDocument;\n    \n    constructor(apollo: Apollo.Apollo) {\n      super(apollo);\n    }\n  }\nexport const SearchRailStationsDocument = gql`\n    query searchRailStations($query: String!, $countryCode: String) {\n  searchRailStations(query: $query, countryCode: $countryCode) {\n    id\n    name\n    stationCode\n    nlcCode\n    trainlineCode\n    trainlineUniqueCode\n    locationDetails {\n      continent\n      country\n      countryCode\n      state\n      city\n      coordinates {\n        latitude\n        longitude\n        altitude\n      }\n      postcode\n      road\n      gridReference\n      northing\n      easting\n    }\n  }\n}\n    `;\n\n  @Injectable({\n    providedIn: 'root'\n  })\n  export class SearchRailStationsGQL extends Apollo.Query<SearchRailStationsQuery, SearchRailStationsQueryVariables> {\n    document = SearchRailStationsDocument;\n    \n    constructor(apollo: Apollo.Apollo) {\n      super(apollo);\n    }\n  }\nexport const SearchUserAddressDocument = gql`\n    query searchUserAddress {\n  getUserAddresses {\n    id\n    description\n    numberOrName\n    street\n    town\n    county\n    postcode\n    countryCode\n    userPrimary\n    officePrimary\n  }\n}\n    `;\n\n  @Injectable({\n    providedIn: 'root'\n  })\n  export class SearchUserAddressGQL extends Apollo.Query<SearchUserAddressQuery, SearchUserAddressQueryVariables> {\n    document = SearchUserAddressDocument;\n    \n    constructor(apollo: Apollo.Apollo) {\n      super(apollo);\n    }\n  }\nexport const SetBasketItemMiGroupDocument = gql`\n    mutation setBasketItemMIGroup($basketItem: ID!, $group: String, $withSupplemental: Boolean = false) {\n  setBasketItemMIGroup(basketItem: $basketItem, group: $group) {\n    ...BasketFields\n  }\n}\n    ${BasketFieldsFragmentDoc}`;\n\n  @Injectable({\n    providedIn: 'root'\n  })\n  export class SetBasketItemMiGroupGQL extends Apollo.Mutation<SetBasketItemMiGroupMutation, SetBasketItemMiGroupMutationVariables> {\n    document = SetBasketItemMiGroupDocument;\n    \n    constructor(apollo: Apollo.Apollo) {\n      super(apollo);\n    }\n  }\nexport const SetBasketItemLeadPassengerDocument = gql`\n    mutation setBasketItemLeadPassenger($id: ID!, $user: ID!, $withSupplemental: Boolean!) {\n  setBasketItemLeadPassenger(id: $id, user: $user) {\n    ...BasketFields\n  }\n}\n    ${BasketFieldsFragmentDoc}`;\n\n  @Injectable({\n    providedIn: 'root'\n  })\n  export class SetBasketItemLeadPassengerGQL extends Apollo.Mutation<SetBasketItemLeadPassengerMutation, SetBasketItemLeadPassengerMutationVariables> {\n    document = SetBasketItemLeadPassengerDocument;\n    \n    constructor(apollo: Apollo.Apollo) {\n      super(apollo);\n    }\n  }\nexport const SetBasketItemMiValueDocument = gql`\n    mutation setBasketItemMIValue($mi: ID!, $miValue: ID, $miFreeValue: String, $user: ID, $withSupplemental: Boolean = false) {\n  setBasketItemMIValue(mi: $mi, miValue: $miValue, miFreeValue: $miFreeValue, user: $user) {\n    ...BasketFields\n  }\n}\n    ${BasketFieldsFragmentDoc}`;\n\n  @Injectable({\n    providedIn: 'root'\n  })\n  export class SetBasketItemMiValueGQL extends Apollo.Mutation<SetBasketItemMiValueMutation, SetBasketItemMiValueMutationVariables> {\n    document = SetBasketItemMiValueDocument;\n    \n    constructor(apollo: Apollo.Apollo) {\n      super(apollo);\n    }\n  }\nexport const SetBasketItemPaymentMethodDocument = gql`\n    mutation setBasketItemPaymentMethod($basketItem: ID!, $paymentMethod: ID!, $withSupplemental: Boolean = false) {\n  setBasketItemPaymentMethod(basketItem: $basketItem, paymentMethod: $paymentMethod) {\n    ...BasketFields\n  }\n}\n    ${BasketFieldsFragmentDoc}`;\n\n  @Injectable({\n    providedIn: 'root'\n  })\n  export class SetBasketItemPaymentMethodGQL extends Apollo.Mutation<SetBasketItemPaymentMethodMutation, SetBasketItemPaymentMethodMutationVariables> {\n    document = SetBasketItemPaymentMethodDocument;\n    \n    constructor(apollo: Apollo.Apollo) {\n      super(apollo);\n    }\n  }\nexport const UpdateBasketNotesDocument = gql`\n    mutation updateBasketNotes($id: ID, $reference: String, $notes: String!, $withSupplemental: Boolean = false) {\n  updateBasketNotes(id: $id, reference: $reference, notes: $notes) {\n    ...BasketFields\n  }\n}\n    ${BasketFieldsFragmentDoc}`;\n\n  @Injectable({\n    providedIn: 'root'\n  })\n  export class UpdateBasketNotesGQL extends Apollo.Mutation<UpdateBasketNotesMutation, UpdateBasketNotesMutationVariables> {\n    document = UpdateBasketNotesDocument;\n    \n    constructor(apollo: Apollo.Apollo) {\n      super(apollo);\n    }\n  }\nexport const UpdateBasketTitleDocument = gql`\n    mutation updateBasketTitle($id: ID, $reference: String, $newTitle: String!, $withSupplemental: Boolean = false) {\n  updateBasketTitle(id: $id, reference: $reference, newTitle: $newTitle) {\n    ...BasketFields\n  }\n}\n    ${BasketFieldsFragmentDoc}`;\n\n  @Injectable({\n    providedIn: 'root'\n  })\n  export class UpdateBasketTitleGQL extends Apollo.Mutation<UpdateBasketTitleMutation, UpdateBasketTitleMutationVariables> {\n    document = UpdateBasketTitleDocument;\n    \n    constructor(apollo: Apollo.Apollo) {\n      super(apollo);\n    }\n  }\nexport const GetUserServicesDocument = gql`\n    query getUserServices {\n  getUserServices {\n    id\n    cancellable\n    amendable\n    type\n    name\n    description\n    detailSchema\n    searchQuerySchema\n  }\n}\n    `;\n\n  @Injectable({\n    providedIn: 'root'\n  })\n  export class GetUserServicesGQL extends Apollo.Query<GetUserServicesQuery, GetUserServicesQueryVariables> {\n    document = GetUserServicesDocument;\n    \n    constructor(apollo: Apollo.Apollo) {\n      super(apollo);\n    }\n  }\nexport const GetUserUiConfigsDocument = gql`\n    query getUserUIConfigs {\n  getUserUIConfigs {\n    all {\n      id\n      config\n      key\n    }\n  }\n}\n    `;\n\n  @Injectable({\n    providedIn: 'root'\n  })\n  export class GetUserUiConfigsGQL extends Apollo.Query<GetUserUiConfigsQuery, GetUserUiConfigsQueryVariables> {\n    document = GetUserUiConfigsDocument;\n    \n    constructor(apollo: Apollo.Apollo) {\n      super(apollo);\n    }\n  }\nexport const GetUserMessagesDocument = gql`\n    query getUserMessages {\n  getUserMessages {\n    id\n    name\n    description\n    config\n    target\n    key\n  }\n}\n    `;\n\n  @Injectable({\n    providedIn: 'root'\n  })\n  export class GetUserMessagesGQL extends Apollo.Query<GetUserMessagesQuery, GetUserMessagesQueryVariables> {\n    document = GetUserMessagesDocument;\n    \n    constructor(apollo: Apollo.Apollo) {\n      super(apollo);\n    }\n  }\nexport const GetUserPhoneNumbersDocument = gql`\n    query getUserPhoneNumbers {\n  getUserPhoneNumbers {\n    id\n    description\n    countryCode\n    areaCode\n    number\n    extension\n    type\n    officePrimary\n    userPrimary\n  }\n}\n    `;\n\n  @Injectable({\n    providedIn: 'root'\n  })\n  export class GetUserPhoneNumbersGQL extends Apollo.Query<GetUserPhoneNumbersQuery, GetUserPhoneNumbersQueryVariables> {\n    document = GetUserPhoneNumbersDocument;\n    \n    constructor(apollo: Apollo.Apollo) {\n      super(apollo);\n    }\n  }\nexport const SetUserLanguageDocument = gql`\n    mutation setUserLanguage($language: ID) {\n  setUserLanguage(language: $language) {\n    id\n    selectedLanguage {\n      id\n      name\n    }\n  }\n}\n    `;\n\n  @Injectable({\n    providedIn: 'root'\n  })\n  export class SetUserLanguageGQL extends Apollo.Mutation<SetUserLanguageMutation, SetUserLanguageMutationVariables> {\n    document = SetUserLanguageDocument;\n    \n    constructor(apollo: Apollo.Apollo) {\n      super(apollo);\n    }\n  }\nexport const GetUserDocument = gql`\n    query getUser($id: ID) {\n  getUser(id: $id) {\n    ...UserFields\n  }\n}\n    ${UserFieldsFragmentDoc}`;\n\n  @Injectable({\n    providedIn: 'root'\n  })\n  export class GetUserGQL extends Apollo.Query<GetUserQuery, GetUserQueryVariables> {\n    document = GetUserDocument;\n    \n    constructor(apollo: Apollo.Apollo) {\n      super(apollo);\n    }\n  }\nexport const SearchUserCanBookForDocument = gql`\n    query searchUserCanBookFor($email: String, $userName: String, $employeeId: String) {\n  searchUserCanBookFor(email: $email, userName: $userName, employeeId: $employeeId) {\n    id\n    forename\n    surname\n    email\n  }\n}\n    `;\n\n  @Injectable({\n    providedIn: 'root'\n  })\n  export class SearchUserCanBookForGQL extends Apollo.Query<SearchUserCanBookForQuery, SearchUserCanBookForQueryVariables> {\n    document = SearchUserCanBookForDocument;\n    \n    constructor(apollo: Apollo.Apollo) {\n      super(apollo);\n    }\n  }\nexport const ValidateUserMiFreeValueDocument = gql`\n    query validateUserMIFreeValue($mi: ID!, $freeValue: String!) {\n  validateUserMIFreeValue(mi: $mi, freeValue: $freeValue)\n}\n    `;\n\n  @Injectable({\n    providedIn: 'root'\n  })\n  export class ValidateUserMiFreeValueGQL extends Apollo.Query<ValidateUserMiFreeValueQuery, ValidateUserMiFreeValueQueryVariables> {\n    document = ValidateUserMiFreeValueDocument;\n    \n    constructor(apollo: Apollo.Apollo) {\n      super(apollo);\n    }\n  }"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"graphql.angular.types.js","sourceRoot":"","sources":["../../../../../../../projects/obtservices/angular/src/lib/vendor/types/graphql.angular.types.ts"],"names":[],"mappings":"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CAAA;IACX,2BAAW,CAAA;IACX,2BAAW,CAAA;IACX,2BAAW,CAAA;IACX,2BAAW,CAAA;IACX,2BAAW,CAAA;IACX,2BAAW,CAAA;IACX,2BAAW,CAAA;IACX,2BAAW,CAAA;IACX,2BAAW,CAAA;IACX,2BAAW,CAAA;IACX,2BAAW,CAAA;IACX,2BAAW,CAAA;IACX,2BAAW,CAAA;IACX,2BAAW,CAAA;IACX,2BAAW,CAAA;IACX,2BAAW,CAAA;IACX,2BAAW,CAAA;IACX,2BAAW,CAAA;IACX,2BAAW,CAAA;IACX,2BAAW,CAAA;IACX,2BAAW,CAAA;IACX,2BAAW,CAAA;IACX,2BAAW,CAAA;IACX,2BAAW,CAAA;IACX,2BAAW,CAAA;IACX,2BAAW,CAAA;IACX,2BAAW,CAAA;IACX,2BAAW,CAAA;IACX,2BAAW,CAAA;IACX,2BAAW,CAAA;IACX,2BAAW,CAAA;IACX,2BAAW,CAAA;IACX,2BAAW,CAAA;IACX,2BAAW,CAAA;IACX,2BAAW,CAAA;IACX,2BAAW,CAAA;IACX,2BAAW,CAAA;IACX,2BAAW,CAAA;IACX,2BAAW,CAAA;IACX,2BAAW,CAAA;IACX,2BAAW,CAAA;IACX,2BAAW,CAAA;IACX,2BAAW,CAAA;IACX,2BAAW,CAAA;IACX,2BAAW,CAAA;IACX,2BAAW,CAAA;IACX,2BAAW,CAAA;IACX,2BAAW,CAAA;IACX,2BAAW,CAAA;IACX,2BAAW,CAAA;IACX,2BAAW,CAAA;IACX,2BAAW,CAAA;IACX,2BAAW,CAAA;IACX,2BAAW,CAAA;IACX,2BAAW,CAAA;IACX,2BAAW,CAAA;IACX,2BAAW,CAAA;IACX,2BAAW,CAAA;IACX,2BAAW,CAAA;IACX,2BAAW,CAAA;IACX,2BAAW,CAAA;IACX,2BAAW,CAAA;IACX,2BAAW,CAAA;IACX,2BAAW,CAAA;IACX,2BAAW,CAAA;IACX,2BAAW,CAAA;IACX,2BAAW,CAAA;IACX,2BAAW,CAAA;IACX,2BAAW,CAAA;IACX,2BAAW,CAAA;IACX,2BAAW,CAAA;IACX,2BAAW,CAAA;IACX,2BAAW,CAAA;IACX,2BAAW,CAAA;IACX,2BAAW,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","sourcesContent":["import { gql } from 'apollo-angular';\nimport { Injectable } from '@angular/core';\nimport * as Apollo from 'apollo-angular';\nexport type Maybe<T> = T | null;\nexport type Exact<T extends { [key: string]: unknown }> = { [K in keyof T]: T[K] };\nexport type MakeOptional<T, K extends keyof T> = Omit<T, K> & { [SubKey in K]?: Maybe<T[SubKey]> };\nexport type MakeMaybe<T, K extends keyof T> = Omit<T, K> & { [SubKey in K]: Maybe<T[SubKey]> };\nexport type FieldWrapper<T> = T;\n/** All built-in and custom scalars, mapped to their actual values */\nexport type Scalars = {\n  ID: string;\n  String: string;\n  Boolean: boolean;\n  Int: number;\n  Float: number;\n  Date: any;\n  DateTime: any;\n  JSON: any;\n};\n\n\n\nexport type Address = {\n  __typename?: 'Address';\n  id: FieldWrapper<Scalars['ID']>;\n  description?: Maybe<FieldWrapper<Scalars['String']>>;\n  numberOrName?: Maybe<FieldWrapper<Scalars['String']>>;\n  street?: Maybe<FieldWrapper<Scalars['String']>>;\n  town?: Maybe<FieldWrapper<Scalars['String']>>;\n  county?: Maybe<FieldWrapper<Scalars['String']>>;\n  postcode?: Maybe<FieldWrapper<Scalars['String']>>;\n  countryCode?: Maybe<FieldWrapper<Scalars['String']>>;\n  userPrimary?: Maybe<FieldWrapper<Scalars['Boolean']>>;\n  officePrimary?: Maybe<FieldWrapper<Scalars['Boolean']>>;\n};\n\nexport type AfterCancellationInfo = {\n  __typename?: 'AfterCancellationInfo';\n  cancelled: FieldWrapper<Scalars['Boolean']>;\n  cancellationFee: FieldWrapper<Scalars['Float']>;\n};\n\nexport type AirlineResult = {\n  __typename?: 'AirlineResult';\n  id: FieldWrapper<Scalars['ID']>;\n  name?: Maybe<FieldWrapper<Scalars['String']>>;\n  iata?: Maybe<FieldWrapper<Scalars['String']>>;\n  icao?: Maybe<FieldWrapper<Scalars['String']>>;\n  alias?: Maybe<FieldWrapper<Scalars['String']>>;\n  callsign?: Maybe<FieldWrapper<Scalars['String']>>;\n  active?: Maybe<FieldWrapper<Scalars['Boolean']>>;\n  continent?: Maybe<FieldWrapper<Scalars['String']>>;\n  country?: Maybe<FieldWrapper<Scalars['String']>>;\n  countryCode?: Maybe<FieldWrapper<Scalars['String']>>;\n  bannerImage?: Maybe<FieldWrapper<Scalars['String']>>;\n  logoImage?: Maybe<FieldWrapper<Scalars['String']>>;\n};\n\nexport type AirlineResults = {\n  __typename?: 'AirlineResults';\n  iataMatch?: Maybe<FieldWrapper<AirlineResult>>;\n  generalMatches: Array<FieldWrapper<AirlineResult>>;\n};\n\nexport type Airport = {\n  __typename?: 'Airport';\n  id: FieldWrapper<Scalars['ID']>;\n  name: FieldWrapper<Scalars['String']>;\n  iata?: Maybe<FieldWrapper<Scalars['String']>>;\n  icao?: Maybe<FieldWrapper<Scalars['String']>>;\n  terminals: Array<FieldWrapper<Scalars['String']>>;\n  hasLounge?: Maybe<FieldWrapper<Scalars['Boolean']>>;\n  hasParking?: Maybe<FieldWrapper<Scalars['Boolean']>>;\n  hasFastTrack?: Maybe<FieldWrapper<Scalars['Boolean']>>;\n  hasPublicTravel?: Maybe<FieldWrapper<Scalars['Boolean']>>;\n  locationDetails?: Maybe<FieldWrapper<LocationDetail>>;\n};\n\nexport type AirportDetail = {\n  __typename?: 'AirportDetail';\n  iata?: Maybe<FieldWrapper<Scalars['String']>>;\n  icao?: Maybe<FieldWrapper<Scalars['String']>>;\n  latitude?: Maybe<FieldWrapper<Scalars['Float']>>;\n  longitude?: Maybe<FieldWrapper<Scalars['Float']>>;\n  altitude?: Maybe<FieldWrapper<Scalars['Float']>>;\n  state?: Maybe<FieldWrapper<Scalars['String']>>;\n  city?: Maybe<FieldWrapper<Scalars['String']>>;\n  road?: Maybe<FieldWrapper<Scalars['String']>>;\n  popularity?: Maybe<FieldWrapper<Scalars['Int']>>;\n  area?: Maybe<FieldWrapper<Scalars['String']>>;\n  location?: Maybe<FieldWrapper<Scalars['String']>>;\n  offset?: Maybe<FieldWrapper<Scalars['String']>>;\n  airportName?: Maybe<FieldWrapper<Scalars['String']>>;\n  countryName?: Maybe<FieldWrapper<Scalars['String']>>;\n  countryCode?: Maybe<FieldWrapper<Scalars['String']>>;\n  postcode?: Maybe<FieldWrapper<Scalars['String']>>;\n};\n\nexport type AirportResults = {\n  __typename?: 'AirportResults';\n  iataMatch?: Maybe<FieldWrapper<Airport>>;\n  generalMatches: Array<FieldWrapper<Airport>>;\n};\n\nexport enum ApplicationStage {\n  BeforeSearch = 'BEFORE_SEARCH',\n  AfterSearch = 'AFTER_SEARCH'\n}\n\nexport type Approvee = {\n  __typename?: 'Approvee';\n  approvee: FieldWrapper<User>;\n  active: FieldWrapper<Scalars['Boolean']>;\n  priority: FieldWrapper<Scalars['Int']>;\n};\n\nexport type Approver = {\n  __typename?: 'Approver';\n  approver: FieldWrapper<User>;\n  active: FieldWrapper<Scalars['Boolean']>;\n  priority: FieldWrapper<Scalars['Int']>;\n};\n\nexport type Association = {\n  __typename?: 'Association';\n  category?: Maybe<FieldWrapper<Scalars['String']>>;\n  rid?: Maybe<FieldWrapper<Scalars['String']>>;\n  uid?: Maybe<FieldWrapper<Scalars['String']>>;\n  trainid?: Maybe<FieldWrapper<Scalars['String']>>;\n  sdd?: Maybe<FieldWrapper<Scalars['String']>>;\n  origin?: Maybe<FieldWrapper<Scalars['String']>>;\n  originCRS?: Maybe<FieldWrapper<Scalars['String']>>;\n  originTiploc?: Maybe<FieldWrapper<Scalars['String']>>;\n  destination?: Maybe<FieldWrapper<Scalars['String']>>;\n  destCRS?: Maybe<FieldWrapper<Scalars['String']>>;\n  destTiploc?: Maybe<FieldWrapper<Scalars['String']>>;\n};\n\nexport type BaggageAllowance = {\n  __typename?: 'BaggageAllowance';\n  type: FieldWrapper<BaggageType>;\n  qty: FieldWrapper<Scalars['Int']>;\n  maxKG?: Maybe<FieldWrapper<Scalars['Float']>>;\n  maxLBS?: Maybe<FieldWrapper<Scalars['Float']>>;\n};\n\nexport enum BaggageType {\n  CheckIn = 'CheckIn',\n  HandCarry = 'HandCarry'\n}\n\nexport type Basket = {\n  __typename?: 'Basket';\n  id: FieldWrapper<Scalars['ID']>;\n  owner: FieldWrapper<User>;\n  reference: FieldWrapper<Scalars['String']>;\n  title: FieldWrapper<Scalars['String']>;\n  notes?: Maybe<FieldWrapper<Scalars['String']>>;\n  createdAt: FieldWrapper<Scalars['DateTime']>;\n  updatedAt: FieldWrapper<Scalars['DateTime']>;\n  basketItems: Array<FieldWrapper<BasketItem>>;\n  status: FieldWrapper<BasketStatus>;\n  companyGroup?: Maybe<FieldWrapper<CompanyGroup>>;\n  validated: FieldWrapper<Scalars['Boolean']>;\n  bookedAt?: Maybe<FieldWrapper<Scalars['DateTime']>>;\n};\n\nexport type BasketItem = {\n  __typename?: 'BasketItem';\n  id: FieldWrapper<Scalars['ID']>;\n  basket: FieldWrapper<Basket>;\n  adults: FieldWrapper<Scalars['Int']>;\n  children: FieldWrapper<Scalars['Int']>;\n  infants: FieldWrapper<Scalars['Int']>;\n  detail: FieldWrapper<Scalars['JSON']>;\n  detailHash: FieldWrapper<Scalars['String']>;\n  createdAt: FieldWrapper<Scalars['DateTime']>;\n  updatedAt: FieldWrapper<Scalars['DateTime']>;\n  expiry: FieldWrapper<Scalars['DateTime']>;\n  expired: FieldWrapper<Scalars['Boolean']>;\n  users: Array<FieldWrapper<User>>;\n  userPassengerTypes: Array<FieldWrapper<UserPassengerType>>;\n  leadPassenger?: Maybe<FieldWrapper<User>>;\n  service: FieldWrapper<Service>;\n  searchQuery: FieldWrapper<Scalars['JSON']>;\n  price: FieldWrapper<Scalars['Float']>;\n  currency: FieldWrapper<CurrencyCode>;\n  miGroupsAvailable: Array<FieldWrapper<Scalars['String']>>;\n  miGroupSelected?: Maybe<FieldWrapper<Scalars['String']>>;\n  managementInfo: Array<FieldWrapper<ManagementInfo>>;\n  validated: FieldWrapper<Scalars['Boolean']>;\n  latestValidation?: Maybe<FieldWrapper<Scalars['DateTime']>>;\n  latestValidationPrice?: Maybe<FieldWrapper<Scalars['Int']>>;\n  latestValidationPriceDifference?: Maybe<FieldWrapper<Scalars['Int']>>;\n  latestValidationAvailable?: Maybe<FieldWrapper<Scalars['Boolean']>>;\n  bookingThirdPartyReference?: Maybe<FieldWrapper<Scalars['String']>>;\n  pnrLocator?: Maybe<FieldWrapper<Scalars['String']>>;\n  status: FieldWrapper<BasketItemStatus>;\n  availablePaymentMethods: Array<FieldWrapper<PaymentMethod>>;\n  selectedPaymentMethod?: Maybe<FieldWrapper<PaymentMethod>>;\n  perItemSupplementaryBookingInfoSchema: FieldWrapper<Scalars['JSON']>;\n  perPassengerSupplementaryBookingInfoSchema: FieldWrapper<Scalars['JSON']>;\n  perItemAddress: FieldWrapper<Scalars['Boolean']>;\n  perItemPhoneNumber: FieldWrapper<Scalars['Boolean']>;\n  perPassengerAddress: FieldWrapper<Scalars['Boolean']>;\n  perPassengerPhoneNumber: FieldWrapper<Scalars['Boolean']>;\n  cancellable: FieldWrapper<Scalars['Boolean']>;\n  amendable: FieldWrapper<Scalars['Boolean']>;\n  co2PerPassenger: FieldWrapper<Scalars['Float']>;\n  co2PerItem: FieldWrapper<Scalars['Float']>;\n  outboundDate: FieldWrapper<Scalars['DateTime']>;\n  inboundDate?: Maybe<FieldWrapper<Scalars['DateTime']>>;\n};\n\nexport enum BasketItemStatus {\n  Open = 'OPEN',\n  Booked = 'BOOKED',\n  BookingFailed = 'BOOKING_FAILED'\n}\n\nexport enum BasketStatus {\n  Open = 'OPEN',\n  Booked = 'BOOKED',\n  AwaitingApproval = 'AWAITING_APPROVAL',\n  Approved = 'APPROVED',\n  Disapproved = 'DISAPPROVED',\n  PartiallyBooked = 'PARTIALLY_BOOKED',\n  BookingFailed = 'BOOKING_FAILED'\n}\n\nexport type BeforeCancellationInfo = {\n  __typename?: 'BeforeCancellationInfo';\n  cancellable: FieldWrapper<Scalars['Boolean']>;\n  info?: Maybe<FieldWrapper<Scalars['String']>>;\n  cancellationFee?: Maybe<FieldWrapper<Scalars['Float']>>;\n};\n\nexport enum BookerType {\n  Root = 'ROOT',\n  Tmc = 'TMC',\n  Company = 'COMPANY',\n  Office = 'OFFICE',\n  CompanyGroup = 'COMPANY_GROUP',\n  SelfBook = 'SELF_BOOK',\n  Booker = 'BOOKER',\n  Traveller = 'TRAVELLER',\n  BookerWithSelf = 'BOOKER_WITH_SELF'\n}\n\nexport type BookingAddress = {\n  numberOrName: Scalars['String'];\n  street: Scalars['String'];\n  town: Scalars['String'];\n  county: Scalars['String'];\n  postcode: Scalars['String'];\n  countryCode: Scalars['String'];\n};\n\nexport type BookingPhoneNumber = {\n  countryCode: Scalars['String'];\n  areaCode: Scalars['String'];\n  number: Scalars['String'];\n  extension?: Maybe<Scalars['String']>;\n};\n\nexport type CabHireLocation = {\n  __typename?: 'CabHireLocation';\n  address: FieldWrapper<Scalars['String']>;\n  postcode: FieldWrapper<Scalars['String']>;\n  latitude?: Maybe<FieldWrapper<Scalars['Float']>>;\n  longitude?: Maybe<FieldWrapper<Scalars['Float']>>;\n};\n\nexport type CabHireLocationInput = {\n  address: Scalars['String'];\n  postcode: Scalars['String'];\n};\n\nexport type CabHireQuote = {\n  __typename?: 'CabHireQuote';\n  id: FieldWrapper<Scalars['ID']>;\n  source: FieldWrapper<Scalars['String']>;\n  sourceId: FieldWrapper<Scalars['Int']>;\n  supplierName: FieldWrapper<Scalars['String']>;\n  estimatedCO2: FieldWrapper<Scalars['Float']>;\n  co2PerPassenger: FieldWrapper<Scalars['Float']>;\n  co2PerItem: FieldWrapper<Scalars['Float']>;\n  price: FieldWrapper<Scalars['Float']>;\n  currency: FieldWrapper<CurrencyCode>;\n  vehicleType: FieldWrapper<CabHireVehicleType>;\n  tripDistanceMetres?: Maybe<FieldWrapper<Scalars['Int']>>;\n  tripDurationSeconds?: Maybe<FieldWrapper<Scalars['Int']>>;\n  departs: FieldWrapper<Scalars['DateTime']>;\n  tmcPreferred: FieldWrapper<Scalars['Boolean']>;\n  companyPreferred: FieldWrapper<Scalars['Boolean']>;\n  officePreferred: FieldWrapper<Scalars['Boolean']>;\n  tmcPreferredMessage?: Maybe<FieldWrapper<Scalars['String']>>;\n  companyPreferredMessage?: Maybe<FieldWrapper<Scalars['String']>>;\n  officePreferredMessage?: Maybe<FieldWrapper<Scalars['String']>>;\n  unavailable: FieldWrapper<Scalars['Boolean']>;\n  unavailableMessage?: Maybe<FieldWrapper<Scalars['String']>>;\n  fromLocation: FieldWrapper<CabHireLocation>;\n  toLocation: FieldWrapper<CabHireLocation>;\n  vias: Array<FieldWrapper<CabHireLocation>>;\n};\n\nexport type CabHireResult = {\n  __typename?: 'CabHireResult';\n  results: Array<FieldWrapper<CabHireQuote>>;\n  errors: Array<FieldWrapper<SearchError>>;\n};\n\nexport enum CabHireVehicleType {\n  Any = 'Any',\n  DdaCar = 'DDACar',\n  CoachLarge = 'CoachLarge',\n  CoachSmall = 'CoachSmall',\n  Economy = 'Economy',\n  EconomyCoach = 'EconomyCoach',\n  EconomyMpvSmall = 'EconomyMPVSmall',\n  EconomyMpvLarge = 'EconomyMPVLarge',\n  EconomySuv = 'EconomySUV',\n  ExecutiveCar = 'ExecutiveCar',\n  ExecutiveSuv = 'ExecutiveSUV',\n  GreenCar = 'GreenCar',\n  GreenExecutive = 'GreenExecutive',\n  GreenSuv = 'GreenSUV',\n  SmallMpv = 'SmallMPV',\n  MediumMpv = 'MediumMPV',\n  LargeMpv = 'LargeMPV',\n  StandardCar = 'StandardCar',\n  Suv = 'SUV',\n  BlackCab = 'BlackCab',\n  TaxiSuv = 'TaxiSUV'\n}\n\nexport type CarHireAdditionalInfoItem = {\n  __typename?: 'CarHireAdditionalInfoItem';\n  name?: Maybe<FieldWrapper<Scalars['String']>>;\n  text?: Maybe<Array<Maybe<FieldWrapper<Scalars['String']>>>>;\n  json?: Maybe<FieldWrapper<Scalars['String']>>;\n  custom?: Maybe<Array<Maybe<FieldWrapper<CarHireCustom>>>>;\n};\n\nexport type CarHireAddress = {\n  __typename?: 'CarHireAddress';\n  name?: Maybe<FieldWrapper<Scalars['String']>>;\n  topLine?: Maybe<FieldWrapper<Scalars['String']>>;\n  city?: Maybe<FieldWrapper<Scalars['String']>>;\n  region?: Maybe<FieldWrapper<Scalars['String']>>;\n  postCode?: Maybe<FieldWrapper<Scalars['String']>>;\n  country?: Maybe<FieldWrapper<Scalars['String']>>;\n  countryCode?: Maybe<FieldWrapper<Scalars['String']>>;\n  stateCode?: Maybe<FieldWrapper<Scalars['String']>>;\n  latitude?: Maybe<FieldWrapper<Scalars['Float']>>;\n  longitude?: Maybe<FieldWrapper<Scalars['Float']>>;\n};\n\nexport type CarHireAirportInput = {\n  pickupCode?: Maybe<Scalars['String']>;\n  dropoffCode?: Maybe<Scalars['String']>;\n};\n\nexport type CarHireCharge = {\n  __typename?: 'CarHireCharge';\n  label?: Maybe<FieldWrapper<Scalars['String']>>;\n  amount?: Maybe<FieldWrapper<Scalars['String']>>;\n  currencyCode?: Maybe<FieldWrapper<Scalars['String']>>;\n};\n\nexport type CarHireCityInput = {\n  pickupCountryCode?: Maybe<Scalars['String']>;\n  pickupCity?: Maybe<Scalars['String']>;\n  dropoffCountryCode?: Maybe<Scalars['String']>;\n  dropoffCity?: Maybe<Scalars['String']>;\n};\n\nexport enum CarHireClass {\n  Mini = 'Mini',\n  MiniElite = 'MiniElite',\n  Economy = 'Economy',\n  EconomyElite = 'EconomyElite',\n  Compact = 'Compact',\n  CompactElite = 'CompactElite',\n  Intermediate = 'Intermediate',\n  IntermediateElite = 'IntermediateElite',\n  Standard = 'Standard',\n  StandardElite = 'StandardElite',\n  Fullsize = 'Fullsize',\n  FullsizeElite = 'FullsizeElite',\n  Premium = 'Premium',\n  PremiumElite = 'PremiumElite',\n  Luxury = 'Luxury',\n  LuxuryElite = 'LuxuryElite',\n  Oversize = 'Oversize',\n  Special = 'Special'\n}\n\nexport type CarHireCustom = {\n  __typename?: 'CarHireCustom';\n  name?: Maybe<FieldWrapper<Scalars['String']>>;\n  text?: Maybe<Array<Maybe<FieldWrapper<Scalars['String']>>>>;\n};\n\nexport type CarHireDepot = {\n  __typename?: 'CarHireDepot';\n  countryCode?: Maybe<FieldWrapper<Scalars['String']>>;\n  locationCode?: Maybe<FieldWrapper<Scalars['String']>>;\n  extendedLocationCode?: Maybe<FieldWrapper<Scalars['String']>>;\n  vendorCode?: Maybe<FieldWrapper<Scalars['String']>>;\n  latitude?: Maybe<FieldWrapper<Scalars['Float']>>;\n  longitude?: Maybe<FieldWrapper<Scalars['Float']>>;\n  vendor?: Maybe<FieldWrapper<Scalars['String']>>;\n  addressLines?: Maybe<Array<Maybe<FieldWrapper<Scalars['String']>>>>;\n  cityName?: Maybe<FieldWrapper<Scalars['String']>>;\n};\n\nexport type CarHireDepotResult = {\n  __typename?: 'CarHireDepotResult';\n  results: Array<FieldWrapper<CarHireDepot>>;\n  errors: Array<FieldWrapper<SearchError>>;\n};\n\nexport type CarHireDetailRequestResponse = {\n  __typename?: 'CarHireDetailRequestResponse';\n  identifiers?: Maybe<FieldWrapper<CarHireIdentifiers>>;\n  vendor?: Maybe<FieldWrapper<CarHireVendor>>;\n  address?: Maybe<FieldWrapper<CarHireAddress>>;\n  additionalInfo?: Maybe<Array<FieldWrapper<CarHireAdditionalInfoItem>>>;\n};\n\nexport type CarHireDisplayRecord = {\n  __typename?: 'CarHireDisplayRecord';\n  status?: Maybe<FieldWrapper<Scalars['String']>>;\n  pickup?: Maybe<FieldWrapper<Scalars['String']>>;\n  dropoff?: Maybe<FieldWrapper<Scalars['String']>>;\n  vendor?: Maybe<FieldWrapper<CarHireVendor>>;\n  vehicle?: Maybe<FieldWrapper<CarHireVehicle>>;\n  charges?: Maybe<Array<Maybe<FieldWrapper<CarHireCharge>>>>;\n  pickupLocation?: Maybe<FieldWrapper<CarHireAddress>>;\n  returnLocation?: Maybe<FieldWrapper<CarHireAddress>>;\n  additionalInfo?: Maybe<Array<Maybe<FieldWrapper<CarHireAdditionalInfoItem>>>>;\n};\n\nexport type CarHireIdentifiers = {\n  __typename?: 'CarHireIdentifiers';\n  locator?: Maybe<FieldWrapper<Scalars['String']>>;\n  rph?: Maybe<FieldWrapper<Scalars['String']>>;\n  status?: Maybe<FieldWrapper<Scalars['String']>>;\n  vehType?: Maybe<FieldWrapper<Scalars['String']>>;\n  locationCode?: Maybe<FieldWrapper<Scalars['String']>>;\n  extendedLocationCode?: Maybe<FieldWrapper<Scalars['String']>>;\n  locationName?: Maybe<FieldWrapper<Scalars['String']>>;\n  dropOffLocation?: Maybe<FieldWrapper<Scalars['String']>>;\n  pickupDateTime?: Maybe<FieldWrapper<Scalars['DateTime']>>;\n  dropoffDateTime?: Maybe<FieldWrapper<Scalars['DateTime']>>;\n  vendor?: Maybe<FieldWrapper<Scalars['String']>>;\n};\n\nexport type CarHireInputIdentifiers = {\n  locator?: Maybe<Scalars['String']>;\n  rph?: Maybe<Scalars['String']>;\n  status?: Maybe<Scalars['String']>;\n  vehType?: Maybe<Scalars['String']>;\n  locationCode?: Maybe<Scalars['String']>;\n  extendedLocationCode?: Maybe<Scalars['String']>;\n  locationName?: Maybe<Scalars['String']>;\n  dropOffLocation?: Maybe<Scalars['String']>;\n  pickupDateTime?: Maybe<Scalars['DateTime']>;\n  dropoffDateTime?: Maybe<Scalars['DateTime']>;\n  vendor?: Maybe<Scalars['String']>;\n};\n\nexport type CarHireLocationInput = {\n  pickupCountryCode?: Maybe<Scalars['String']>;\n  pickupPostalCode?: Maybe<Scalars['String']>;\n  dropoffCountryCode?: Maybe<Scalars['String']>;\n  dropoffPostalCode?: Maybe<Scalars['String']>;\n};\n\nexport type CarHireResult = {\n  __typename?: 'CarHireResult';\n  results: Array<FieldWrapper<CarHireVehicleAvailibility>>;\n  errors: Array<FieldWrapper<SearchError>>;\n};\n\nexport enum CarHireTransmission {\n  Manual = 'Manual',\n  Auto = 'Auto'\n}\n\nexport enum CarHireType {\n  TwoToThreeDoor = 'TwoToThreeDoor',\n  TwoOrFourDoor = 'TwoOrFourDoor',\n  FourToFiveDoor = 'FourToFiveDoor',\n  WagonOrEstate = 'WagonOrEstate',\n  PassengerVan = 'PassengerVan',\n  Limousine = 'Limousine',\n  Sport = 'Sport',\n  Convertible = 'Convertible',\n  Suv = 'SUV',\n  OpenAirAllTerrain = 'OpenAirAllTerrain',\n  Special = 'Special',\n  PickUpRegularCab = 'PickUpRegularCab',\n  PickUpExtendedCab = 'PickUpExtendedCab',\n  SpecialOfferCar = 'SpecialOfferCar',\n  Coupe = 'Coupe',\n  MonospaceEuropeanUse = 'MonospaceEuropeanUse',\n  MotorHome = 'MotorHome',\n  TwoWheelVehicle = 'TwoWheelVehicle',\n  Roadster = 'Roadster'\n}\n\nexport type CarHireVehicle = {\n  __typename?: 'CarHireVehicle';\n  class?: Maybe<FieldWrapper<Scalars['String']>>;\n  type?: Maybe<FieldWrapper<Scalars['String']>>;\n  transmission?: Maybe<FieldWrapper<Scalars['String']>>;\n  aircon?: Maybe<FieldWrapper<Scalars['Boolean']>>;\n  description?: Maybe<FieldWrapper<Scalars['String']>>;\n  images?: Maybe<Array<Maybe<FieldWrapper<Scalars['String']>>>>;\n};\n\nexport type CarHireVehicleAvailibility = {\n  __typename?: 'CarHireVehicleAvailibility';\n  source: FieldWrapper<Scalars['String']>;\n  sourceId: FieldWrapper<Scalars['Int']>;\n  identifiers?: Maybe<FieldWrapper<CarHireIdentifiers>>;\n  displayRecord?: Maybe<FieldWrapper<CarHireDisplayRecord>>;\n  tmcPreferred: FieldWrapper<Scalars['Boolean']>;\n  companyPreferred: FieldWrapper<Scalars['Boolean']>;\n  officePreferred: FieldWrapper<Scalars['Boolean']>;\n  tmcPreferredMessage?: Maybe<FieldWrapper<Scalars['String']>>;\n  companyPreferredMessage?: Maybe<FieldWrapper<Scalars['String']>>;\n  officePreferredMessage?: Maybe<FieldWrapper<Scalars['String']>>;\n  unavailable: FieldWrapper<Scalars['Boolean']>;\n  unavailableMessage?: Maybe<FieldWrapper<Scalars['String']>>;\n  co2PerPassenger: FieldWrapper<Scalars['Float']>;\n  co2PerItem: FieldWrapper<Scalars['Float']>;\n};\n\nexport type CarHireVendor = {\n  __typename?: 'CarHireVendor';\n  name?: Maybe<FieldWrapper<Scalars['String']>>;\n  logo?: Maybe<FieldWrapper<Scalars['String']>>;\n};\n\nexport type CarbonAllowance = {\n  __typename?: 'CarbonAllowance';\n  id: FieldWrapper<Scalars['ID']>;\n  startOfPeriod: FieldWrapper<Scalars['DateTime']>;\n  endOfPeriod: FieldWrapper<Scalars['DateTime']>;\n  remainingCo2: FieldWrapper<Scalars['Float']>;\n  totalCo2: FieldWrapper<Scalars['Float']>;\n  carbonPolicySource: FieldWrapper<CarbonPolicySource>;\n  periodConsumption: Array<FieldWrapper<CarbonConsumption>>;\n  company?: Maybe<FieldWrapper<Company>>;\n  office?: Maybe<FieldWrapper<Office>>;\n  user: FieldWrapper<User>;\n};\n\nexport type CarbonConsumption = {\n  __typename?: 'CarbonConsumption';\n  id: FieldWrapper<Scalars['ID']>;\n  consumed: FieldWrapper<Scalars['Float']>;\n  datetime: FieldWrapper<Scalars['DateTime']>;\n};\n\nexport enum CarbonPolicySource {\n  Company = 'COMPANY',\n  Office = 'OFFICE',\n  User = 'USER'\n}\n\nexport type City = {\n  __typename?: 'City';\n  id: FieldWrapper<Scalars['ID']>;\n  name: FieldWrapper<Scalars['String']>;\n  country: FieldWrapper<Scalars['String']>;\n  countryCode: FieldWrapper<Scalars['String']>;\n  coordinates: FieldWrapper<GeoCoordinates>;\n  continentName: FieldWrapper<Scalars['String']>;\n};\n\nexport type Company = {\n  __typename?: 'Company';\n  id: FieldWrapper<Scalars['ID']>;\n  name: FieldWrapper<Scalars['String']>;\n  tmc: FieldWrapper<Tmc>;\n  offices: Array<FieldWrapper<Office>>;\n  companyGroups: Array<FieldWrapper<CompanyGroup>>;\n  addresses: Array<FieldWrapper<Address>>;\n  phoneNumbers: Array<FieldWrapper<PhoneNumber>>;\n  supportPhoneNumber?: Maybe<FieldWrapper<PhoneNumber>>;\n  createdAt: FieldWrapper<Scalars['DateTime']>;\n  updatedAt: FieldWrapper<Scalars['DateTime']>;\n  supportEmail: FieldWrapper<Scalars['String']>;\n  co2ConsumptionPolicy?: Maybe<FieldWrapper<Scalars['String']>>;\n  co2AllowancePeriod?: Maybe<FieldWrapper<Scalars['String']>>;\n  co2AllowancePerPeriod?: Maybe<FieldWrapper<Scalars['String']>>;\n};\n\nexport type CompanyGroup = {\n  __typename?: 'CompanyGroup';\n  id: FieldWrapper<Scalars['ID']>;\n  name: FieldWrapper<Scalars['String']>;\n  description: FieldWrapper<Scalars['String']>;\n  company: FieldWrapper<Company>;\n  createdAt: FieldWrapper<Scalars['DateTime']>;\n  updatedAt: FieldWrapper<Scalars['DateTime']>;\n};\n\nexport type ConfermaBlockedHotelsResult = {\n  __typename?: 'ConfermaBlockedHotelsResult';\n  results: FieldWrapper<Scalars['Boolean']>;\n  errors: Array<FieldWrapper<SearchError>>;\n};\n\nexport type ConfermaCard = {\n  __typename?: 'ConfermaCard';\n  id: FieldWrapper<Scalars['ID']>;\n  label?: Maybe<FieldWrapper<Scalars['String']>>;\n  token?: Maybe<FieldWrapper<Scalars['String']>>;\n  webInstanceId?: Maybe<FieldWrapper<Scalars['String']>>;\n  company?: Maybe<FieldWrapper<Scalars['ID']>>;\n  office?: Maybe<FieldWrapper<Scalars['ID']>>;\n  user?: Maybe<FieldWrapper<Scalars['ID']>>;\n  status: FieldWrapper<ConfermaCardStatus>;\n  expires?: Maybe<FieldWrapper<Scalars['String']>>;\n  cardHolderName?: Maybe<FieldWrapper<Scalars['String']>>;\n  cardType?: Maybe<FieldWrapper<Scalars['String']>>;\n};\n\nexport type ConfermaCardResults = {\n  __typename?: 'ConfermaCardResults';\n  id: FieldWrapper<Scalars['ID']>;\n  label?: Maybe<FieldWrapper<Scalars['String']>>;\n  token?: Maybe<FieldWrapper<Scalars['String']>>;\n  cardHolderName?: Maybe<FieldWrapper<Scalars['String']>>;\n  cardType?: Maybe<FieldWrapper<Scalars['String']>>;\n  expires?: Maybe<FieldWrapper<Scalars['Date']>>;\n  status: FieldWrapper<ConfermaCardStatus>;\n};\n\nexport enum ConfermaCardStatus {\n  Pending = 'Pending',\n  Enabled = 'Enabled',\n  Disabled = 'Disabled'\n}\n\nexport type ConfermaCityLocation = {\n  __typename?: 'ConfermaCityLocation';\n  foundExact: FieldWrapper<Scalars['Boolean']>;\n  suggestions?: Maybe<Array<Maybe<FieldWrapper<ConfermaCityLocationOptions>>>>;\n};\n\nexport type ConfermaCityLocationOptions = {\n  __typename?: 'ConfermaCityLocationOptions';\n  name: FieldWrapper<Scalars['String']>;\n  countryCode: FieldWrapper<Scalars['String']>;\n  latitude?: Maybe<FieldWrapper<Scalars['Float']>>;\n  longitude?: Maybe<FieldWrapper<Scalars['Float']>>;\n};\n\nexport type ConfermaCreateCardResult = {\n  __typename?: 'ConfermaCreateCardResult';\n  results?: Maybe<FieldWrapper<Scalars['String']>>;\n  errors: Array<FieldWrapper<SearchError>>;\n};\n\nexport type ConfermaOfficeAddress = {\n  __typename?: 'ConfermaOfficeAddress';\n  addressName?: Maybe<FieldWrapper<Scalars['String']>>;\n  addressLine1?: Maybe<FieldWrapper<Scalars['String']>>;\n  addressLine2?: Maybe<FieldWrapper<Scalars['String']>>;\n  addressLine3?: Maybe<FieldWrapper<Scalars['String']>>;\n  postalCode?: Maybe<FieldWrapper<Scalars['String']>>;\n  city?: Maybe<FieldWrapper<Scalars['String']>>;\n  countryCode?: Maybe<FieldWrapper<Scalars['String']>>;\n  countryName?: Maybe<FieldWrapper<Scalars['String']>>;\n  telephoneNumber?: Maybe<FieldWrapper<Scalars['String']>>;\n  facsimileNumber?: Maybe<FieldWrapper<Scalars['String']>>;\n  emailAddress?: Maybe<FieldWrapper<Scalars['String']>>;\n  stateProvince?: Maybe<FieldWrapper<Scalars['String']>>;\n  mobileNumber?: Maybe<FieldWrapper<Scalars['String']>>;\n};\n\nexport type ConfermaOfficeHotels = {\n  __typename?: 'ConfermaOfficeHotels';\n  hotelId?: Maybe<FieldWrapper<Scalars['Int']>>;\n  hotelName?: Maybe<FieldWrapper<Scalars['String']>>;\n  isPreferred?: Maybe<FieldWrapper<Scalars['Boolean']>>;\n};\n\nexport type ConfermaOfficeInfo = {\n  __typename?: 'ConfermaOfficeInfo';\n  id: FieldWrapper<Scalars['Int']>;\n  name?: Maybe<FieldWrapper<Scalars['String']>>;\n  address?: Maybe<FieldWrapper<ConfermaOfficeAddress>>;\n  closestAirport?: Maybe<FieldWrapper<Scalars['String']>>;\n  closestTrainStation?: Maybe<FieldWrapper<Scalars['String']>>;\n  longitude?: Maybe<FieldWrapper<Scalars['String']>>;\n  latitude?: Maybe<FieldWrapper<Scalars['String']>>;\n  closestHotels?: Maybe<Array<Maybe<FieldWrapper<ConfermaOfficeHotels>>>>;\n};\n\nexport type ConfermaOfficeNames = {\n  __typename?: 'ConfermaOfficeNames';\n  id: FieldWrapper<Scalars['Int']>;\n  name: FieldWrapper<Scalars['String']>;\n};\n\nexport type ConfermaOfficeNamesResult = {\n  __typename?: 'ConfermaOfficeNamesResult';\n  results?: Maybe<Array<Maybe<FieldWrapper<ConfermaOfficeNames>>>>;\n  errors: Array<FieldWrapper<SearchError>>;\n};\n\nexport type ConfermaOfficeResult = {\n  __typename?: 'ConfermaOfficeResult';\n  results?: Maybe<FieldWrapper<ConfermaOfficeInfo>>;\n  errors: Array<FieldWrapper<SearchError>>;\n};\n\nexport type Country = {\n  __typename?: 'Country';\n  id: FieldWrapper<Scalars['ID']>;\n  name: FieldWrapper<Scalars['String']>;\n  code: FieldWrapper<Scalars['String']>;\n  dialCode?: Maybe<FieldWrapper<Scalars['String']>>;\n};\n\nexport enum CurrencyCode {\n  Aed = 'AED',\n  Afn = 'AFN',\n  All = 'ALL',\n  Amd = 'AMD',\n  Ang = 'ANG',\n  Aoa = 'AOA',\n  Ars = 'ARS',\n  Aud = 'AUD',\n  Awg = 'AWG',\n  Azn = 'AZN',\n  Bam = 'BAM',\n  Bbd = 'BBD',\n  Bdt = 'BDT',\n  Bgn = 'BGN',\n  Bhd = 'BHD',\n  Bif = 'BIF',\n  Bmd = 'BMD',\n  Bnd = 'BND',\n  Bob = 'BOB',\n  Bov = 'BOV',\n  Brl = 'BRL',\n  Bsd = 'BSD',\n  Btn = 'BTN',\n  Bwp = 'BWP',\n  Byn = 'BYN',\n  Bzd = 'BZD',\n  Cad = 'CAD',\n  Cdf = 'CDF',\n  Che = 'CHE',\n  Chf = 'CHF',\n  Chw = 'CHW',\n  Clf = 'CLF',\n  Clp = 'CLP',\n  Cny = 'CNY',\n  Cop = 'COP',\n  Cou = 'COU',\n  Crc = 'CRC',\n  Cuc = 'CUC',\n  Cup = 'CUP',\n  Cve = 'CVE',\n  Czk = 'CZK',\n  Djf = 'DJF',\n  Dkk = 'DKK',\n  Dop = 'DOP',\n  Dzd = 'DZD',\n  Egp = 'EGP',\n  Ern = 'ERN',\n  Etb = 'ETB',\n  Eur = 'EUR',\n  Fjd = 'FJD',\n  Fkp = 'FKP',\n  Gbp = 'GBP',\n  Gel = 'GEL',\n  Ghs = 'GHS',\n  Gip = 'GIP',\n  Gmd = 'GMD',\n  Gnf = 'GNF',\n  Gtq = 'GTQ',\n  Gyd = 'GYD',\n  Hkd = 'HKD',\n  Hnl = 'HNL',\n  Hrk = 'HRK',\n  Htg = 'HTG',\n  Huf = 'HUF',\n  Idr = 'IDR',\n  Ils = 'ILS',\n  Inr = 'INR',\n  Iqd = 'IQD',\n  Irr = 'IRR',\n  Isk = 'ISK',\n  Jmd = 'JMD',\n  Jod = 'JOD',\n  Jpy = 'JPY',\n  Kes = 'KES',\n  Kgs = 'KGS',\n  Khr = 'KHR',\n  Kmf = 'KMF',\n  Kpw = 'KPW',\n  Krw = 'KRW',\n  Kwd = 'KWD',\n  Kyd = 'KYD',\n  Kzt = 'KZT',\n  Lak = 'LAK',\n  Lbp = 'LBP',\n  Lkr = 'LKR',\n  Lrd = 'LRD',\n  Lsl = 'LSL',\n  Lyd = 'LYD',\n  Mad = 'MAD',\n  Mdl = 'MDL',\n  Mga = 'MGA',\n  Mkd = 'MKD',\n  Mmk = 'MMK',\n  Mnt = 'MNT',\n  Mop = 'MOP',\n  Mru = 'MRU',\n  Mur = 'MUR',\n  Mvr = 'MVR',\n  Mwk = 'MWK',\n  Mxn = 'MXN',\n  Mxv = 'MXV',\n  Myr = 'MYR',\n  Mzn = 'MZN',\n  Nad = 'NAD',\n  Ngn = 'NGN',\n  Nio = 'NIO',\n  Nok = 'NOK',\n  Npr = 'NPR',\n  Nzd = 'NZD',\n  Omr = 'OMR',\n  Pab = 'PAB',\n  Pen = 'PEN',\n  Pgk = 'PGK',\n  Php = 'PHP',\n  Pkr = 'PKR',\n  Pln = 'PLN',\n  Pyg = 'PYG',\n  Qar = 'QAR',\n  Ron = 'RON',\n  Rsd = 'RSD',\n  Rub = 'RUB',\n  Rwf = 'RWF',\n  Sar = 'SAR',\n  Sbd = 'SBD',\n  Scr = 'SCR',\n  Sdg = 'SDG',\n  Sek = 'SEK',\n  Sgd = 'SGD',\n  Shp = 'SHP',\n  Sll = 'SLL',\n  Sos = 'SOS',\n  Srd = 'SRD',\n  Ssp = 'SSP',\n  Stn = 'STN',\n  Svc = 'SVC',\n  Syp = 'SYP',\n  Szl = 'SZL',\n  Thb = 'THB',\n  Tjs = 'TJS',\n  Tmt = 'TMT',\n  Tnd = 'TND',\n  Top = 'TOP',\n  Try = 'TRY',\n  Ttd = 'TTD',\n  Twd = 'TWD',\n  Tzs = 'TZS',\n  Uah = 'UAH',\n  Ugx = 'UGX',\n  Usd = 'USD',\n  Usn = 'USN',\n  Uyi = 'UYI',\n  Uyu = 'UYU',\n  Uzs = 'UZS',\n  Vef = 'VEF',\n  Vnd = 'VND',\n  Vuv = 'VUV',\n  Wst = 'WST',\n  Xaf = 'XAF',\n  Xag = 'XAG',\n  Xau = 'XAU',\n  Xba = 'XBA',\n  Xbb = 'XBB',\n  Xbc = 'XBC',\n  Xbd = 'XBD',\n  Xcd = 'XCD',\n  Xdr = 'XDR',\n  Xof = 'XOF',\n  Xpd = 'XPD',\n  Xpf = 'XPF',\n  Xpt = 'XPT',\n  Xsu = 'XSU',\n  Xts = 'XTS',\n  Xua = 'XUA',\n  Xxx = 'XXX',\n  Yer = 'YER',\n  Zar = 'ZAR',\n  Zmw = 'ZMW',\n  Zwl = 'ZWL'\n}\n\n\n\nexport type DepartureBoardService = {\n  __typename?: 'DepartureBoardService';\n  rid?: Maybe<FieldWrapper<Scalars['String']>>;\n  uid?: Maybe<FieldWrapper<Scalars['String']>>;\n  trainid?: Maybe<FieldWrapper<Scalars['String']>>;\n  sdd?: Maybe<FieldWrapper<Scalars['String']>>;\n  operator?: Maybe<FieldWrapper<Scalars['String']>>;\n  operatorCode?: Maybe<FieldWrapper<Scalars['String']>>;\n  std?: Maybe<FieldWrapper<Scalars['String']>>;\n  etd?: Maybe<FieldWrapper<Scalars['String']>>;\n  departureType?: Maybe<FieldWrapper<Scalars['String']>>;\n  departureSource?: Maybe<FieldWrapper<Scalars['String']>>;\n  platform?: Maybe<FieldWrapper<Scalars['String']>>;\n  platformIsHidden: FieldWrapper<Scalars['Boolean']>;\n  origin?: Maybe<FieldWrapper<Location>>;\n  destination?: Maybe<FieldWrapper<Location>>;\n  subsequentLocations?: Maybe<Array<Maybe<FieldWrapper<SubsequentLocations>>>>;\n};\n\nexport type DestinationEntry = {\n  orig: Scalars['String'];\n  dest: Scalars['String'];\n  date: Scalars['Date'];\n};\n\nexport enum DistanceTypes {\n  K = 'K',\n  M = 'M'\n}\n\nexport type DynamicCondition = {\n  __typename?: 'DynamicCondition';\n  name?: Maybe<FieldWrapper<Scalars['String']>>;\n  description?: Maybe<FieldWrapper<Scalars['String']>>;\n};\n\nexport type FeFlightSearchResults = {\n  __typename?: 'FEFlightSearchResults';\n  journeys: Array<FieldWrapper<FlightItinerary>>;\n  multi: Array<FieldWrapper<ItinerarySummary>>;\n  grouped?: Maybe<Array<FieldWrapper<GroupFlights>>>;\n};\n\nexport type FareConditionEntry = {\n  __typename?: 'FareConditionEntry';\n  name: FieldWrapper<Scalars['String']>;\n  type: FieldWrapper<FareRuleType>;\n  currency: FieldWrapper<Scalars['String']>;\n  amount: FieldWrapper<Scalars['Float']>;\n  remark?: Maybe<FieldWrapper<Scalars['String']>>;\n  changeFeeInd: FieldWrapper<Scalars['Boolean']>;\n  cancelFeeInd: FieldWrapper<Scalars['Boolean']>;\n  refundableInd: FieldWrapper<Scalars['Boolean']>;\n};\n\nexport type FareConditions = {\n  __typename?: 'FareConditions';\n  cancellation?: Maybe<Array<Maybe<FieldWrapper<FareConditionEntry>>>>;\n  change?: Maybe<Array<Maybe<FieldWrapper<FareConditionEntry>>>>;\n  noShow?: Maybe<Array<Maybe<FieldWrapper<FareConditionEntry>>>>;\n  upgrade?: Maybe<Array<Maybe<FieldWrapper<FareConditionEntry>>>>;\n  other?: Maybe<Array<Maybe<FieldWrapper<FareConditionEntry>>>>;\n};\n\nexport enum FareRuleType {\n  Cancellation = 'Cancellation',\n  Change = 'Change',\n  NoShow = 'NoShow',\n  Upgrade = 'Upgrade',\n  Other = 'Other'\n}\n\nexport enum FareType {\n  Flexible = 'Flexible',\n  Lowest = 'Lowest',\n  Negotiated = 'Negotiated',\n  NonNegotiated = 'NonNegotiated',\n  Leisure = 'Leisure',\n  RequestFareRules = 'RequestFareRules',\n  SelectAndPro = 'SelectAndPro'\n}\n\nexport type FastTrackQuote = {\n  __typename?: 'FastTrackQuote';\n  source: FieldWrapper<Scalars['String']>;\n  sourceId: FieldWrapper<Scalars['Int']>;\n  name: FieldWrapper<Scalars['String']>;\n  code: FieldWrapper<Scalars['String']>;\n  price: FieldWrapper<Scalars['Float']>;\n  currency: FieldWrapper<Scalars['String']>;\n  refundable: FieldWrapper<Scalars['Boolean']>;\n  terminal?: Maybe<FieldWrapper<Scalars['Int']>>;\n  images: Array<FieldWrapper<Scalars['String']>>;\n  logo?: Maybe<FieldWrapper<Scalars['String']>>;\n  description?: Maybe<FieldWrapper<Scalars['String']>>;\n  importantInfo?: Maybe<FieldWrapper<Scalars['String']>>;\n  tmcPreferred: FieldWrapper<Scalars['Boolean']>;\n  companyPreferred: FieldWrapper<Scalars['Boolean']>;\n  officePreferred: FieldWrapper<Scalars['Boolean']>;\n  tmcPreferredMessage?: Maybe<FieldWrapper<Scalars['String']>>;\n  companyPreferredMessage?: Maybe<FieldWrapper<Scalars['String']>>;\n  officePreferredMessage?: Maybe<FieldWrapper<Scalars['String']>>;\n  unavailable: FieldWrapper<Scalars['Boolean']>;\n  unavailableMessage?: Maybe<FieldWrapper<Scalars['String']>>;\n  co2PerPassenger: FieldWrapper<Scalars['Float']>;\n  co2PerItem: FieldWrapper<Scalars['Float']>;\n};\n\nexport type FastTrackResult = {\n  __typename?: 'FastTrackResult';\n  results: Array<FieldWrapper<FastTrackQuote>>;\n  errors: Array<FieldWrapper<SearchError>>;\n};\n\nexport type FlightAmount = {\n  __typename?: 'FlightAmount';\n  description: FieldWrapper<Scalars['String']>;\n  amount: FieldWrapper<Scalars['Float']>;\n  currency: FieldWrapper<Scalars['String']>;\n};\n\nexport enum FlightCabinClass {\n  Any = 'Any',\n  LiteEconomy = 'LiteEconomy',\n  Economy = 'Economy',\n  EconomyRestricted = 'EconomyRestricted',\n  EconomyNoBags = 'EconomyNoBags',\n  EconomyFlexi = 'EconomyFlexi',\n  PremiumEconomy = 'PremiumEconomy',\n  Business = 'Business',\n  PremiumBusiness = 'PremiumBusiness',\n  First = 'First',\n  PremiumFirst = 'PremiumFirst'\n}\n\nexport type FlightCarbonEmissions = {\n  __typename?: 'FlightCarbonEmissions';\n  amount?: Maybe<FieldWrapper<Scalars['Float']>>;\n  unit: FieldWrapper<Scalars['String']>;\n};\n\nexport type FlightCarrierDetail = {\n  __typename?: 'FlightCarrierDetail';\n  name?: Maybe<FieldWrapper<Scalars['String']>>;\n  alias?: Maybe<FieldWrapper<Scalars['String']>>;\n  callsign?: Maybe<FieldWrapper<Scalars['String']>>;\n  iata?: Maybe<FieldWrapper<Scalars['String']>>;\n  icao?: Maybe<FieldWrapper<Scalars['String']>>;\n  logo?: Maybe<FieldWrapper<Scalars['String']>>;\n  banner?: Maybe<FieldWrapper<Scalars['String']>>;\n  popularity?: Maybe<FieldWrapper<Scalars['Int']>>;\n};\n\nexport type FlightFareTotal = {\n  __typename?: 'FlightFareTotal';\n  price: FieldWrapper<Scalars['Float']>;\n  tax?: Maybe<FieldWrapper<Scalars['Float']>>;\n  discount?: Maybe<FieldWrapper<Scalars['Float']>>;\n  currency: FieldWrapper<CurrencyCode>;\n};\n\nexport type FlightItinerary = {\n  __typename?: 'FlightItinerary';\n  uid: FieldWrapper<Scalars['Int']>;\n  passengerCount: FieldWrapper<Scalars['Int']>;\n  outboundFlights: Array<FieldWrapper<FlightJourney>>;\n  inboundFlights?: Maybe<Array<Maybe<FieldWrapper<FlightJourney>>>>;\n  outboundTotalDuration: FieldWrapper<Scalars['Int']>;\n  outboundCarbonEmissions?: Maybe<FieldWrapper<FlightCarbonEmissions>>;\n  inboundTotalDuration?: Maybe<FieldWrapper<Scalars['Int']>>;\n  inboundCarbonEmissions?: Maybe<FieldWrapper<FlightCarbonEmissions>>;\n  taxes?: Maybe<Array<Maybe<FieldWrapper<FlightAmount>>>>;\n  discounts?: Maybe<Array<Maybe<FieldWrapper<FlightAmount>>>>;\n  total: FieldWrapper<FlightFareTotal>;\n  fareConditions?: Maybe<FieldWrapper<FareConditions>>;\n  baggageAllowance?: Maybe<Array<Maybe<FieldWrapper<BaggageAllowance>>>>;\n  additional?: Maybe<FieldWrapper<Scalars['JSON']>>;\n  source: FieldWrapper<Scalars['String']>;\n  sourceId: FieldWrapper<Scalars['Int']>;\n  version: FieldWrapper<Scalars['String']>;\n  tmcPreferred: FieldWrapper<Scalars['Boolean']>;\n  companyPreferred: FieldWrapper<Scalars['Boolean']>;\n  officePreferred: FieldWrapper<Scalars['Boolean']>;\n  tmcPreferredMessage?: Maybe<FieldWrapper<Scalars['String']>>;\n  companyPreferredMessage?: Maybe<FieldWrapper<Scalars['String']>>;\n  officePreferredMessage?: Maybe<FieldWrapper<Scalars['String']>>;\n  unavailable: FieldWrapper<Scalars['Boolean']>;\n  unavailableMessage?: Maybe<FieldWrapper<Scalars['String']>>;\n  co2PerItem: FieldWrapper<Scalars['Float']>;\n  co2PerPassenger: FieldWrapper<Scalars['Float']>;\n};\n\nexport type FlightJourney = {\n  __typename?: 'FlightJourney';\n  fareInfo?: Maybe<FieldWrapper<FlightSpecialFareInfo>>;\n  originAirport: FieldWrapper<Scalars['String']>;\n  originTerminal?: Maybe<FieldWrapper<Scalars['String']>>;\n  originAirportName?: Maybe<FieldWrapper<Scalars['String']>>;\n  originAirportDetail: FieldWrapper<AirportDetail>;\n  destinationAirport: FieldWrapper<Scalars['String']>;\n  destinationTerminal?: Maybe<FieldWrapper<Scalars['String']>>;\n  destinationAirportName?: Maybe<FieldWrapper<Scalars['String']>>;\n  destinationAirportDetail: FieldWrapper<AirportDetail>;\n  dateTimeDeparting: FieldWrapper<Scalars['String']>;\n  dateTimeDepartingUTC: FieldWrapper<Scalars['String']>;\n  dateTimeArriving: FieldWrapper<Scalars['String']>;\n  dateTimeArrivingUTC: FieldWrapper<Scalars['String']>;\n  marketingCarrier: FieldWrapper<Scalars['String']>;\n  marketingCarrierName?: Maybe<FieldWrapper<Scalars['String']>>;\n  marketingCarrierDetail: FieldWrapper<FlightCarrierDetail>;\n  marketingFlightNumber: FieldWrapper<Scalars['String']>;\n  operatingCarrier: FieldWrapper<Scalars['String']>;\n  operatingCarrierName?: Maybe<FieldWrapper<Scalars['String']>>;\n  operatingCarrierDetail: FieldWrapper<FlightCarrierDetail>;\n  operatingFlightNumber: FieldWrapper<Scalars['String']>;\n  equipmentCode: FieldWrapper<Scalars['String']>;\n  equipmentName: FieldWrapper<Scalars['String']>;\n  totalDuration: FieldWrapper<Scalars['Int']>;\n  seatsAvailable?: Maybe<FieldWrapper<Scalars['Int']>>;\n  cabinCode?: Maybe<FieldWrapper<Scalars['String']>>;\n  cabinClass?: Maybe<FieldWrapper<Scalars['String']>>;\n  marketingNames?: Maybe<Array<Maybe<FieldWrapper<Scalars['String']>>>>;\n  fareConditions: FieldWrapper<FareConditions>;\n  vendorCode?: Maybe<FieldWrapper<Scalars['String']>>;\n  stops?: Maybe<FieldWrapper<Scalars['String']>>;\n  bookingCode?: Maybe<FieldWrapper<Scalars['String']>>;\n  marriageGroup?: Maybe<FieldWrapper<Scalars['Boolean']>>;\n  fareBasisCode?: Maybe<FieldWrapper<Scalars['String']>>;\n  additional?: Maybe<FieldWrapper<Scalars['JSON']>>;\n};\n\nexport type FlightPassengerObject = {\n  type: FlightPassengerType;\n  firstName?: Maybe<Scalars['String']>;\n  middleName?: Maybe<Scalars['String']>;\n  surname?: Maybe<Scalars['String']>;\n  dob?: Maybe<Scalars['Date']>;\n};\n\nexport enum FlightPassengerType {\n  Infant = 'Infant',\n  Child = 'Child',\n  Adult = 'Adult',\n  Senior = 'Senior'\n}\n\nexport type FlightRevalidateResponse = {\n  __typename?: 'FlightRevalidateResponse';\n  valid: FieldWrapper<Scalars['Boolean']>;\n  available: FieldWrapper<Scalars['Boolean']>;\n  price?: Maybe<FieldWrapper<Scalars['Float']>>;\n  priceDifference?: Maybe<FieldWrapper<Scalars['Float']>>;\n  currency?: Maybe<FieldWrapper<Scalars['String']>>;\n};\n\nexport type FlightSearchResult = {\n  __typename?: 'FlightSearchResult';\n  results: Array<FieldWrapper<SearchResult>>;\n  errors: Array<FieldWrapper<SearchError>>;\n};\n\nexport type FlightSearchResultV2 = {\n  __typename?: 'FlightSearchResultV2';\n  results: FieldWrapper<FeFlightSearchResults>;\n  errors: Array<FieldWrapper<SearchError>>;\n};\n\nexport type FlightSeatMapAircraft = {\n  __typename?: 'FlightSeatMapAircraft';\n  carrier: FieldWrapper<Scalars['String']>;\n  number: FieldWrapper<Scalars['String']>;\n  type?: Maybe<FieldWrapper<Scalars['String']>>;\n};\n\nexport type FlightSeatMapResponse = {\n  __typename?: 'FlightSeatMapResponse';\n  aircraft: FieldWrapper<FlightSeatMapAircraft>;\n  seats: Array<FieldWrapper<FlightSeatMapSeats>>;\n  source: FieldWrapper<Scalars['String']>;\n  sourceId: FieldWrapper<Scalars['Int']>;\n};\n\nexport type FlightSeatMapResult = {\n  __typename?: 'FlightSeatMapResult';\n  results: Array<FieldWrapper<FlightSeatMapResponse>>;\n  errors: Array<FieldWrapper<SearchError>>;\n};\n\nexport type FlightSeatMapSeatAttributes = {\n  __typename?: 'FlightSeatMapSeatAttributes';\n  code: FieldWrapper<Scalars['String']>;\n  description: FieldWrapper<Scalars['String']>;\n};\n\nexport type FlightSeatMapSeats = {\n  __typename?: 'FlightSeatMapSeats';\n  row: FieldWrapper<Scalars['String']>;\n  column: FieldWrapper<Scalars['String']>;\n  attributes: Array<FieldWrapper<FlightSeatMapSeatAttributes>>;\n  price?: Maybe<FieldWrapper<Scalars['Float']>>;\n  currency?: Maybe<FieldWrapper<Scalars['String']>>;\n};\n\nexport type FlightSpecialFareInfo = {\n  __typename?: 'FlightSpecialFareInfo';\n  title: FieldWrapper<Scalars['String']>;\n  type: FieldWrapper<Scalars['String']>;\n  code?: Maybe<FieldWrapper<Scalars['String']>>;\n  supplierCode?: Maybe<FieldWrapper<Scalars['String']>>;\n};\n\nexport type GeoCoordinates = {\n  __typename?: 'GeoCoordinates';\n  latitude?: Maybe<FieldWrapper<Scalars['Float']>>;\n  longitude?: Maybe<FieldWrapper<Scalars['Float']>>;\n  altitude?: Maybe<FieldWrapper<Scalars['Float']>>;\n};\n\nexport type GroupFlights = {\n  __typename?: 'GroupFlights';\n  referenceID: FieldWrapper<Scalars['Int']>;\n  flightID: FieldWrapper<Scalars['String']>;\n  boundIndicator: FieldWrapper<Scalars['Int']>;\n  minPrice: FieldWrapper<Scalars['Float']>;\n  maxPrice: FieldWrapper<Scalars['Float']>;\n  flights: FieldWrapper<MatchingFlights>;\n};\n\nexport type HotelAddress = {\n  __typename?: 'HotelAddress';\n  addressLine1?: Maybe<FieldWrapper<Scalars['String']>>;\n  addressLine2?: Maybe<FieldWrapper<Scalars['String']>>;\n  addressLine3?: Maybe<FieldWrapper<Scalars['String']>>;\n  city?: Maybe<FieldWrapper<Scalars['String']>>;\n  postOrZipCode?: Maybe<FieldWrapper<Scalars['String']>>;\n  countryCode?: Maybe<FieldWrapper<Scalars['String']>>;\n  telephone?: Maybe<FieldWrapper<Scalars['String']>>;\n  facsimile?: Maybe<FieldWrapper<Scalars['String']>>;\n};\n\nexport type HotelAvailability = {\n  __typename?: 'HotelAvailability';\n  hotelId: FieldWrapper<Scalars['String']>;\n  imageUrl: FieldWrapper<Scalars['String']>;\n  rooms?: Maybe<Array<Maybe<FieldWrapper<HotelRoom>>>>;\n  prpn?: Maybe<FieldWrapper<Scalars['Float']>>;\n  currencyCode?: Maybe<FieldWrapper<Scalars['String']>>;\n  isBusy?: Maybe<FieldWrapper<Scalars['Boolean']>>;\n  source: FieldWrapper<Scalars['String']>;\n  version: FieldWrapper<Scalars['String']>;\n};\n\nexport type HotelAvailabilityResult = {\n  __typename?: 'HotelAvailabilityResult';\n  results?: Maybe<FieldWrapper<HotelAvailability>>;\n  errors: Array<FieldWrapper<SearchError>>;\n};\n\nexport type HotelCard = {\n  __typename?: 'HotelCard';\n  id: FieldWrapper<Scalars['String']>;\n  name: FieldWrapper<Scalars['String']>;\n};\n\nexport type HotelConversion = {\n  __typename?: 'HotelConversion';\n  rate: FieldWrapper<Scalars['Float']>;\n  localCode: FieldWrapper<Scalars['String']>;\n  localTotal: FieldWrapper<Scalars['Float']>;\n  convertedCode: FieldWrapper<Scalars['String']>;\n  convertedTotal: FieldWrapper<Scalars['Float']>;\n};\n\nexport type HotelDeposit = {\n  __typename?: 'HotelDeposit';\n  amount: FieldWrapper<Scalars['Float']>;\n  policy?: Maybe<FieldWrapper<Scalars['String']>>;\n  required: FieldWrapper<Scalars['Boolean']>;\n};\n\nexport type HotelItinerary = {\n  __typename?: 'HotelItinerary';\n  id: FieldWrapper<Scalars['String']>;\n  name: FieldWrapper<Scalars['String']>;\n  imageUrl: FieldWrapper<Scalars['String']>;\n  group: FieldWrapper<Scalars['String']>;\n  location: FieldWrapper<HotelLocation>;\n  address: FieldWrapper<HotelAddress>;\n  transports?: Maybe<Array<Maybe<FieldWrapper<HotelTransport>>>>;\n  preferred: FieldWrapper<HotelPreferred>;\n  tags?: Maybe<Array<Maybe<FieldWrapper<HotelTag>>>>;\n  availableRates?: Maybe<FieldWrapper<HotelAvailability>>;\n  stars?: Maybe<FieldWrapper<Scalars['Float']>>;\n  co2PerPassenger: FieldWrapper<Scalars['Float']>;\n  co2PerItem: FieldWrapper<Scalars['Float']>;\n  source: FieldWrapper<Scalars['String']>;\n  sourceId: FieldWrapper<Scalars['Int']>;\n  version: FieldWrapper<Scalars['String']>;\n  tmcPreferred: FieldWrapper<Scalars['Boolean']>;\n  companyPreferred: FieldWrapper<Scalars['Boolean']>;\n  officePreferred: FieldWrapper<Scalars['Boolean']>;\n  tmcPreferredMessage?: Maybe<FieldWrapper<Scalars['String']>>;\n  companyPreferredMessage?: Maybe<FieldWrapper<Scalars['String']>>;\n  officePreferredMessage?: Maybe<FieldWrapper<Scalars['String']>>;\n  unavailable: FieldWrapper<Scalars['Boolean']>;\n  unavailableMessage?: Maybe<FieldWrapper<Scalars['String']>>;\n};\n\nexport type HotelLocation = {\n  __typename?: 'HotelLocation';\n  distance: FieldWrapper<Scalars['Float']>;\n  distanceType: FieldWrapper<Scalars['String']>;\n  longitude: FieldWrapper<Scalars['Float']>;\n  latitude: FieldWrapper<Scalars['Float']>;\n};\n\nexport type HotelMultiAvailabilityResult = {\n  __typename?: 'HotelMultiAvailabilityResult';\n  results?: Maybe<Array<Maybe<FieldWrapper<HotelAvailability>>>>;\n  errors: Array<FieldWrapper<SearchError>>;\n};\n\nexport type HotelNight = {\n  __typename?: 'HotelNight';\n  night: FieldWrapper<Scalars['Int']>;\n  rate: FieldWrapper<Scalars['Float']>;\n  info?: Maybe<FieldWrapper<Scalars['String']>>;\n  date: FieldWrapper<Scalars['Date']>;\n};\n\nexport type HotelPaymentType = {\n  __typename?: 'HotelPaymentType';\n  type: FieldWrapper<Scalars['String']>;\n  name?: Maybe<FieldWrapper<Scalars['String']>>;\n};\n\nexport type HotelPolicy = {\n  __typename?: 'HotelPolicy';\n  cancellation?: Maybe<FieldWrapper<Scalars['String']>>;\n  deposit?: Maybe<FieldWrapper<Scalars['String']>>;\n  disabledAccess?: Maybe<FieldWrapper<Scalars['Boolean']>>;\n  general?: Maybe<FieldWrapper<Scalars['String']>>;\n  guarantee?: Maybe<FieldWrapper<Scalars['String']>>;\n  refundAvailable?: Maybe<FieldWrapper<Scalars['Boolean']>>;\n};\n\nexport type HotelPreferred = {\n  __typename?: 'HotelPreferred';\n  client: FieldWrapper<Scalars['Boolean']>;\n  consumer: FieldWrapper<Scalars['Boolean']>;\n};\n\nexport type HotelRoom = {\n  __typename?: 'HotelRoom';\n  roomId: FieldWrapper<Scalars['String']>;\n  roomType?: Maybe<FieldWrapper<Scalars['String']>>;\n  roomDescription?: Maybe<FieldWrapper<Scalars['String']>>;\n  rateCode?: Maybe<FieldWrapper<Scalars['String']>>;\n  rateDescription?: Maybe<FieldWrapper<Scalars['String']>>;\n  total: FieldWrapper<Scalars['Float']>;\n  currencyCode: FieldWrapper<Scalars['String']>;\n  currencyConversion?: Maybe<FieldWrapper<HotelConversion>>;\n  deposit?: Maybe<FieldWrapper<HotelDeposit>>;\n  nights: Array<FieldWrapper<HotelNight>>;\n  policies: FieldWrapper<HotelPolicy>;\n  tax: FieldWrapper<HotelTax>;\n  acceptedCards?: Maybe<Array<Maybe<FieldWrapper<HotelCard>>>>;\n  paymentTypes?: Maybe<Array<Maybe<FieldWrapper<HotelPaymentType>>>>;\n};\n\nexport type HotelSearchResult = {\n  __typename?: 'HotelSearchResult';\n  results?: Maybe<Array<Maybe<FieldWrapper<HotelItinerary>>>>;\n  errors: Array<FieldWrapper<SearchError>>;\n};\n\nexport type HotelTag = {\n  __typename?: 'HotelTag';\n  name: FieldWrapper<Scalars['String']>;\n  display?: Maybe<FieldWrapper<Scalars['String']>>;\n  type: FieldWrapper<Scalars['String']>;\n  icon: FieldWrapper<Scalars['String']>;\n};\n\nexport type HotelTax = {\n  __typename?: 'HotelTax';\n  included: FieldWrapper<Scalars['Boolean']>;\n  rate: FieldWrapper<Scalars['Float']>;\n};\n\nexport type HotelTransport = {\n  __typename?: 'HotelTransport';\n  type: FieldWrapper<Scalars['String']>;\n  name: FieldWrapper<Scalars['String']>;\n  code?: Maybe<FieldWrapper<Scalars['String']>>;\n  distance: FieldWrapper<Scalars['Float']>;\n  distanceType: FieldWrapper<Scalars['String']>;\n  longitude?: Maybe<FieldWrapper<Scalars['Float']>>;\n  latitude?: Maybe<FieldWrapper<Scalars['Float']>>;\n};\n\nexport enum IrlClass {\n  All = 'All',\n  First = 'First',\n  Standard = 'Standard'\n}\n\nexport type IrlDynamicCondition = {\n  __typename?: 'IRLDynamicCondition';\n  name?: Maybe<FieldWrapper<Scalars['String']>>;\n  description?: Maybe<FieldWrapper<Scalars['String']>>;\n};\n\nexport type IrlIdentifiers = {\n  __typename?: 'IRLIdentifiers';\n  transactionIdentifier?: Maybe<FieldWrapper<Scalars['String']>>;\n  signature?: Maybe<FieldWrapper<Scalars['String']>>;\n  journeyIdentifier?: Maybe<FieldWrapper<Scalars['String']>>;\n  provider?: Maybe<FieldWrapper<Scalars['String']>>;\n  fareIdentifier?: Maybe<FieldWrapper<Scalars['String']>>;\n  direction?: Maybe<FieldWrapper<Scalars['String']>>;\n  allowedWith: Array<FieldWrapper<IrlIdentifiers>>;\n  singleOrReturn?: Maybe<FieldWrapper<Scalars['String']>>;\n  bookingRef?: Maybe<FieldWrapper<Scalars['String']>>;\n};\n\nexport type IrlJourneyOption = {\n  __typename?: 'IRLJourneyOption';\n  identifiers?: Maybe<FieldWrapper<IrlIdentifiers>>;\n  travellers?: Maybe<Array<FieldWrapper<IrlTraveller>>>;\n  from?: Maybe<FieldWrapper<Scalars['String']>>;\n  fromCode?: Maybe<FieldWrapper<Scalars['String']>>;\n  to?: Maybe<FieldWrapper<Scalars['String']>>;\n  toCode?: Maybe<FieldWrapper<Scalars['String']>>;\n  departDateTime?: Maybe<FieldWrapper<Scalars['DateTime']>>;\n  arriveDateTime?: Maybe<FieldWrapper<Scalars['DateTime']>>;\n  changes?: Maybe<FieldWrapper<Scalars['String']>>;\n  segments?: Maybe<Array<FieldWrapper<IrlSegment>>>;\n  providers?: Maybe<Array<FieldWrapper<IrlProvider>>>;\n  unsellable?: Maybe<FieldWrapper<Scalars['String']>>;\n  ticketExtras?: Maybe<Array<FieldWrapper<IrlTicketExtra>>>;\n  plusBus?: Maybe<FieldWrapper<IrlPlusBus>>;\n};\n\nexport type IrlJourneyOptions = {\n  __typename?: 'IRLJourneyOptions';\n  source: FieldWrapper<Scalars['String']>;\n  sourceId: FieldWrapper<Scalars['Int']>;\n  outbound?: Maybe<Array<FieldWrapper<IrlJourneyOption>>>;\n  return?: Maybe<Array<FieldWrapper<IrlJourneyOption>>>;\n};\n\nexport enum IrlJourneyType {\n  ReturnJourney = 'ReturnJourney',\n  SingleJourney = 'SingleJourney'\n}\n\nexport type IrlPlusBus = {\n  __typename?: 'IRLPlusBus';\n  originPlusBusNLC?: Maybe<FieldWrapper<Scalars['String']>>;\n  originStationNLC?: Maybe<FieldWrapper<Scalars['String']>>;\n  destinationPlusBusNLC?: Maybe<FieldWrapper<Scalars['String']>>;\n  destinationStationNLC?: Maybe<FieldWrapper<Scalars['String']>>;\n};\n\nexport type IrlProvider = {\n  __typename?: 'IRLProvider';\n  providerId?: Maybe<FieldWrapper<Scalars['String']>>;\n  name?: Maybe<FieldWrapper<Scalars['String']>>;\n  cheapestTicket?: Maybe<FieldWrapper<IrlTicketOption>>;\n  ticketOptions?: Maybe<Array<Maybe<FieldWrapper<IrlTicketOption>>>>;\n  bookedTicket?: Maybe<FieldWrapper<IrlTicketOption>>;\n};\n\nexport type IrlSearchResult = {\n  __typename?: 'IRLSearchResult';\n  results: Array<FieldWrapper<IrlJourneyOptions>>;\n  errors: Array<FieldWrapper<SearchError>>;\n};\n\nexport type IrlSeat = {\n  __typename?: 'IRLSeat';\n  location?: Maybe<FieldWrapper<Scalars['String']>>;\n  coach?: Maybe<FieldWrapper<Scalars['String']>>;\n  number?: Maybe<FieldWrapper<Scalars['String']>>;\n  direction?: Maybe<FieldWrapper<Scalars['String']>>;\n  position?: Maybe<FieldWrapper<Scalars['String']>>;\n  deck?: Maybe<FieldWrapper<Scalars['String']>>;\n  seatType?: Maybe<FieldWrapper<Scalars['String']>>;\n  seatSelection?: Maybe<FieldWrapper<Scalars['String']>>;\n  facilities?: Maybe<Array<Maybe<FieldWrapper<Scalars['String']>>>>;\n  note: FieldWrapper<Scalars['String']>;\n};\n\nexport type IrlSeatPreferenceType = {\n  __typename?: 'IRLSeatPreferenceType';\n  name?: Maybe<FieldWrapper<Scalars['String']>>;\n  allowedValues?: Maybe<Array<Maybe<FieldWrapper<Scalars['String']>>>>;\n};\n\nexport type IrlSegment = {\n  __typename?: 'IRLSegment';\n  id?: Maybe<FieldWrapper<Scalars['String']>>;\n  operator?: Maybe<FieldWrapper<Scalars['String']>>;\n  depart?: Maybe<FieldWrapper<Scalars['String']>>;\n  departDateTime?: Maybe<FieldWrapper<Scalars['DateTime']>>;\n  arrive?: Maybe<FieldWrapper<Scalars['String']>>;\n  arriveDateTime?: Maybe<FieldWrapper<Scalars['DateTime']>>;\n  reservableStatus?: Maybe<FieldWrapper<Scalars['String']>>;\n  seatPreferenceTypes?: Maybe<Array<FieldWrapper<IrlSeatPreferenceType>>>;\n  seatPreferenceGroup?: Maybe<FieldWrapper<Scalars['String']>>;\n  seats?: Maybe<Array<FieldWrapper<IrlSeat>>>;\n};\n\nexport enum IrlSupplier {\n  Renfe = 'Renfe',\n  BeNe = 'BeNe',\n  Ntv = 'Ntv'\n}\n\nexport type IrlSupplierStation = {\n  __typename?: 'IRLSupplierStation';\n  id: FieldWrapper<Scalars['ID']>;\n  name: FieldWrapper<Scalars['String']>;\n  supplier: FieldWrapper<Scalars['String']>;\n  stationCode: FieldWrapper<Scalars['String']>;\n  nlcCode?: Maybe<FieldWrapper<Scalars['Int']>>;\n  trainlineCode?: Maybe<FieldWrapper<Scalars['String']>>;\n  trainlineUniqueCode?: Maybe<FieldWrapper<Scalars['String']>>;\n  locationDetails?: Maybe<FieldWrapper<LocationDetail>>;\n};\n\nexport type IrlTextValuePair = {\n  __typename?: 'IRLTextValuePair';\n  text: FieldWrapper<Scalars['String']>;\n  value?: Maybe<FieldWrapper<Scalars['String']>>;\n};\n\nexport type IrlTicket = {\n  __typename?: 'IRLTicket';\n  price?: Maybe<FieldWrapper<Scalars['Float']>>;\n  type?: Maybe<FieldWrapper<Scalars['String']>>;\n  route?: Maybe<FieldWrapper<Scalars['String']>>;\n  segments?: Maybe<Array<FieldWrapper<IrlSegment>>>;\n  numChildren?: Maybe<FieldWrapper<Scalars['Int']>>;\n  numAdults?: Maybe<FieldWrapper<Scalars['Int']>>;\n};\n\nexport type IrlTicketExtra = {\n  __typename?: 'IRLTicketExtra';\n  identifiers?: Maybe<FieldWrapper<IrlTicketExtraIdentifiers>>;\n  type?: Maybe<FieldWrapper<Scalars['String']>>;\n  location?: Maybe<FieldWrapper<Scalars['String']>>;\n  date?: Maybe<FieldWrapper<Scalars['Date']>>;\n  description?: Maybe<FieldWrapper<Scalars['String']>>;\n  amount?: Maybe<FieldWrapper<Scalars['Float']>>;\n  adultAmount?: Maybe<FieldWrapper<Scalars['Float']>>;\n  childAmount?: Maybe<FieldWrapper<Scalars['Float']>>;\n  currency?: Maybe<FieldWrapper<Scalars['String']>>;\n};\n\nexport type IrlTicketExtraIdentifiers = {\n  __typename?: 'IRLTicketExtraIdentifiers';\n  type?: Maybe<FieldWrapper<Scalars['String']>>;\n  location?: Maybe<FieldWrapper<Scalars['String']>>;\n  date?: Maybe<FieldWrapper<Scalars['Date']>>;\n  journeyId?: Maybe<FieldWrapper<Scalars['String']>>;\n  isOrigin?: Maybe<FieldWrapper<Scalars['Boolean']>>;\n};\n\nexport type IrlTicketOption = {\n  __typename?: 'IRLTicketOption';\n  identifiers?: Maybe<FieldWrapper<IrlIdentifiers>>;\n  type?: Maybe<FieldWrapper<Scalars['String']>>;\n  class?: Maybe<FieldWrapper<Scalars['String']>>;\n  singleOrReturn?: Maybe<FieldWrapper<Scalars['String']>>;\n  price?: Maybe<FieldWrapper<Scalars['Float']>>;\n  reservableStatus?: Maybe<FieldWrapper<Scalars['String']>>;\n  currency?: Maybe<FieldWrapper<Scalars['String']>>;\n  route?: Maybe<FieldWrapper<Scalars['String']>>;\n  routeCode?: Maybe<FieldWrapper<Scalars['String']>>;\n  tickets?: Maybe<Array<Maybe<FieldWrapper<IrlTicket>>>>;\n};\n\nexport type IrlTraveller = {\n  __typename?: 'IRLTraveller';\n  status?: Maybe<FieldWrapper<IrlTravellerStatus>>;\n  id?: Maybe<FieldWrapper<Scalars['String']>>;\n  dob?: Maybe<FieldWrapper<Scalars['Date']>>;\n  railcard?: Maybe<FieldWrapper<Scalars['String']>>;\n  givenName?: Maybe<FieldWrapper<Scalars['String']>>;\n  surname?: Maybe<FieldWrapper<Scalars['String']>>;\n  nameTitle?: Maybe<FieldWrapper<Scalars['String']>>;\n  contactInfo?: Maybe<FieldWrapper<Scalars['String']>>;\n  deliveryEmailAddress?: Maybe<FieldWrapper<Scalars['String']>>;\n  fare?: Maybe<FieldWrapper<Scalars['String']>>;\n};\n\nexport enum IrlTravellerStatus {\n  Placeholder = 'placeholder',\n  Complete = 'complete'\n}\n\nexport type InputCarHireDepot = {\n  vendorCode?: Maybe<Scalars['String']>;\n  pickupLocationCode?: Maybe<Scalars['String']>;\n  pickupExtendedLocationCode?: Maybe<Scalars['String']>;\n  dropOffLocationCode?: Maybe<Scalars['String']>;\n  dropOffExtendedLocationCode?: Maybe<Scalars['String']>;\n};\n\nexport type InputFlightJourney = {\n  fareInfo?: Maybe<Scalars['JSON']>;\n  originAirport: Scalars['String'];\n  originTerminal?: Maybe<Scalars['String']>;\n  destinationAirport: Scalars['String'];\n  destinationTerminal?: Maybe<Scalars['String']>;\n  dateTimeDeparting: Scalars['String'];\n  dateTimeDepartingUTC: Scalars['String'];\n  dateTimeArriving: Scalars['String'];\n  dateTimeArrivingUTC: Scalars['String'];\n  marketingCarrier: Scalars['String'];\n  marketingCarrierName?: Maybe<Scalars['String']>;\n  marketingFlightNumber: Scalars['String'];\n  operatingCarrier: Scalars['String'];\n  operatingCarrierName?: Maybe<Scalars['String']>;\n  operatingFlightNumber: Scalars['String'];\n  equipmentCode: Scalars['String'];\n  equipmentName: Scalars['String'];\n  totalDuration: Scalars['Int'];\n  seatsAvailable?: Maybe<Scalars['Int']>;\n  cabinCode?: Maybe<Scalars['String']>;\n  cabinClass?: Maybe<Scalars['String']>;\n  marketingNames?: Maybe<Array<Maybe<Scalars['String']>>>;\n  fareConditions: Scalars['JSON'];\n  vendorCode?: Maybe<Scalars['String']>;\n  stops?: Maybe<Scalars['String']>;\n  bookingCode?: Maybe<Scalars['String']>;\n  marriageGroup?: Maybe<Scalars['Boolean']>;\n  fareBasisCode?: Maybe<Scalars['String']>;\n  additional?: Maybe<Scalars['JSON']>;\n};\n\nexport type ItinerarySummary = {\n  __typename?: 'ItinerarySummary';\n  order: FieldWrapper<Scalars['Int']>;\n  origin: FieldWrapper<Scalars['String']>;\n  destination: FieldWrapper<Scalars['String']>;\n  results: Array<FieldWrapper<FlightItinerary>>;\n  minPrice: FieldWrapper<Scalars['Float']>;\n  maxPrice: FieldWrapper<Scalars['Float']>;\n};\n\n\nexport type Language = {\n  __typename?: 'Language';\n  id: FieldWrapper<Scalars['ID']>;\n  name: FieldWrapper<Scalars['String']>;\n  isoCode: FieldWrapper<Scalars['String']>;\n};\n\nexport type LiveDepBoardResult = {\n  __typename?: 'LiveDepBoardResult';\n  services?: Maybe<Array<Maybe<FieldWrapper<DepartureBoardService>>>>;\n};\n\nexport type Location = {\n  __typename?: 'Location';\n  locationName?: Maybe<FieldWrapper<Scalars['String']>>;\n  tiploc?: Maybe<FieldWrapper<Scalars['String']>>;\n  crs?: Maybe<FieldWrapper<Scalars['String']>>;\n};\n\nexport type LocationDetail = {\n  __typename?: 'LocationDetail';\n  continent?: Maybe<FieldWrapper<Scalars['String']>>;\n  country?: Maybe<FieldWrapper<Scalars['String']>>;\n  countryCode?: Maybe<FieldWrapper<Scalars['String']>>;\n  state?: Maybe<FieldWrapper<Scalars['String']>>;\n  city?: Maybe<FieldWrapper<Scalars['String']>>;\n  coordinates?: Maybe<FieldWrapper<GeoCoordinates>>;\n  postcode?: Maybe<FieldWrapper<Scalars['String']>>;\n  road?: Maybe<FieldWrapper<Scalars['String']>>;\n  gridReference?: Maybe<FieldWrapper<Scalars['String']>>;\n  northing?: Maybe<FieldWrapper<Scalars['String']>>;\n  easting?: Maybe<FieldWrapper<Scalars['String']>>;\n};\n\nexport type LoungeLocation = {\n  __typename?: 'LoungeLocation';\n  code: FieldWrapper<Scalars['String']>;\n  name: FieldWrapper<Scalars['String']>;\n  airport: FieldWrapper<Scalars['String']>;\n  terminal?: Maybe<FieldWrapper<Scalars['Int']>>;\n  address?: Maybe<FieldWrapper<Scalars['String']>>;\n  telephone?: Maybe<FieldWrapper<Scalars['String']>>;\n  fax?: Maybe<FieldWrapper<Scalars['String']>>;\n  directions?: Maybe<FieldWrapper<Scalars['String']>>;\n  introduction?: Maybe<FieldWrapper<Scalars['String']>>;\n  logo?: Maybe<FieldWrapper<Scalars['String']>>;\n  mobileImage?: Maybe<FieldWrapper<Scalars['String']>>;\n  furtherImages?: Maybe<Array<Maybe<FieldWrapper<Scalars['String']>>>>;\n  adultAge?: Maybe<FieldWrapper<Scalars['Int']>>;\n  childAge?: Maybe<FieldWrapper<Scalars['Int']>>;\n  infantAge?: Maybe<FieldWrapper<Scalars['Int']>>;\n  landside: FieldWrapper<Scalars['Boolean']>;\n  airside: FieldWrapper<Scalars['Boolean']>;\n  facilities?: Maybe<Array<Maybe<FieldWrapper<Scalars['String']>>>>;\n  openTime?: Maybe<FieldWrapper<Scalars['String']>>;\n  closeTime?: Maybe<FieldWrapper<Scalars['String']>>;\n  wifi?: Maybe<FieldWrapper<Scalars['Boolean']>>;\n  tv?: Maybe<FieldWrapper<Scalars['Boolean']>>;\n  snacks?: Maybe<FieldWrapper<Scalars['Boolean']>>;\n  phone?: Maybe<FieldWrapper<Scalars['Boolean']>>;\n  internet?: Maybe<FieldWrapper<Scalars['Boolean']>>;\n  childrenAllowed?: Maybe<FieldWrapper<Scalars['Boolean']>>;\n  disabledAccess?: Maybe<FieldWrapper<Scalars['Boolean']>>;\n  drinks?: Maybe<FieldWrapper<Scalars['Boolean']>>;\n  freeDrinks?: Maybe<FieldWrapper<Scalars['Boolean']>>;\n  freeFood?: Maybe<FieldWrapper<Scalars['Boolean']>>;\n  smokingPermitted?: Maybe<FieldWrapper<Scalars['Boolean']>>;\n  magazines?: Maybe<FieldWrapper<Scalars['Boolean']>>;\n  includedDrinks?: Maybe<Array<Maybe<FieldWrapper<Scalars['String']>>>>;\n  menuFood?: Maybe<FieldWrapper<Scalars['String']>>;\n  menuDrinks?: Maybe<FieldWrapper<Scalars['String']>>;\n  menuExtras?: Maybe<FieldWrapper<Scalars['String']>>;\n  whatsIncludedDrinks?: Maybe<FieldWrapper<Scalars['String']>>;\n  whatsIncludedExtras?: Maybe<FieldWrapper<Scalars['String']>>;\n  whatsIncludedFood?: Maybe<FieldWrapper<Scalars['String']>>;\n  groupInfo?: Maybe<FieldWrapper<Scalars['String']>>;\n  checkInInfo?: Maybe<FieldWrapper<Scalars['String']>>;\n  dressCode?: Maybe<FieldWrapper<Scalars['String']>>;\n  facilitiesInfo?: Maybe<FieldWrapper<Scalars['String']>>;\n  foodAndBeverage?: Maybe<FieldWrapper<Scalars['String']>>;\n  cancellationInfo?: Maybe<FieldWrapper<Scalars['String']>>;\n  amendmentsInfo?: Maybe<FieldWrapper<Scalars['String']>>;\n  misc?: Maybe<FieldWrapper<Scalars['JSON']>>;\n};\n\nexport type LoungeQuote = {\n  __typename?: 'LoungeQuote';\n  source: FieldWrapper<Scalars['String']>;\n  sourceId: FieldWrapper<Scalars['Int']>;\n  name: FieldWrapper<Scalars['String']>;\n  code: FieldWrapper<Scalars['String']>;\n  price: FieldWrapper<Scalars['Float']>;\n  currency: FieldWrapper<CurrencyCode>;\n  lounge: FieldWrapper<LoungeLocation>;\n  tmcPreferred: FieldWrapper<Scalars['Boolean']>;\n  companyPreferred: FieldWrapper<Scalars['Boolean']>;\n  officePreferred: FieldWrapper<Scalars['Boolean']>;\n  tmcPreferredMessage?: Maybe<FieldWrapper<Scalars['String']>>;\n  companyPreferredMessage?: Maybe<FieldWrapper<Scalars['String']>>;\n  officePreferredMessage?: Maybe<FieldWrapper<Scalars['String']>>;\n  unavailable: FieldWrapper<Scalars['Boolean']>;\n  unavailableMessage?: Maybe<FieldWrapper<Scalars['String']>>;\n  co2PerPassenger: FieldWrapper<Scalars['Float']>;\n  co2PerItem: FieldWrapper<Scalars['Float']>;\n};\n\nexport type LoungeSearchResult = {\n  __typename?: 'LoungeSearchResult';\n  results: Array<FieldWrapper<LoungeQuote>>;\n  errors: Array<FieldWrapper<SearchError>>;\n};\n\nexport type ManagementInfo = {\n  __typename?: 'ManagementInfo';\n  id: FieldWrapper<Scalars['ID']>;\n  dbId: FieldWrapper<Scalars['Int']>;\n  name: FieldWrapper<Scalars['String']>;\n  description?: Maybe<FieldWrapper<Scalars['String']>>;\n  handoff: FieldWrapper<Scalars['String']>;\n  valueMask?: Maybe<FieldWrapper<Scalars['String']>>;\n  service: FieldWrapper<Service>;\n  uiPresentation: FieldWrapper<UiPresentation>;\n  mandatory: FieldWrapper<Scalars['Boolean']>;\n  perPassenger: FieldWrapper<Scalars['Boolean']>;\n  perBooking: FieldWrapper<Scalars['Boolean']>;\n  agentOnly: FieldWrapper<Scalars['Boolean']>;\n  createdAt: FieldWrapper<Scalars['DateTime']>;\n  updatedAt: FieldWrapper<Scalars['DateTime']>;\n  fixed: FieldWrapper<Scalars['Boolean']>;\n  fixedValue?: Maybe<FieldWrapper<ManagementInfoValue>>;\n  defaultValue?: Maybe<FieldWrapper<ManagementInfoValue>>;\n  values: Array<FieldWrapper<ManagementInfoValue>>;\n  group?: Maybe<Array<Maybe<FieldWrapper<Scalars['String']>>>>;\n  selectedValues: Array<FieldWrapper<SelectedManagementInfoValue>>;\n};\n\nexport type ManagementInfoValue = {\n  __typename?: 'ManagementInfoValue';\n  id: FieldWrapper<Scalars['ID']>;\n  label: FieldWrapper<Scalars['String']>;\n  value: FieldWrapper<Scalars['String']>;\n  default: FieldWrapper<Scalars['Boolean']>;\n  fixed: FieldWrapper<Scalars['Boolean']>;\n  agentOnly: FieldWrapper<Scalars['Boolean']>;\n};\n\nexport type MatchingFlights = {\n  __typename?: 'MatchingFlights';\n  LiteEconomy?: Maybe<Array<Maybe<FieldWrapper<Scalars['Int']>>>>;\n  EconomyRestricted?: Maybe<Array<Maybe<FieldWrapper<Scalars['Int']>>>>;\n  EconomyNoBags?: Maybe<Array<Maybe<FieldWrapper<Scalars['Int']>>>>;\n  EconomyFlexi?: Maybe<Array<Maybe<FieldWrapper<Scalars['Int']>>>>;\n  Economy?: Maybe<Array<Maybe<FieldWrapper<Scalars['Int']>>>>;\n  PremiumEconomy?: Maybe<Array<Maybe<FieldWrapper<Scalars['Int']>>>>;\n  Business?: Maybe<Array<Maybe<FieldWrapper<Scalars['Int']>>>>;\n  PremiumBusiness?: Maybe<Array<Maybe<FieldWrapper<Scalars['Int']>>>>;\n  First?: Maybe<Array<Maybe<FieldWrapper<Scalars['Int']>>>>;\n  PremiumFirst?: Maybe<Array<Maybe<FieldWrapper<Scalars['Int']>>>>;\n};\n\nexport type Message = {\n  __typename?: 'Message';\n  id: FieldWrapper<Scalars['ID']>;\n  name: FieldWrapper<Scalars['String']>;\n  description?: Maybe<FieldWrapper<Scalars['String']>>;\n  config: FieldWrapper<Scalars['JSON']>;\n  target: FieldWrapper<Scalars['String']>;\n  key: FieldWrapper<Scalars['String']>;\n  displayTarget: FieldWrapper<MessageTarget>;\n  agentOnly: FieldWrapper<Scalars['Boolean']>;\n  clickToConfirm: FieldWrapper<Scalars['Boolean']>;\n  validFrom?: Maybe<FieldWrapper<Scalars['DateTime']>>;\n  validTo?: Maybe<FieldWrapper<Scalars['DateTime']>>;\n};\n\nexport enum MessageTarget {\n  Login = 'LOGIN',\n  SearchForm = 'SEARCH_FORM',\n  Results = 'RESULTS',\n  MiForm = 'MI_FORM',\n  BasketBeforeConfirm = 'BASKET_BEFORE_CONFIRM',\n  Dashboard = 'DASHBOARD'\n}\n\nexport type Mutation = {\n  __typename?: 'Mutation';\n  saveUserAddress: FieldWrapper<Address>;\n  deleteUserAddress: FieldWrapper<Scalars['Boolean']>;\n  setAddressAsUserPrimary: FieldWrapper<Address>;\n  sendBasketForApproval: FieldWrapper<Basket>;\n  createBasket: FieldWrapper<Basket>;\n  deleteBasket: FieldWrapper<Scalars['Boolean']>;\n  updateBasketTitle: FieldWrapper<Basket>;\n  updateBasketNotes: FieldWrapper<Basket>;\n  addItemToBasket: FieldWrapper<Basket>;\n  removeItemFromBasket: FieldWrapper<Basket>;\n  removeItemsFromBasket: FieldWrapper<Basket>;\n  moveItemToADifferentBasket: FieldWrapper<Basket>;\n  addUsersToBasketItem: FieldWrapper<Basket>;\n  removeUserFromBasketItem: FieldWrapper<Basket>;\n  reopenBasket: FieldWrapper<Basket>;\n  setBasketItemLeadPassenger: FieldWrapper<Basket>;\n  bookBasket: FieldWrapper<Basket>;\n  cancelBooking: FieldWrapper<AfterCancellationInfo>;\n  confermaCreateCard: FieldWrapper<ConfermaCreateCardResult>;\n  confermaDeleteCard: FieldWrapper<Scalars['Boolean']>;\n  setBasketItemMIGroup: FieldWrapper<Basket>;\n  setMIDefaultValue: FieldWrapper<Scalars['Boolean']>;\n  setBasketItemMIValue: FieldWrapper<Basket>;\n  confirmMessage: FieldWrapper<Scalars['Boolean']>;\n  setBasketItemPaymentMethod: FieldWrapper<Basket>;\n  revalidateBasket: FieldWrapper<Basket>;\n  revalidateBasketItem: FieldWrapper<Basket>;\n  acceptNewPrice: FieldWrapper<Basket>;\n  saveFavouriteSearch: Array<FieldWrapper<Search>>;\n  saveRecentSearch: Array<FieldWrapper<Search>>;\n  deleteFavouriteSearch: FieldWrapper<Scalars['Boolean']>;\n  deleteRecentSearch: FieldWrapper<Scalars['Boolean']>;\n  setUserLanguage: FieldWrapper<User>;\n};\n\n\nexport type MutationSaveUserAddressArgs = {\n  description: Scalars['String'];\n  numberOrName?: Maybe<Scalars['String']>;\n  street?: Maybe<Scalars['String']>;\n  town?: Maybe<Scalars['String']>;\n  county?: Maybe<Scalars['String']>;\n  postcode?: Maybe<Scalars['String']>;\n  countryCode?: Maybe<Scalars['String']>;\n  userPrimary?: Maybe<Scalars['Boolean']>;\n};\n\n\nexport type MutationDeleteUserAddressArgs = {\n  id: Scalars['ID'];\n};\n\n\nexport type MutationSetAddressAsUserPrimaryArgs = {\n  id: Scalars['ID'];\n};\n\n\nexport type MutationSendBasketForApprovalArgs = {\n  basket: Scalars['ID'];\n};\n\n\nexport type MutationCreateBasketArgs = {\n  title?: Maybe<Scalars['String']>;\n};\n\n\nexport type MutationDeleteBasketArgs = {\n  id?: Maybe<Scalars['ID']>;\n  reference?: Maybe<Scalars['String']>;\n};\n\n\nexport type MutationUpdateBasketTitleArgs = {\n  id?: Maybe<Scalars['ID']>;\n  reference?: Maybe<Scalars['String']>;\n  newTitle: Scalars['String'];\n};\n\n\nexport type MutationUpdateBasketNotesArgs = {\n  id?: Maybe<Scalars['ID']>;\n  reference?: Maybe<Scalars['String']>;\n  notes: Scalars['String'];\n};\n\n\nexport type MutationAddItemToBasketArgs = {\n  basket?: Maybe<Scalars['ID']>;\n  service: Scalars['ID'];\n  detail: Scalars['JSON'];\n  adults: Scalars['Int'];\n  children?: Maybe<Scalars['Int']>;\n  infants?: Maybe<Scalars['Int']>;\n  price: Scalars['Float'];\n  currency: CurrencyCode;\n  searchQuery: Scalars['JSON'];\n  quickAdd?: Maybe<Scalars['Boolean']>;\n  users?: Maybe<Array<Maybe<UserPassengerTypeInput>>>;\n  leadPassenger?: Maybe<Scalars['ID']>;\n  co2PerItem?: Maybe<Scalars['Float']>;\n  co2PerPassenger?: Maybe<Scalars['Float']>;\n  outboundDate: Scalars['DateTime'];\n  inboundDate?: Maybe<Scalars['DateTime']>;\n};\n\n\nexport type MutationRemoveItemFromBasketArgs = {\n  basketItem: Scalars['ID'];\n};\n\n\nexport type MutationRemoveItemsFromBasketArgs = {\n  basketId: Scalars['ID'];\n  basketItems: Array<Scalars['ID']>;\n};\n\n\nexport type MutationMoveItemToADifferentBasketArgs = {\n  basketItem: Scalars['ID'];\n  newBasket: Scalars['ID'];\n};\n\n\nexport type MutationAddUsersToBasketItemArgs = {\n  basketItem: Scalars['ID'];\n  users: Array<UserPassengerTypeInput>;\n};\n\n\nexport type MutationRemoveUserFromBasketItemArgs = {\n  basketItem: Scalars['ID'];\n  user: Scalars['ID'];\n};\n\n\nexport type MutationReopenBasketArgs = {\n  id: Scalars['ID'];\n};\n\n\nexport type MutationSetBasketItemLeadPassengerArgs = {\n  id: Scalars['ID'];\n  user: Scalars['ID'];\n};\n\n\nexport type MutationBookBasketArgs = {\n  id: Scalars['ID'];\n  supplementaryInfo: Array<SupplementaryBookingInfo>;\n};\n\n\nexport type MutationCancelBookingArgs = {\n  basketItem: Scalars['ID'];\n};\n\n\nexport type MutationConfermaCreateCardArgs = {\n  label: Scalars['String'];\n};\n\n\nexport type MutationConfermaDeleteCardArgs = {\n  id: Scalars['ID'];\n};\n\n\nexport type MutationSetBasketItemMiGroupArgs = {\n  basketItem: Scalars['ID'];\n  group?: Maybe<Scalars['String']>;\n};\n\n\nexport type MutationSetMiDefaultValueArgs = {\n  mi: Scalars['ID'];\n  value: Scalars['ID'];\n};\n\n\nexport type MutationSetBasketItemMiValueArgs = {\n  mi: Scalars['ID'];\n  miValue?: Maybe<Scalars['ID']>;\n  miFreeValue?: Maybe<Scalars['String']>;\n  user?: Maybe<Scalars['ID']>;\n};\n\n\nexport type MutationConfirmMessageArgs = {\n  message: Scalars['String'];\n};\n\n\nexport type MutationSetBasketItemPaymentMethodArgs = {\n  basketItem: Scalars['ID'];\n  paymentMethod: Scalars['ID'];\n};\n\n\nexport type MutationRevalidateBasketArgs = {\n  id: Scalars['ID'];\n};\n\n\nexport type MutationRevalidateBasketItemArgs = {\n  id: Scalars['ID'];\n};\n\n\nexport type MutationAcceptNewPriceArgs = {\n  id: Scalars['ID'];\n};\n\n\nexport type MutationSaveFavouriteSearchArgs = {\n  name: Scalars['String'];\n  serviceType: ServiceType;\n  searchArgs: Scalars['JSON'];\n};\n\n\nexport type MutationSaveRecentSearchArgs = {\n  serviceType: ServiceType;\n  searchArgs: Scalars['JSON'];\n  travelDate: Scalars['DateTime'];\n  travellers?: Maybe<Array<Maybe<Scalars['ID']>>>;\n};\n\n\nexport type MutationDeleteFavouriteSearchArgs = {\n  id: Scalars['ID'];\n};\n\n\nexport type MutationDeleteRecentSearchArgs = {\n  id: Scalars['ID'];\n};\n\n\nexport type MutationSetUserLanguageArgs = {\n  language?: Maybe<Scalars['ID']>;\n};\n\nexport type Office = {\n  __typename?: 'Office';\n  id: FieldWrapper<Scalars['ID']>;\n  name: FieldWrapper<Scalars['String']>;\n  createdAt: FieldWrapper<Scalars['DateTime']>;\n  updatedAt: FieldWrapper<Scalars['DateTime']>;\n  company: FieldWrapper<Company>;\n  addresses: Array<FieldWrapper<Address>>;\n  phoneNumbers: Array<FieldWrapper<PhoneNumber>>;\n  co2AllowancePeriod?: Maybe<FieldWrapper<Scalars['String']>>;\n  co2AllowancePerPeriod?: Maybe<FieldWrapper<Scalars['String']>>;\n};\n\nexport type ParkingLocation = {\n  __typename?: 'ParkingLocation';\n  code: FieldWrapper<Scalars['String']>;\n  name: FieldWrapper<Scalars['String']>;\n  airport: FieldWrapper<Scalars['String']>;\n  terminal?: Maybe<FieldWrapper<Scalars['Int']>>;\n  latitude?: Maybe<FieldWrapper<Scalars['Float']>>;\n  longitude?: Maybe<FieldWrapper<Scalars['Float']>>;\n  address?: Maybe<FieldWrapper<Scalars['String']>>;\n  distanceToAirport?: Maybe<FieldWrapper<Scalars['Float']>>;\n  onAirport?: Maybe<FieldWrapper<Scalars['Boolean']>>;\n  carParkedForYou?: Maybe<FieldWrapper<Scalars['Boolean']>>;\n  meetAndGreet?: Maybe<FieldWrapper<Scalars['Boolean']>>;\n  telephone?: Maybe<FieldWrapper<Scalars['String']>>;\n  fax?: Maybe<FieldWrapper<Scalars['String']>>;\n  directions?: Maybe<FieldWrapper<Scalars['String']>>;\n  arrivalProcedure?: Maybe<FieldWrapper<Scalars['String']>>;\n  departureProcedure?: Maybe<FieldWrapper<Scalars['String']>>;\n  maximumCarSize?: Maybe<FieldWrapper<Scalars['String']>>;\n  introduction?: Maybe<FieldWrapper<Scalars['String']>>;\n  information?: Maybe<FieldWrapper<Scalars['String']>>;\n  transferInformation?: Maybe<FieldWrapper<Scalars['String']>>;\n  transferOperatingTimes?: Maybe<FieldWrapper<Scalars['String']>>;\n  transferTime?: Maybe<FieldWrapper<Scalars['Float']>>;\n  logo?: Maybe<FieldWrapper<Scalars['String']>>;\n  defaultImage?: Maybe<FieldWrapper<Scalars['String']>>;\n  brandImage?: Maybe<FieldWrapper<Scalars['String']>>;\n  mobileImage?: Maybe<FieldWrapper<Scalars['String']>>;\n  furtherImages?: Maybe<Array<Maybe<FieldWrapper<Scalars['String']>>>>;\n  misc?: Maybe<FieldWrapper<Scalars['JSON']>>;\n};\n\nexport type ParkingQuote = {\n  __typename?: 'ParkingQuote';\n  source: FieldWrapper<Scalars['String']>;\n  sourceId: FieldWrapper<Scalars['Int']>;\n  carPark: FieldWrapper<ParkingLocation>;\n  requiredInfo: Array<FieldWrapper<Scalars['String']>>;\n  price: FieldWrapper<Scalars['Float']>;\n  currency: FieldWrapper<CurrencyCode>;\n  misc?: Maybe<FieldWrapper<Scalars['JSON']>>;\n  tmcPreferred: FieldWrapper<Scalars['Boolean']>;\n  companyPreferred: FieldWrapper<Scalars['Boolean']>;\n  officePreferred: FieldWrapper<Scalars['Boolean']>;\n  tmcPreferredMessage?: Maybe<FieldWrapper<Scalars['String']>>;\n  companyPreferredMessage?: Maybe<FieldWrapper<Scalars['String']>>;\n  officePreferredMessage?: Maybe<FieldWrapper<Scalars['String']>>;\n  unavailable: FieldWrapper<Scalars['Boolean']>;\n  unavailableMessage?: Maybe<FieldWrapper<Scalars['String']>>;\n  co2PerPassenger: FieldWrapper<Scalars['Float']>;\n  co2PerItem: FieldWrapper<Scalars['Float']>;\n};\n\nexport type ParkingSearchResult = {\n  __typename?: 'ParkingSearchResult';\n  results: Array<FieldWrapper<ParkingQuote>>;\n  errors: Array<FieldWrapper<SearchError>>;\n};\n\nexport enum PassengerType {\n  Adult = 'ADULT',\n  Child = 'CHILD',\n  Infant = 'INFANT'\n}\n\nexport type Passport = {\n  __typename?: 'Passport';\n  id: FieldWrapper<Scalars['ID']>;\n  number: FieldWrapper<Scalars['String']>;\n  codeOfIssuingState: FieldWrapper<Scalars['String']>;\n  nationality: FieldWrapper<Scalars['String']>;\n  sex: FieldWrapper<PassportSex>;\n  dob: FieldWrapper<Scalars['DateTime']>;\n  surname: FieldWrapper<Scalars['String']>;\n  givenNames: FieldWrapper<Scalars['String']>;\n  dateOfIssue: FieldWrapper<Scalars['DateTime']>;\n  user: FieldWrapper<User>;\n  createdAt: FieldWrapper<Scalars['DateTime']>;\n  updatedAt: FieldWrapper<Scalars['DateTime']>;\n};\n\nexport enum PassportSex {\n  M = 'M',\n  F = 'F'\n}\n\nexport type PaymentConfig = {\n  cspUrl?: Maybe<Scalars['String']>;\n  agentId?: Maybe<Scalars['String']>;\n  bookerId?: Maybe<Scalars['String']>;\n  apiKey?: Maybe<Scalars['String']>;\n  password?: Maybe<Scalars['String']>;\n  server?: Maybe<Scalars['String']>;\n  consumer?: Maybe<Scalars['String']>;\n  clientId?: Maybe<Scalars['String']>;\n  accountType?: Maybe<Scalars['String']>;\n  accountValue?: Maybe<Scalars['String']>;\n  tokenUrl?: Maybe<Scalars['String']>;\n  tokenId?: Maybe<Scalars['String']>;\n  consumerId?: Maybe<Scalars['String']>;\n  tokenUsername?: Maybe<Scalars['String']>;\n  tokenPassword?: Maybe<Scalars['String']>;\n};\n\nexport type PaymentMethod = {\n  __typename?: 'PaymentMethod';\n  id: FieldWrapper<Scalars['ID']>;\n  name: FieldWrapper<Scalars['String']>;\n  description?: Maybe<FieldWrapper<Scalars['String']>>;\n};\n\nexport type PaymentMethodInput = {\n  config?: Maybe<PaymentConfig>;\n};\n\nexport type PhoneNumber = {\n  __typename?: 'PhoneNumber';\n  id: FieldWrapper<Scalars['ID']>;\n  description?: Maybe<FieldWrapper<Scalars['String']>>;\n  countryCode?: Maybe<FieldWrapper<Scalars['String']>>;\n  areaCode?: Maybe<FieldWrapper<Scalars['String']>>;\n  number?: Maybe<FieldWrapper<Scalars['String']>>;\n  extension?: Maybe<FieldWrapper<Scalars['String']>>;\n  type?: Maybe<FieldWrapper<PhoneType>>;\n  officePrimary?: Maybe<FieldWrapper<Scalars['Boolean']>>;\n  userPrimary?: Maybe<FieldWrapper<Scalars['Boolean']>>;\n};\n\nexport enum PhoneType {\n  Mobile = 'MOBILE',\n  Landline = 'LANDLINE',\n  Fax = 'FAX',\n  Other = 'OTHER'\n}\n\nexport type PostcodeDetails = {\n  __typename?: 'PostcodeDetails';\n  postcode: FieldWrapper<Scalars['String']>;\n  latitude?: Maybe<FieldWrapper<Scalars['Float']>>;\n  longitude?: Maybe<FieldWrapper<Scalars['Float']>>;\n  eastings?: Maybe<FieldWrapper<Scalars['Int']>>;\n  northings?: Maybe<FieldWrapper<Scalars['Int']>>;\n  country?: Maybe<FieldWrapper<Scalars['String']>>;\n  europeanElectoralRegion?: Maybe<FieldWrapper<Scalars['String']>>;\n  primaryCareTrust?: Maybe<FieldWrapper<Scalars['String']>>;\n  region?: Maybe<FieldWrapper<Scalars['String']>>;\n  lsoa?: Maybe<FieldWrapper<Scalars['String']>>;\n  msoa?: Maybe<FieldWrapper<Scalars['String']>>;\n  incode?: Maybe<FieldWrapper<Scalars['String']>>;\n  outcode?: Maybe<FieldWrapper<Scalars['String']>>;\n  parliamentaryConstituency?: Maybe<FieldWrapper<Scalars['String']>>;\n  adminDistrict?: Maybe<FieldWrapper<Scalars['String']>>;\n  parish?: Maybe<FieldWrapper<Scalars['String']>>;\n  adminCounty?: Maybe<FieldWrapper<Scalars['String']>>;\n  adminWard?: Maybe<FieldWrapper<Scalars['String']>>;\n  ced?: Maybe<FieldWrapper<Scalars['String']>>;\n  ccg?: Maybe<FieldWrapper<Scalars['String']>>;\n  nuts?: Maybe<FieldWrapper<Scalars['String']>>;\n};\n\nexport type Query = {\n  __typename?: 'Query';\n  getUserAddresses: Array<FieldWrapper<Address>>;\n  searchAirlines: FieldWrapper<AirlineResults>;\n  searchAirports: FieldWrapper<AirportResults>;\n  getUserBasket: FieldWrapper<Basket>;\n  getUserBaskets: Array<FieldWrapper<Basket>>;\n  searchCabHire: FieldWrapper<CabHireResult>;\n  searchUserCanBookFor: Array<FieldWrapper<User>>;\n  getCancellationInfo: FieldWrapper<BeforeCancellationInfo>;\n  searchCarHire: FieldWrapper<CarHireResult>;\n  getCarHireDepots: Array<FieldWrapper<CarHireDepot>>;\n  carHireAvailabilityDetailRequest: FieldWrapper<CarHireDetailRequestResponse>;\n  getUserCurrentCarbonAllowance?: Maybe<FieldWrapper<CarbonAllowance>>;\n  searchCities: Array<FieldWrapper<City>>;\n  confermaBlockClientHotels: FieldWrapper<ConfermaBlockedHotelsResult>;\n  confermaUnblockClientHotels: FieldWrapper<ConfermaBlockedHotelsResult>;\n  confermaBlockConsumerHotels: FieldWrapper<ConfermaBlockedHotelsResult>;\n  confermaUnblockConsumerHotels: FieldWrapper<ConfermaBlockedHotelsResult>;\n  confermaListCards: Array<FieldWrapper<ConfermaCardResults>>;\n  searchConfermaCities: FieldWrapper<ConfermaCityLocation>;\n  getConfermaOffice: FieldWrapper<ConfermaOfficeResult>;\n  getConfermaOfficeNames: FieldWrapper<ConfermaOfficeNamesResult>;\n  getConfermaQuicklist: FieldWrapper<HotelSearchResult>;\n  getCountries: Array<FieldWrapper<Country>>;\n  getCOVIDMicrositeToken: FieldWrapper<Scalars['String']>;\n  searchFastTrack: FieldWrapper<FastTrackResult>;\n  searchFlights: FieldWrapper<FlightSearchResult>;\n  searchFlightsV2: FieldWrapper<FlightSearchResultV2>;\n  searchEurostar: FieldWrapper<FlightSearchResultV2>;\n  alive: FieldWrapper<Scalars['Boolean']>;\n  getHotelChains: Array<FieldWrapper<Scalars['String']>>;\n  searchHotelChains: Array<FieldWrapper<Scalars['String']>>;\n  searchHotels: FieldWrapper<HotelSearchResult>;\n  getHotelAvailability: FieldWrapper<HotelAvailabilityResult>;\n  getMultipleHotelsAvailability: FieldWrapper<HotelMultiAvailabilityResult>;\n  getIRLSupplierStation?: Maybe<FieldWrapper<IrlSupplierStation>>;\n  searchIRLSupplierStations: Array<FieldWrapper<IrlSupplierStation>>;\n  searchIRL: FieldWrapper<IrlSearchResult>;\n  getRailLiveDepartures: FieldWrapper<LiveDepBoardResult>;\n  searchLounges: FieldWrapper<LoungeSearchResult>;\n  getUserMIAutoSuggestValues: Array<FieldWrapper<ManagementInfoValue>>;\n  validateUserMIFreeValue: FieldWrapper<Scalars['Boolean']>;\n  validateBasketItemMI: FieldWrapper<Scalars['Boolean']>;\n  getUserMessages: Array<FieldWrapper<Message>>;\n  getUserCompanyOffices: Array<FieldWrapper<Office>>;\n  searchParking: FieldWrapper<ParkingSearchResult>;\n  getBasketItemPaymentSupplmentaryInfoSchema: FieldWrapper<Scalars['JSON']>;\n  getUserPhoneNumbers: Array<FieldWrapper<PhoneNumber>>;\n  getPostcodeDetails: FieldWrapper<PostcodeDetails>;\n  postcodeAutoSuggest: Array<FieldWrapper<Scalars['String']>>;\n  searchPostcodes: Array<FieldWrapper<PostcodeDetails>>;\n  isPostcodeValid: FieldWrapper<Scalars['Boolean']>;\n  getRailStation: FieldWrapper<RailStation>;\n  searchRailStations: Array<FieldWrapper<RailStation>>;\n  searchRail: FieldWrapper<RailSearchResult>;\n  getRailcards: Array<FieldWrapper<ReferenceRailCardQualifier>>;\n  getRiskAlerts: Array<FieldWrapper<RiskAlert>>;\n  getUserTravelRules: FieldWrapper<TravelRulesCollection>;\n  getUserRecentSearches: Array<FieldWrapper<Search>>;\n  getUserFavouriteSearches: Array<FieldWrapper<Search>>;\n  getFlightSeatMap: FieldWrapper<FlightSeatMapResult>;\n  getUserServices: Array<FieldWrapper<Service>>;\n  getUserUIConfigs: FieldWrapper<UiConfigCollection>;\n  getUser: FieldWrapper<User>;\n};\n\n\nexport type QuerySearchAirlinesArgs = {\n  query: Scalars['String'];\n};\n\n\nexport type QuerySearchAirportsArgs = {\n  query: Scalars['String'];\n  countryCode?: Maybe<Scalars['String']>;\n  hasLounge?: Maybe<Scalars['Boolean']>;\n  hasParking?: Maybe<Scalars['Boolean']>;\n  hasFastTrack?: Maybe<Scalars['Boolean']>;\n  excludeNonPublic?: Maybe<Scalars['Boolean']>;\n};\n\n\nexport type QueryGetUserBasketArgs = {\n  id: Scalars['ID'];\n};\n\n\nexport type QueryGetUserBasketsArgs = {\n  user?: Maybe<Scalars['ID']>;\n  traveller?: Maybe<Scalars['ID']>;\n  basketStatus?: Maybe<BasketStatus>;\n  createdAfter?: Maybe<Scalars['DateTime']>;\n  createdBefore?: Maybe<Scalars['DateTime']>;\n  bookedAfter?: Maybe<Scalars['DateTime']>;\n  bookedBefore?: Maybe<Scalars['DateTime']>;\n  dateOfTravelBefore?: Maybe<Scalars['DateTime']>;\n  dateOfTravelAfter?: Maybe<Scalars['DateTime']>;\n  basketItemBookingReference?: Maybe<Scalars['String']>;\n  basketReference?: Maybe<Scalars['String']>;\n  basketTitle?: Maybe<Scalars['String']>;\n};\n\n\nexport type QuerySearchCabHireArgs = {\n  departs: Scalars['DateTime'];\n  fromLocation: CabHireLocationInput;\n  toLocation: CabHireLocationInput;\n  adults: Scalars['Int'];\n  children?: Maybe<Scalars['Int']>;\n  infants?: Maybe<Scalars['Int']>;\n  vias?: Maybe<Array<Maybe<CabHireLocationInput>>>;\n  vehicleType?: Maybe<CabHireVehicleType>;\n};\n\n\nexport type QuerySearchUserCanBookForArgs = {\n  email?: Maybe<Scalars['String']>;\n  userName?: Maybe<Scalars['String']>;\n  employeeId?: Maybe<Scalars['String']>;\n};\n\n\nexport type QueryGetCancellationInfoArgs = {\n  basketItem: Scalars['ID'];\n};\n\n\nexport type QuerySearchCarHireArgs = {\n  airport?: Maybe<CarHireAirportInput>;\n  city?: Maybe<CarHireCityInput>;\n  location?: Maybe<CarHireLocationInput>;\n  depot?: Maybe<InputCarHireDepot>;\n  pickupDateTime: Scalars['DateTime'];\n  dropoffDateTime: Scalars['DateTime'];\n  vendor?: Maybe<Scalars['String']>;\n  class?: Maybe<CarHireClass>;\n  type?: Maybe<CarHireType>;\n  transmission?: Maybe<CarHireTransmission>;\n  aircon?: Maybe<Scalars['Boolean']>;\n  estimatedDailyDistance?: Maybe<Scalars['Float']>;\n  estimatedDailyDistanceUnits?: Maybe<DistanceTypes>;\n};\n\n\nexport type QueryGetCarHireDepotsArgs = {\n  latitude: Scalars['Float'];\n  longitude: Scalars['Float'];\n  vendorCode?: Maybe<Scalars['String']>;\n};\n\n\nexport type QueryCarHireAvailabilityDetailRequestArgs = {\n  locationDetails: CarHireInputIdentifiers;\n};\n\n\nexport type QueryGetUserCurrentCarbonAllowanceArgs = {\n  user?: Maybe<Scalars['ID']>;\n};\n\n\nexport type QuerySearchCitiesArgs = {\n  query: Scalars['String'];\n  countryCode?: Maybe<Scalars['String']>;\n};\n\n\nexport type QueryConfermaBlockClientHotelsArgs = {\n  hotelIds: Array<Scalars['String']>;\n  groupIds: Array<Scalars['String']>;\n};\n\n\nexport type QueryConfermaUnblockClientHotelsArgs = {\n  hotelIds: Array<Scalars['String']>;\n  groupIds: Array<Scalars['String']>;\n};\n\n\nexport type QueryConfermaBlockConsumerHotelsArgs = {\n  hotelIds: Array<Scalars['String']>;\n  groupIds: Array<Scalars['String']>;\n};\n\n\nexport type QueryConfermaUnblockConsumerHotelsArgs = {\n  hotelIds: Array<Scalars['String']>;\n  groupIds: Array<Scalars['String']>;\n};\n\n\nexport type QueryConfermaListCardsArgs = {\n  companyId?: Maybe<Scalars['ID']>;\n  officeId?: Maybe<Scalars['ID']>;\n};\n\n\nexport type QuerySearchConfermaCitiesArgs = {\n  cityName: Scalars['String'];\n  countryCode: Scalars['String'];\n};\n\n\nexport type QueryGetConfermaOfficeArgs = {\n  officeId: Scalars['Int'];\n};\n\n\nexport type QueryGetConfermaQuicklistArgs = {\n  countryCode: Scalars['String'];\n};\n\n\nexport type QuerySearchFastTrackArgs = {\n  arrivalDatetime: Scalars['DateTime'];\n  locationCode: Scalars['String'];\n  adults: Scalars['Int'];\n  children?: Maybe<Scalars['Int']>;\n};\n\n\nexport type QuerySearchFlightsArgs = {\n  passengers: Array<FlightPassengerObject>;\n  originAirport?: Maybe<Scalars['String']>;\n  destinationAirport?: Maybe<Scalars['String']>;\n  multiDestination?: Maybe<Array<Maybe<DestinationEntry>>>;\n  outboundDate?: Maybe<Scalars['Date']>;\n  outboundDepartureTimeWindow?: Maybe<Scalars['String']>;\n  outboundArrivalTimeWindow?: Maybe<Scalars['String']>;\n  outboundCabinClass?: Maybe<Array<Maybe<FlightCabinClass>>>;\n  returnTrip: Scalars['Boolean'];\n  returnDate?: Maybe<Scalars['Date']>;\n  returnDepartureTimeWindow?: Maybe<Scalars['String']>;\n  returnArrivalTimeWindow?: Maybe<Scalars['String']>;\n  returnCabinClass?: Maybe<Array<Maybe<FlightCabinClass>>>;\n  fareType: FareType;\n  requireFreeBag?: Maybe<Scalars['Boolean']>;\n  maxConnections?: Maybe<Scalars['Int']>;\n  preferredCarriers?: Maybe<Array<Maybe<Scalars['String']>>>;\n  includeNearbyAirports?: Maybe<Scalars['Boolean']>;\n  asSingles?: Maybe<Scalars['Boolean']>;\n};\n\n\nexport type QuerySearchFlightsV2Args = {\n  passengers: Array<FlightPassengerObject>;\n  originAirport?: Maybe<Scalars['String']>;\n  destinationAirport?: Maybe<Scalars['String']>;\n  multiDestination?: Maybe<Array<Maybe<DestinationEntry>>>;\n  outboundDate?: Maybe<Scalars['Date']>;\n  outboundDepartureTimeWindow?: Maybe<Scalars['String']>;\n  outboundArrivalTimeWindow?: Maybe<Scalars['String']>;\n  outboundCabinClass?: Maybe<Array<Maybe<FlightCabinClass>>>;\n  returnTrip: Scalars['Boolean'];\n  returnDate?: Maybe<Scalars['Date']>;\n  returnDepartureTimeWindow?: Maybe<Scalars['String']>;\n  returnArrivalTimeWindow?: Maybe<Scalars['String']>;\n  returnCabinClass?: Maybe<Array<Maybe<FlightCabinClass>>>;\n  fareType: FareType;\n  requireFreeBag?: Maybe<Scalars['Boolean']>;\n  maxConnections?: Maybe<Scalars['Int']>;\n  preferredCarriers?: Maybe<Array<Maybe<Scalars['String']>>>;\n  includeNearbyAirports?: Maybe<Scalars['Boolean']>;\n  asSingles?: Maybe<Scalars['Boolean']>;\n};\n\n\nexport type QuerySearchEurostarArgs = {\n  passengers: Array<FlightPassengerObject>;\n  originAirport?: Maybe<Scalars['String']>;\n  destinationAirport?: Maybe<Scalars['String']>;\n  multiDestination?: Maybe<Array<Maybe<DestinationEntry>>>;\n  outboundDate?: Maybe<Scalars['Date']>;\n  outboundDepartureTimeWindow?: Maybe<Scalars['String']>;\n  outboundArrivalTimeWindow?: Maybe<Scalars['String']>;\n  outboundCabinClass?: Maybe<Array<Maybe<FlightCabinClass>>>;\n  returnTrip: Scalars['Boolean'];\n  returnDate?: Maybe<Scalars['Date']>;\n  returnDepartureTimeWindow?: Maybe<Scalars['String']>;\n  returnArrivalTimeWindow?: Maybe<Scalars['String']>;\n  returnCabinClass?: Maybe<Array<Maybe<FlightCabinClass>>>;\n  fareType: FareType;\n  requireFreeBag?: Maybe<Scalars['Boolean']>;\n  maxConnections?: Maybe<Scalars['Int']>;\n  preferredCarriers?: Maybe<Array<Maybe<Scalars['String']>>>;\n  includeNearbyAirports?: Maybe<Scalars['Boolean']>;\n  asSingles?: Maybe<Scalars['Boolean']>;\n};\n\n\nexport type QuerySearchHotelChainsArgs = {\n  query: Scalars['String'];\n};\n\n\nexport type QuerySearchHotelsArgs = {\n  startDate: Scalars['Date'];\n  endDate: Scalars['Date'];\n  cityName?: Maybe<Scalars['String']>;\n  postOrZipCode?: Maybe<Scalars['String']>;\n  countryCode?: Maybe<Scalars['String']>;\n  latitude?: Maybe<Scalars['Float']>;\n  longitude?: Maybe<Scalars['Float']>;\n  trainStationCode?: Maybe<Scalars['String']>;\n  iata?: Maybe<Scalars['String']>;\n  officeId?: Maybe<Scalars['Int']>;\n  rooms: Scalars['Int'];\n  adults: Scalars['Int'];\n  children?: Maybe<Scalars['Int']>;\n  currency: Scalars['String'];\n  distanceType: DistanceTypes;\n  distance: Scalars['Int'];\n  maxResults?: Maybe<Scalars['Int']>;\n  hotelName?: Maybe<Scalars['String']>;\n  groupName?: Maybe<Scalars['String']>;\n};\n\n\nexport type QueryGetHotelAvailabilityArgs = {\n  hotel: Scalars['String'];\n  startDate: Scalars['Date'];\n  endDate: Scalars['Date'];\n  currency: Scalars['String'];\n  occupants: Scalars['Int'];\n  rooms?: Maybe<Scalars['Int']>;\n};\n\n\nexport type QueryGetMultipleHotelsAvailabilityArgs = {\n  hotel: Array<Scalars['String']>;\n  startDate: Scalars['Date'];\n  endDate: Scalars['Date'];\n  currency: Scalars['String'];\n  occupants: Scalars['Int'];\n  rooms?: Maybe<Scalars['Int']>;\n};\n\n\nexport type QueryGetIrlSupplierStationArgs = {\n  id?: Maybe<Scalars['ID']>;\n  supplier?: Maybe<IrlSupplier>;\n  code?: Maybe<Scalars['String']>;\n};\n\n\nexport type QuerySearchIrlSupplierStationsArgs = {\n  query: Scalars['String'];\n  supplier?: Maybe<IrlSupplier>;\n};\n\n\nexport type QuerySearchIrlArgs = {\n  supplier: IrlSupplier;\n  countryCode: Scalars['String'];\n  journeyType: IrlJourneyType;\n  class?: Maybe<IrlClass>;\n  outboundDepartureDateTime: Scalars['DateTime'];\n  departureLocationId: Scalars['ID'];\n  arrivalLocationId: Scalars['ID'];\n  adults: Scalars['Int'];\n  children?: Maybe<Scalars['Int']>;\n  returnDepartureDateTime?: Maybe<Scalars['DateTime']>;\n};\n\n\nexport type QueryGetRailLiveDeparturesArgs = {\n  stationCode: Scalars['String'];\n};\n\n\nexport type QuerySearchLoungesArgs = {\n  locationCode: Scalars['String'];\n  arrivalDatetime: Scalars['DateTime'];\n  adults: Scalars['Int'];\n  children?: Maybe<Scalars['Int']>;\n  infants?: Maybe<Scalars['Int']>;\n  terminal?: Maybe<Scalars['String']>;\n};\n\n\nexport type QueryGetUserMiAutoSuggestValuesArgs = {\n  mi: Scalars['ID'];\n  partialLabel: Scalars['String'];\n};\n\n\nexport type QueryValidateUserMiFreeValueArgs = {\n  mi: Scalars['ID'];\n  freeValue: Scalars['String'];\n};\n\n\nexport type QueryValidateBasketItemMiArgs = {\n  basketItem: Scalars['ID'];\n};\n\n\nexport type QueryGetUserMessagesArgs = {\n  environment?: Maybe<Scalars['String']>;\n  displayTarget?: Maybe<Scalars['String']>;\n};\n\n\nexport type QuerySearchParkingArgs = {\n  arrivalDatetime: Scalars['DateTime'];\n  departDatetime: Scalars['DateTime'];\n  locationCode: Scalars['String'];\n  outFlightNumber?: Maybe<Scalars['String']>;\n  recommended?: Maybe<Scalars['Boolean']>;\n  onAirport?: Maybe<Scalars['Boolean']>;\n  meetAndGreet?: Maybe<Scalars['Boolean']>;\n  parkAndRide?: Maybe<Scalars['Boolean']>;\n  parkAndStroll?: Maybe<Scalars['Boolean']>;\n  carParkedForYou?: Maybe<Scalars['Boolean']>;\n  terminal?: Maybe<Scalars['String']>;\n};\n\n\nexport type QueryGetBasketItemPaymentSupplmentaryInfoSchemaArgs = {\n  basketItem: Scalars['ID'];\n};\n\n\nexport type QueryGetPostcodeDetailsArgs = {\n  postcode: Scalars['String'];\n};\n\n\nexport type QueryPostcodeAutoSuggestArgs = {\n  postcode: Scalars['String'];\n};\n\n\nexport type QuerySearchPostcodesArgs = {\n  query: Scalars['String'];\n};\n\n\nexport type QueryIsPostcodeValidArgs = {\n  postcode: Scalars['String'];\n};\n\n\nexport type QueryGetRailStationArgs = {\n  id?: Maybe<Scalars['ID']>;\n  code?: Maybe<Scalars['String']>;\n};\n\n\nexport type QuerySearchRailStationsArgs = {\n  query: Scalars['String'];\n  countryCode?: Maybe<Scalars['String']>;\n};\n\n\nexport type QuerySearchRailArgs = {\n  countryCode: Scalars['String'];\n  journeyType: RailJourneyType;\n  class?: Maybe<RailClass>;\n  outboundArrivalDateTime?: Maybe<Scalars['DateTime']>;\n  outboundDepartureDateTime?: Maybe<Scalars['DateTime']>;\n  departureLocationId: Scalars['ID'];\n  arrivalLocationId: Scalars['ID'];\n  adults: Scalars['Int'];\n  children?: Maybe<Scalars['Int']>;\n  returnArrivalDateTime?: Maybe<Scalars['DateTime']>;\n  returnDepartureDateTime?: Maybe<Scalars['DateTime']>;\n  railCardQualifiers?: Maybe<Array<Scalars['String']>>;\n  viaLocationId?: Maybe<Scalars['ID']>;\n  extraTimeToChange?: Maybe<Scalars['Boolean']>;\n  plusBusOut?: Maybe<RailPlusBusAvail>;\n  plusBusReturn?: Maybe<RailPlusBusAvail>;\n};\n\n\nexport type QueryGetRiskAlertsArgs = {\n  minLevel?: Maybe<RiskLevel>;\n  maxLevel?: Maybe<RiskLevel>;\n  countryIsoCode?: Maybe<Scalars['String']>;\n  airport?: Maybe<Scalars['ID']>;\n  railStation?: Maybe<Scalars['ID']>;\n  airportIata?: Maybe<Scalars['String']>;\n};\n\n\nexport type QueryGetUserRecentSearchesArgs = {\n  serviceType?: Maybe<ServiceType>;\n};\n\n\nexport type QueryGetUserFavouriteSearchesArgs = {\n  serviceType?: Maybe<ServiceType>;\n};\n\n\nexport type QueryGetFlightSeatMapArgs = {\n  flight: InputFlightJourney;\n};\n\n\nexport type QueryGetUserUiConfigsArgs = {\n  target?: Maybe<Scalars['String']>;\n};\n\n\nexport type QueryGetUserArgs = {\n  id?: Maybe<Scalars['ID']>;\n};\n\nexport type RailAccount = {\n  __typename?: 'RailAccount';\n  id?: Maybe<FieldWrapper<Scalars['String']>>;\n  reference?: Maybe<FieldWrapper<Scalars['String']>>;\n  description?: Maybe<FieldWrapper<Scalars['String']>>;\n  isDefault?: Maybe<FieldWrapper<Scalars['Boolean']>>;\n  type?: Maybe<FieldWrapper<Scalars['String']>>;\n};\n\nexport type RailCallingPoint = {\n  __typename?: 'RailCallingPoint';\n  stationName?: Maybe<FieldWrapper<Scalars['String']>>;\n  stationCode?: Maybe<FieldWrapper<Scalars['String']>>;\n  arrivalDateTime?: Maybe<FieldWrapper<Scalars['DateTime']>>;\n  departureDateTime?: Maybe<FieldWrapper<Scalars['DateTime']>>;\n  scheduledPlatform?: Maybe<FieldWrapper<Scalars['String']>>;\n  stationClassification?: Maybe<FieldWrapper<RailStationClassification>>;\n  stoppingPattern?: Maybe<FieldWrapper<RailStoppingPattern>>;\n};\n\nexport enum RailClass {\n  All = 'All',\n  First = 'First',\n  Standard = 'Standard'\n}\n\nexport type RailIdentifiers = {\n  __typename?: 'RailIdentifiers';\n  transactionIdentifier?: Maybe<FieldWrapper<Scalars['String']>>;\n  journeyIdentifier?: Maybe<FieldWrapper<Scalars['String']>>;\n  provider?: Maybe<FieldWrapper<Scalars['String']>>;\n  fareIdentifier?: Maybe<FieldWrapper<Scalars['String']>>;\n  direction?: Maybe<FieldWrapper<Scalars['String']>>;\n  allowedWith: Array<FieldWrapper<RailIdentifiers>>;\n  singleOrReturn?: Maybe<FieldWrapper<Scalars['String']>>;\n  bookingRef?: Maybe<FieldWrapper<Scalars['String']>>;\n};\n\nexport type RailJourneyOption = {\n  __typename?: 'RailJourneyOption';\n  identifiers?: Maybe<FieldWrapper<RailIdentifiers>>;\n  travellers?: Maybe<Array<FieldWrapper<RailTraveller>>>;\n  co2PerItem?: Maybe<FieldWrapper<Scalars['Float']>>;\n  co2PerPassenger?: Maybe<FieldWrapper<Scalars['Float']>>;\n  from?: Maybe<FieldWrapper<Scalars['String']>>;\n  fromCode?: Maybe<FieldWrapper<Scalars['String']>>;\n  to?: Maybe<FieldWrapper<Scalars['String']>>;\n  toCode?: Maybe<FieldWrapper<Scalars['String']>>;\n  departDateTime?: Maybe<FieldWrapper<Scalars['DateTime']>>;\n  arriveDateTime?: Maybe<FieldWrapper<Scalars['DateTime']>>;\n  changes?: Maybe<FieldWrapper<Scalars['String']>>;\n  segments?: Maybe<Array<FieldWrapper<RailSegment>>>;\n  providers?: Maybe<Array<FieldWrapper<RailProvider>>>;\n  unsellable?: Maybe<FieldWrapper<Scalars['String']>>;\n  ticketExtras?: Maybe<Array<FieldWrapper<RailTicketExtra>>>;\n  plusBus?: Maybe<FieldWrapper<RailPlusBus>>;\n};\n\nexport type RailJourneyOptions = {\n  __typename?: 'RailJourneyOptions';\n  source: FieldWrapper<Scalars['String']>;\n  sourceId: FieldWrapper<Scalars['Int']>;\n  outbound?: Maybe<Array<FieldWrapper<RailJourneyOption>>>;\n  return?: Maybe<Array<FieldWrapper<RailJourneyOption>>>;\n};\n\nexport enum RailJourneyType {\n  ReturnJourney = 'ReturnJourney',\n  SingleJourney = 'SingleJourney',\n  DualSingleJourney = 'DualSingleJourney',\n  OpenReturnJourney = 'OpenReturnJourney'\n}\n\nexport type RailPlusBus = {\n  __typename?: 'RailPlusBus';\n  originPlusBusNLC?: Maybe<FieldWrapper<Scalars['String']>>;\n  originStationNLC?: Maybe<FieldWrapper<Scalars['String']>>;\n  destinationPlusBusNLC?: Maybe<FieldWrapper<Scalars['String']>>;\n  destinationStationNLC?: Maybe<FieldWrapper<Scalars['String']>>;\n};\n\nexport type RailPlusBusAvail = {\n  origin?: Maybe<Scalars['Boolean']>;\n  destination?: Maybe<Scalars['Boolean']>;\n};\n\nexport type RailProvider = {\n  __typename?: 'RailProvider';\n  providerId?: Maybe<FieldWrapper<Scalars['String']>>;\n  name?: Maybe<FieldWrapper<Scalars['String']>>;\n  cheapestTicket?: Maybe<FieldWrapper<RailTicketOption>>;\n  ticketOptions?: Maybe<Array<Maybe<FieldWrapper<RailTicketOption>>>>;\n  bookedTicket?: Maybe<FieldWrapper<RailTicketOption>>;\n};\n\nexport type RailSearchResult = {\n  __typename?: 'RailSearchResult';\n  results: Array<FieldWrapper<RailJourneyOptions>>;\n  errors: Array<FieldWrapper<SearchError>>;\n};\n\nexport type RailSeat = {\n  __typename?: 'RailSeat';\n  location?: Maybe<FieldWrapper<Scalars['String']>>;\n  coach?: Maybe<FieldWrapper<Scalars['String']>>;\n  number?: Maybe<FieldWrapper<Scalars['String']>>;\n  direction?: Maybe<FieldWrapper<Scalars['String']>>;\n  position?: Maybe<FieldWrapper<Scalars['String']>>;\n  deck?: Maybe<FieldWrapper<Scalars['String']>>;\n  seatType?: Maybe<FieldWrapper<Scalars['String']>>;\n  seatSelection?: Maybe<FieldWrapper<Scalars['String']>>;\n  facilities?: Maybe<Array<Maybe<FieldWrapper<Scalars['String']>>>>;\n  note: FieldWrapper<Scalars['String']>;\n};\n\nexport type RailSeatPreferenceType = {\n  __typename?: 'RailSeatPreferenceType';\n  name?: Maybe<FieldWrapper<Scalars['String']>>;\n  allowedValues?: Maybe<Array<Maybe<FieldWrapper<Scalars['String']>>>>;\n};\n\nexport type RailSegment = {\n  __typename?: 'RailSegment';\n  id?: Maybe<FieldWrapper<Scalars['String']>>;\n  operator?: Maybe<FieldWrapper<Scalars['String']>>;\n  depart?: Maybe<FieldWrapper<Scalars['String']>>;\n  departDateTime?: Maybe<FieldWrapper<Scalars['DateTime']>>;\n  arrive?: Maybe<FieldWrapper<Scalars['String']>>;\n  arriveDateTime?: Maybe<FieldWrapper<Scalars['DateTime']>>;\n  reservableStatus?: Maybe<FieldWrapper<Scalars['String']>>;\n  seatPreferenceTypes?: Maybe<Array<FieldWrapper<RailSeatPreferenceType>>>;\n  seatPreferenceGroup?: Maybe<FieldWrapper<Scalars['String']>>;\n  seats?: Maybe<Array<FieldWrapper<RailSeat>>>;\n  callingPoints?: Maybe<Array<FieldWrapper<RailCallingPoint>>>;\n};\n\nexport type RailStation = {\n  __typename?: 'RailStation';\n  id: FieldWrapper<Scalars['ID']>;\n  name: FieldWrapper<Scalars['String']>;\n  stationCode: FieldWrapper<Scalars['String']>;\n  nlcCode?: Maybe<FieldWrapper<Scalars['Int']>>;\n  trainlineCode?: Maybe<FieldWrapper<Scalars['String']>>;\n  trainlineUniqueCode?: Maybe<FieldWrapper<Scalars['String']>>;\n  locationDetails?: Maybe<FieldWrapper<LocationDetail>>;\n};\n\nexport enum RailStationClassification {\n  Origin = 'Origin',\n  Intermediate = 'Intermediate',\n  Destination = 'Destination',\n  Unknown = 'Unknown'\n}\n\nexport enum RailStoppingPattern {\n  RequestStop = 'RequestStop',\n  PickUpOnly = 'PickUpOnly',\n  SetDownOnly = 'SetDownOnly',\n  Normal = 'Normal',\n  Passing = 'Passing',\n  Unknown = 'Unknown'\n}\n\nexport type RailTextValuePair = {\n  __typename?: 'RailTextValuePair';\n  text: FieldWrapper<Scalars['String']>;\n  value?: Maybe<FieldWrapper<Scalars['String']>>;\n};\n\nexport type RailTicket = {\n  __typename?: 'RailTicket';\n  price?: Maybe<FieldWrapper<Scalars['Float']>>;\n  type?: Maybe<FieldWrapper<Scalars['String']>>;\n  route?: Maybe<FieldWrapper<Scalars['String']>>;\n  segments?: Maybe<Array<FieldWrapper<RailSegment>>>;\n  numChildren?: Maybe<FieldWrapper<Scalars['Int']>>;\n  numAdults?: Maybe<FieldWrapper<Scalars['Int']>>;\n};\n\nexport type RailTicketExtra = {\n  __typename?: 'RailTicketExtra';\n  identifiers?: Maybe<FieldWrapper<RailTicketExtraIdentifiers>>;\n  type?: Maybe<FieldWrapper<Scalars['String']>>;\n  location?: Maybe<FieldWrapper<Scalars['String']>>;\n  date?: Maybe<FieldWrapper<Scalars['Date']>>;\n  description?: Maybe<FieldWrapper<Scalars['String']>>;\n  amount?: Maybe<FieldWrapper<Scalars['Float']>>;\n  adultAmount?: Maybe<FieldWrapper<Scalars['Float']>>;\n  childAmount?: Maybe<FieldWrapper<Scalars['Float']>>;\n  currency?: Maybe<FieldWrapper<Scalars['String']>>;\n};\n\nexport type RailTicketExtraIdentifiers = {\n  __typename?: 'RailTicketExtraIdentifiers';\n  type?: Maybe<FieldWrapper<Scalars['String']>>;\n  location?: Maybe<FieldWrapper<Scalars['String']>>;\n  date?: Maybe<FieldWrapper<Scalars['Date']>>;\n  journeyId?: Maybe<FieldWrapper<Scalars['String']>>;\n  isOrigin?: Maybe<FieldWrapper<Scalars['Boolean']>>;\n};\n\nexport type RailTicketOption = {\n  __typename?: 'RailTicketOption';\n  identifiers?: Maybe<FieldWrapper<RailIdentifiers>>;\n  type?: Maybe<FieldWrapper<Scalars['String']>>;\n  terms?: Maybe<FieldWrapper<RailTicketTerms>>;\n  class?: Maybe<FieldWrapper<Scalars['String']>>;\n  singleOrReturn?: Maybe<FieldWrapper<Scalars['String']>>;\n  price?: Maybe<FieldWrapper<Scalars['Float']>>;\n  reservableStatus?: Maybe<FieldWrapper<Scalars['String']>>;\n  currency?: Maybe<FieldWrapper<Scalars['String']>>;\n  route?: Maybe<FieldWrapper<Scalars['String']>>;\n  routeCode?: Maybe<FieldWrapper<Scalars['String']>>;\n  availableSeats?: Maybe<FieldWrapper<Scalars['Int']>>;\n  tickets?: Maybe<Array<Maybe<FieldWrapper<RailTicket>>>>;\n  ticketQueueList?: Maybe<Array<Maybe<FieldWrapper<RailTicketQueue>>>>;\n  accountsList?: Maybe<Array<Maybe<FieldWrapper<RailAccount>>>>;\n};\n\nexport type RailTicketQueue = {\n  __typename?: 'RailTicketQueue';\n  id?: Maybe<FieldWrapper<Scalars['String']>>;\n  name?: Maybe<FieldWrapper<Scalars['String']>>;\n  type?: Maybe<FieldWrapper<Scalars['String']>>;\n};\n\nexport type RailTicketTerms = {\n  __typename?: 'RailTicketTerms';\n  error?: Maybe<FieldWrapper<Scalars['String']>>;\n  ticketTypeCode?: Maybe<FieldWrapper<Scalars['String']>>;\n  trainOperatingCompanyCode?: Maybe<FieldWrapper<Scalars['String']>>;\n  ticketTypeName?: Maybe<FieldWrapper<Scalars['String']>>;\n  ticketTypeAltName?: Maybe<FieldWrapper<Scalars['String']>>;\n  ticketTypeClass?: Maybe<FieldWrapper<Scalars['String']>>;\n  reservationRule?: Maybe<FieldWrapper<Scalars['String']>>;\n  journeyType?: Maybe<FieldWrapper<Scalars['String']>>;\n  preBookingRequirement?: Maybe<FieldWrapper<Scalars['String']>>;\n  generalValidity?: Maybe<FieldWrapper<Scalars['String']>>;\n  validOutRule?: Maybe<FieldWrapper<Scalars['String']>>;\n  validReturnRule?: Maybe<FieldWrapper<Scalars['String']>>;\n  generalDiscount?: Maybe<FieldWrapper<Scalars['String']>>;\n  childDiscount?: Maybe<FieldWrapper<Scalars['String']>>;\n  railcardDiscount?: Maybe<FieldWrapper<Scalars['String']>>;\n  refundCancellationRule?: Maybe<FieldWrapper<Scalars['String']>>;\n  changeRule?: Maybe<FieldWrapper<Scalars['String']>>;\n  ticketTypeConditionsDescription?: Maybe<FieldWrapper<Scalars['String']>>;\n  journeyBreakRule?: Maybe<FieldWrapper<Scalars['String']>>;\n  availabilityRule?: Maybe<FieldWrapper<Scalars['String']>>;\n  todAvailable?: Maybe<FieldWrapper<Scalars['String']>>;\n  kioskAvailable?: Maybe<FieldWrapper<Scalars['String']>>;\n  startDate?: Maybe<FieldWrapper<Scalars['String']>>;\n  endDate?: Maybe<FieldWrapper<Scalars['String']>>;\n  dynamicConditions?: Maybe<Array<Maybe<FieldWrapper<DynamicCondition>>>>;\n};\n\nexport type RailTraveller = {\n  __typename?: 'RailTraveller';\n  status?: Maybe<FieldWrapper<RailTravellerStatus>>;\n  id?: Maybe<FieldWrapper<Scalars['String']>>;\n  dob?: Maybe<FieldWrapper<Scalars['Date']>>;\n  railcard?: Maybe<FieldWrapper<Scalars['String']>>;\n  givenName?: Maybe<FieldWrapper<Scalars['String']>>;\n  surname?: Maybe<FieldWrapper<Scalars['String']>>;\n  nameTitle?: Maybe<FieldWrapper<Scalars['String']>>;\n  contactInfo?: Maybe<FieldWrapper<Scalars['String']>>;\n  deliveryEmailAddress?: Maybe<FieldWrapper<Scalars['String']>>;\n  fare?: Maybe<FieldWrapper<Scalars['String']>>;\n};\n\nexport enum RailTravellerStatus {\n  Placeholder = 'placeholder',\n  Complete = 'complete'\n}\n\nexport type ReferenceRailCardQualifier = {\n  __typename?: 'ReferenceRailCardQualifier';\n  name: FieldWrapper<Scalars['String']>;\n  code: FieldWrapper<Scalars['String']>;\n};\n\nexport type RiskAlert = {\n  __typename?: 'RiskAlert';\n  id: FieldWrapper<Scalars['ID']>;\n  title: FieldWrapper<Scalars['String']>;\n  description: FieldWrapper<Scalars['String']>;\n  breaking: FieldWrapper<Scalars['Boolean']>;\n  risk: FieldWrapper<RiskLevel>;\n  category: FieldWrapper<Scalars['String']>;\n  country: FieldWrapper<Scalars['String']>;\n  location?: Maybe<FieldWrapper<Scalars['String']>>;\n  latitude?: Maybe<FieldWrapper<Scalars['Float']>>;\n  longitude?: Maybe<FieldWrapper<Scalars['Float']>>;\n  startDate: FieldWrapper<Scalars['DateTime']>;\n  endDate: FieldWrapper<Scalars['DateTime']>;\n  receivedDate: FieldWrapper<Scalars['DateTime']>;\n};\n\nexport enum RiskLevel {\n  Low = 'Low',\n  Moderate = 'Moderate',\n  Medium = 'Medium',\n  High = 'High',\n  Extreme = 'Extreme'\n}\n\nexport type Search = {\n  __typename?: 'Search';\n  id: FieldWrapper<Scalars['ID']>;\n  name?: Maybe<FieldWrapper<Scalars['String']>>;\n  serviceType: FieldWrapper<ServiceType>;\n  searchArgs: FieldWrapper<Scalars['JSON']>;\n  createdAt: FieldWrapper<Scalars['DateTime']>;\n  updatedAt: FieldWrapper<Scalars['DateTime']>;\n  travelDate?: Maybe<FieldWrapper<Scalars['DateTime']>>;\n  travellers?: Maybe<Array<FieldWrapper<User>>>;\n};\n\nexport type SearchError = {\n  __typename?: 'SearchError';\n  service: FieldWrapper<Service>;\n  errorMessage: FieldWrapper<Scalars['String']>;\n  errorCode: FieldWrapper<Scalars['String']>;\n};\n\nexport type SearchResult = FlightItinerary | ItinerarySummary;\n\nexport type SelectedManagementInfoValue = {\n  __typename?: 'SelectedManagementInfoValue';\n  value?: Maybe<FieldWrapper<ManagementInfoValue>>;\n  freeValue?: Maybe<FieldWrapper<Scalars['String']>>;\n  basketLevelValue: FieldWrapper<Scalars['Boolean']>;\n  userLevelValue: FieldWrapper<Scalars['Boolean']>;\n  user?: Maybe<FieldWrapper<User>>;\n};\n\nexport type Service = {\n  __typename?: 'Service';\n  id: FieldWrapper<Scalars['ID']>;\n  type: FieldWrapper<ServiceType>;\n  name: FieldWrapper<Scalars['String']>;\n  description: FieldWrapper<Scalars['String']>;\n  supplierUrl: FieldWrapper<Scalars['String']>;\n  active: FieldWrapper<Scalars['Boolean']>;\n  apiEndpointUrl: FieldWrapper<Scalars['String']>;\n  basketItemTtl: FieldWrapper<Scalars['Float']>;\n  cancellable: FieldWrapper<Scalars['Boolean']>;\n  amendable: FieldWrapper<Scalars['Boolean']>;\n  detailSchema: FieldWrapper<Scalars['JSON']>;\n  searchQuerySchema: FieldWrapper<Scalars['JSON']>;\n};\n\nexport enum ServiceType {\n  Flight = 'FLIGHT',\n  Eurostar = 'EUROSTAR',\n  InternationalRail = 'INTERNATIONAL_RAIL',\n  Rail = 'RAIL',\n  Hotel = 'HOTEL',\n  Car = 'CAR',\n  Lounge = 'LOUNGE',\n  FastTrack = 'FAST_TRACK',\n  Parking = 'PARKING',\n  Cab = 'CAB',\n  Coach = 'COACH'\n}\n\nexport type StationSearchRequestResponse = {\n  __typename?: 'StationSearchRequestResponse';\n  text: FieldWrapper<Scalars['String']>;\n  value: FieldWrapper<Scalars['String']>;\n};\n\nexport type SupplementaryBookingInfo = {\n  basketItem: Scalars['ID'];\n  userInfo: Array<UserInfo>;\n  address?: Maybe<BookingAddress>;\n  phoneNumber?: Maybe<BookingPhoneNumber>;\n  supplementaryInfo: Scalars['JSON'];\n  paymentMethodDetails?: Maybe<Scalars['JSON']>;\n};\n\nexport type Tmc = {\n  __typename?: 'TMC';\n  id: FieldWrapper<Scalars['ID']>;\n  name: FieldWrapper<Scalars['String']>;\n};\n\nexport type TravelRule = {\n  __typename?: 'TravelRule';\n  id: FieldWrapper<Scalars['ID']>;\n  name: FieldWrapper<Scalars['String']>;\n  description: FieldWrapper<Scalars['String']>;\n  appliesTo: FieldWrapper<ServiceType>;\n  applicationStage: FieldWrapper<ApplicationStage>;\n};\n\nexport type TravelRuleAppliesTo = {\n  __typename?: 'TravelRuleAppliesTo';\n  flight?: Maybe<Array<Maybe<FieldWrapper<TravelRule>>>>;\n  rail?: Maybe<Array<Maybe<FieldWrapper<TravelRule>>>>;\n  hotel?: Maybe<Array<Maybe<FieldWrapper<TravelRule>>>>;\n  car?: Maybe<Array<Maybe<FieldWrapper<TravelRule>>>>;\n  lounge?: Maybe<Array<Maybe<FieldWrapper<TravelRule>>>>;\n  fastTrack?: Maybe<Array<Maybe<FieldWrapper<TravelRule>>>>;\n  parking?: Maybe<Array<Maybe<FieldWrapper<TravelRule>>>>;\n  cab?: Maybe<Array<Maybe<FieldWrapper<TravelRule>>>>;\n  coach?: Maybe<Array<Maybe<FieldWrapper<TravelRule>>>>;\n};\n\nexport type TravelRulesCollection = {\n  __typename?: 'TravelRulesCollection';\n  tmc: Array<FieldWrapper<TravelRule>>;\n  company: Array<FieldWrapper<TravelRule>>;\n  offices: Array<FieldWrapper<TravelRule>>;\n  companyGroups: Array<FieldWrapper<TravelRule>>;\n  user: Array<FieldWrapper<TravelRule>>;\n  all: Array<FieldWrapper<TravelRule>>;\n  appliesTo?: Maybe<FieldWrapper<TravelRuleAppliesTo>>;\n};\n\nexport type UiConfig = {\n  __typename?: 'UIConfig';\n  id: FieldWrapper<Scalars['ID']>;\n  name: FieldWrapper<Scalars['String']>;\n  target: FieldWrapper<UiConfigTarget>;\n  description?: Maybe<FieldWrapper<Scalars['String']>>;\n  config?: Maybe<FieldWrapper<Scalars['JSON']>>;\n  key: FieldWrapper<Scalars['String']>;\n};\n\nexport type UiConfigCollection = {\n  __typename?: 'UIConfigCollection';\n  tmc: Array<FieldWrapper<UiConfig>>;\n  company: Array<FieldWrapper<UiConfig>>;\n  office: Array<FieldWrapper<UiConfig>>;\n  companyGroup: Array<FieldWrapper<UiConfig>>;\n  user: Array<FieldWrapper<UiConfig>>;\n  all: Array<FieldWrapper<UiConfig>>;\n};\n\nexport enum UiConfigTarget {\n  All = 'ALL',\n  Mock = 'MOCK',\n  Lightning = 'LIGHTNING',\n  App = 'APP'\n}\n\nexport enum UiPresentation {\n  FreeText = 'FREE_TEXT',\n  AutoSuggest = 'AUTO_SUGGEST',\n  Dropdown = 'DROPDOWN',\n  Hidden = 'HIDDEN'\n}\n\nexport type User = {\n  __typename?: 'User';\n  id: FieldWrapper<Scalars['ID']>;\n  title: FieldWrapper<Scalars['String']>;\n  forename: FieldWrapper<Scalars['String']>;\n  surname: FieldWrapper<Scalars['String']>;\n  email: FieldWrapper<Scalars['String']>;\n  username: FieldWrapper<Scalars['String']>;\n  employeeId?: Maybe<FieldWrapper<Scalars['String']>>;\n  createdAt: FieldWrapper<Scalars['DateTime']>;\n  updatedAt: FieldWrapper<Scalars['DateTime']>;\n  dob: FieldWrapper<Scalars['Date']>;\n  admin?: Maybe<FieldWrapper<Scalars['Boolean']>>;\n  tmcAdmin?: Maybe<FieldWrapper<Scalars['Boolean']>>;\n  companyAdmin?: Maybe<FieldWrapper<Scalars['Boolean']>>;\n  bookerType: FieldWrapper<BookerType>;\n  authMethods: Array<FieldWrapper<Scalars['String']>>;\n  active: FieldWrapper<Scalars['Boolean']>;\n  passwordLastUpdated?: Maybe<FieldWrapper<Scalars['DateTime']>>;\n  selectedLanguage: FieldWrapper<Language>;\n  availableLanguages: Array<FieldWrapper<Language>>;\n  passports: Array<FieldWrapper<Passport>>;\n  tmc: FieldWrapper<Tmc>;\n  company: FieldWrapper<Company>;\n  office: FieldWrapper<Office>;\n  companyGroups: Array<FieldWrapper<CompanyGroup>>;\n  addresses: Array<FieldWrapper<Address>>;\n  phoneNumbers: Array<FieldWrapper<PhoneNumber>>;\n  approvers: Array<FieldWrapper<Approver>>;\n  approverFor: Array<FieldWrapper<Approvee>>;\n  bookers: Array<FieldWrapper<User>>;\n  canBookFor: Array<FieldWrapper<User>>;\n  co2AllowancePeriod?: Maybe<FieldWrapper<Scalars['String']>>;\n  co2AllowancePerPeriod?: Maybe<FieldWrapper<Scalars['String']>>;\n};\n\nexport type UserInfo = {\n  id: Scalars['ID'];\n  address?: Maybe<BookingAddress>;\n  phoneNumber?: Maybe<BookingPhoneNumber>;\n  supplementaryInfo: Scalars['JSON'];\n};\n\nexport type UserPassengerType = {\n  __typename?: 'UserPassengerType';\n  id: FieldWrapper<Scalars['ID']>;\n  passengerType: FieldWrapper<PassengerType>;\n};\n\nexport type UserPassengerTypeInput = {\n  id: Scalars['ID'];\n  passengerType: PassengerType;\n};\n\nexport type SubsequentLocations = {\n  __typename?: 'subsequentLocations';\n  locationName?: Maybe<FieldWrapper<Scalars['String']>>;\n  tiploc?: Maybe<FieldWrapper<Scalars['String']>>;\n  crs?: Maybe<FieldWrapper<Scalars['String']>>;\n  platform?: Maybe<FieldWrapper<Scalars['String']>>;\n  platformIsHidden?: Maybe<FieldWrapper<Scalars['String']>>;\n  sta?: Maybe<FieldWrapper<Scalars['String']>>;\n  eta?: Maybe<FieldWrapper<Scalars['String']>>;\n  arrivalType?: Maybe<FieldWrapper<Scalars['String']>>;\n  arrivalSource?: Maybe<FieldWrapper<Scalars['String']>>;\n  std?: Maybe<FieldWrapper<Scalars['String']>>;\n  etd?: Maybe<FieldWrapper<Scalars['String']>>;\n  departureType?: Maybe<FieldWrapper<Scalars['String']>>;\n  departureSource?: Maybe<FieldWrapper<Scalars['String']>>;\n  associations?: Maybe<Array<Maybe<FieldWrapper<Association>>>>;\n};\n\nexport type AcceptNewPriceMutationVariables = Exact<{\n  id: Scalars['ID'];\n  withSupplemental?: Maybe<Scalars['Boolean']>;\n}>;\n\n\nexport type AcceptNewPriceMutation = (\n  { __typename?: 'Mutation' }\n  & { acceptNewPrice: (\n    { __typename?: 'Basket' }\n    & BasketFieldsFragment\n  ) }\n);\n\nexport type AddUsersToBasketItemMutationVariables = Exact<{\n  basketItem: Scalars['ID'];\n  users: Array<UserPassengerTypeInput> | UserPassengerTypeInput;\n  withSupplemental: Scalars['Boolean'];\n}>;\n\n\nexport type AddUsersToBasketItemMutation = (\n  { __typename?: 'Mutation' }\n  & { addUsersToBasketItem: (\n    { __typename?: 'Basket' }\n    & BasketFieldsFragment\n  ) }\n);\n\nexport type TravellerFieldsFragment = (\n  { __typename?: 'User' }\n  & Pick<User, 'id' | 'title' | 'forename' | 'surname' | 'email' | 'username' | 'employeeId'>\n);\n\nexport type OwnerFieldsFragment = (\n  { __typename?: 'User' }\n  & Pick<User, 'id' | 'title' | 'forename' | 'surname' | 'email'>\n);\n\nexport type BasketFieldsFragment = (\n  { __typename?: 'Basket' }\n  & Pick<Basket, 'id' | 'reference' | 'title' | 'notes' | 'createdAt' | 'updatedAt' | 'bookedAt' | 'status' | 'validated'>\n  & { owner: (\n    { __typename?: 'User' }\n    & OwnerFieldsFragment\n  ), basketItems: Array<(\n    { __typename?: 'BasketItem' }\n    & MakeOptional<Pick<BasketItem, 'id' | 'adults' | 'children' | 'infants' | 'detail' | 'detailHash' | 'createdAt' | 'updatedAt' | 'expiry' | 'expired' | 'searchQuery' | 'price' | 'currency' | 'miGroupsAvailable' | 'miGroupSelected' | 'validated' | 'latestValidation' | 'latestValidationPrice' | 'latestValidationPriceDifference' | 'latestValidationAvailable' | 'bookingThirdPartyReference' | 'pnrLocator' | 'status' | 'perItemSupplementaryBookingInfoSchema' | 'perPassengerSupplementaryBookingInfoSchema' | 'perItemAddress' | 'perItemPhoneNumber' | 'perPassengerAddress' | 'perPassengerPhoneNumber' | 'cancellable' | 'amendable' | 'co2PerItem' | 'co2PerPassenger' | 'outboundDate' | 'inboundDate'>, 'perItemSupplementaryBookingInfoSchema' | 'perPassengerSupplementaryBookingInfoSchema' | 'perItemAddress' | 'perItemPhoneNumber' | 'perPassengerAddress' | 'perPassengerPhoneNumber'>\n    & { availablePaymentMethods: Array<(\n      { __typename?: 'PaymentMethod' }\n      & Pick<PaymentMethod, 'id' | 'name' | 'description'>\n    )>, selectedPaymentMethod?: Maybe<(\n      { __typename?: 'PaymentMethod' }\n      & Pick<PaymentMethod, 'id' | 'name' | 'description'>\n    )>, service: (\n      { __typename?: 'Service' }\n      & Pick<Service, 'id' | 'type'>\n    ), users: Array<(\n      { __typename?: 'User' }\n      & TravellerFieldsFragment\n    )>, userPassengerTypes: Array<(\n      { __typename?: 'UserPassengerType' }\n      & Pick<UserPassengerType, 'id' | 'passengerType'>\n    )>, leadPassenger?: Maybe<(\n      { __typename?: 'User' }\n      & TravellerFieldsFragment\n    )>, managementInfo: Array<(\n      { __typename?: 'ManagementInfo' }\n      & Pick<ManagementInfo, 'id' | 'dbId' | 'name' | 'description' | 'handoff' | 'valueMask' | 'uiPresentation' | 'mandatory' | 'perPassenger' | 'perBooking' | 'agentOnly' | 'createdAt' | 'updatedAt' | 'fixed' | 'group'>\n      & { fixedValue?: Maybe<(\n        { __typename?: 'ManagementInfoValue' }\n        & Pick<ManagementInfoValue, 'id' | 'label' | 'value' | 'default' | 'fixed' | 'agentOnly'>\n      )>, defaultValue?: Maybe<(\n        { __typename?: 'ManagementInfoValue' }\n        & Pick<ManagementInfoValue, 'id' | 'label' | 'value' | 'default' | 'fixed' | 'agentOnly'>\n      )>, values: Array<(\n        { __typename?: 'ManagementInfoValue' }\n        & Pick<ManagementInfoValue, 'id' | 'label' | 'value' | 'default' | 'fixed' | 'agentOnly'>\n      )>, selectedValues: Array<(\n        { __typename?: 'SelectedManagementInfoValue' }\n        & Pick<SelectedManagementInfoValue, 'freeValue' | 'basketLevelValue' | 'userLevelValue'>\n        & { value?: Maybe<(\n          { __typename?: 'ManagementInfoValue' }\n          & Pick<ManagementInfoValue, 'id' | 'label' | 'value' | 'default' | 'fixed' | 'agentOnly'>\n        )>, user?: Maybe<(\n          { __typename?: 'User' }\n          & Pick<User, 'id' | 'title' | 'forename' | 'surname' | 'email' | 'username' | 'employeeId' | 'createdAt' | 'updatedAt' | 'dob' | 'admin' | 'companyAdmin' | 'bookerType' | 'authMethods' | 'active' | 'passwordLastUpdated'>\n        )> }\n      )> }\n    )> }\n  )>, companyGroup?: Maybe<(\n    { __typename?: 'CompanyGroup' }\n    & Pick<CompanyGroup, 'id' | 'name' | 'description' | 'createdAt' | 'updatedAt'>\n  )> }\n);\n\nexport type GetUserBasketsQueryVariables = Exact<{\n  user?: Maybe<Scalars['ID']>;\n  traveller?: Maybe<Scalars['ID']>;\n  basketStatus?: Maybe<BasketStatus>;\n  createdAfter?: Maybe<Scalars['DateTime']>;\n  createdBefore?: Maybe<Scalars['DateTime']>;\n  bookedAfter?: Maybe<Scalars['DateTime']>;\n  bookedBefore?: Maybe<Scalars['DateTime']>;\n  dateOfTravelBefore?: Maybe<Scalars['DateTime']>;\n  dateOfTravelAfter?: Maybe<Scalars['DateTime']>;\n  basketItemBookingReference?: Maybe<Scalars['String']>;\n  basketReference?: Maybe<Scalars['String']>;\n  basketTitle?: Maybe<Scalars['String']>;\n  withSupplemental?: Maybe<Scalars['Boolean']>;\n}>;\n\n\nexport type GetUserBasketsQuery = (\n  { __typename?: 'Query' }\n  & { getUserBaskets: Array<(\n    { __typename?: 'Basket' }\n    & BasketFieldsFragment\n  )> }\n);\n\nexport type DeleteBasketMutationVariables = Exact<{\n  id?: Maybe<Scalars['ID']>;\n  reference?: Maybe<Scalars['String']>;\n}>;\n\n\nexport type DeleteBasketMutation = (\n  { __typename?: 'Mutation' }\n  & Pick<Mutation, 'deleteBasket'>\n);\n\nexport type CreateBasketMutationVariables = Exact<{\n  title?: Maybe<Scalars['String']>;\n  withSupplemental?: Maybe<Scalars['Boolean']>;\n}>;\n\n\nexport type CreateBasketMutation = (\n  { __typename?: 'Mutation' }\n  & { createBasket: (\n    { __typename?: 'Basket' }\n    & BasketFieldsFragment\n  ) }\n);\n\nexport type RemoveItemFromBasketMutationVariables = Exact<{\n  basketItem: Scalars['ID'];\n  withSupplemental?: Maybe<Scalars['Boolean']>;\n}>;\n\n\nexport type RemoveItemFromBasketMutation = (\n  { __typename?: 'Mutation' }\n  & { removeItemFromBasket: (\n    { __typename?: 'Basket' }\n    & BasketFieldsFragment\n  ) }\n);\n\nexport type SendBasketForApprovalMutationVariables = Exact<{\n  basket: Scalars['ID'];\n  withSupplemental?: Maybe<Scalars['Boolean']>;\n}>;\n\n\nexport type SendBasketForApprovalMutation = (\n  { __typename?: 'Mutation' }\n  & { sendBasketForApproval: (\n    { __typename?: 'Basket' }\n    & BasketFieldsFragment\n  ) }\n);\n\nexport type AddItemToBasketMutationVariables = Exact<{\n  basket?: Maybe<Scalars['ID']>;\n  service: Scalars['ID'];\n  detail: Scalars['JSON'];\n  adults: Scalars['Int'];\n  children?: Maybe<Scalars['Int']>;\n  infants?: Maybe<Scalars['Int']>;\n  price: Scalars['Float'];\n  currency: CurrencyCode;\n  searchQuery: Scalars['JSON'];\n  quickAdd?: Maybe<Scalars['Boolean']>;\n  users?: Maybe<Array<Maybe<UserPassengerTypeInput>> | Maybe<UserPassengerTypeInput>>;\n  leadPassenger?: Maybe<Scalars['ID']>;\n  co2PerItem?: Maybe<Scalars['Float']>;\n  co2PerPassenger?: Maybe<Scalars['Float']>;\n  outboundDate: Scalars['DateTime'];\n  inboundDate?: Maybe<Scalars['DateTime']>;\n  withSupplemental?: Maybe<Scalars['Boolean']>;\n}>;\n\n\nexport type AddItemToBasketMutation = (\n  { __typename?: 'Mutation' }\n  & { addItemToBasket: (\n    { __typename?: 'Basket' }\n    & BasketFieldsFragment\n  ) }\n);\n\nexport type GetUserBasketQueryVariables = Exact<{\n  id: Scalars['ID'];\n  withSupplemental?: Maybe<Scalars['Boolean']>;\n}>;\n\n\nexport type GetUserBasketQuery = (\n  { __typename?: 'Query' }\n  & { getUserBasket: (\n    { __typename?: 'Basket' }\n    & BasketFieldsFragment\n  ) }\n);\n\nexport type RevalidateBasketMutationVariables = Exact<{\n  id: Scalars['ID'];\n  withSupplemental?: Maybe<Scalars['Boolean']>;\n}>;\n\n\nexport type RevalidateBasketMutation = (\n  { __typename?: 'Mutation' }\n  & { revalidateBasket: (\n    { __typename?: 'Basket' }\n    & BasketFieldsFragment\n  ) }\n);\n\nexport type BookBasketMutationVariables = Exact<{\n  id: Scalars['ID'];\n  supplementaryInfo: Array<SupplementaryBookingInfo> | SupplementaryBookingInfo;\n  withSupplemental?: Maybe<Scalars['Boolean']>;\n}>;\n\n\nexport type BookBasketMutation = (\n  { __typename?: 'Mutation' }\n  & { bookBasket: (\n    { __typename?: 'Basket' }\n    & BasketFieldsFragment\n  ) }\n);\n\nexport type SearchCabHireQueryVariables = Exact<{\n  departs: Scalars['DateTime'];\n  fromLocation: CabHireLocationInput;\n  toLocation: CabHireLocationInput;\n  adults: Scalars['Int'];\n  children?: Maybe<Scalars['Int']>;\n  infants?: Maybe<Scalars['Int']>;\n  vias?: Maybe<Array<Maybe<CabHireLocationInput>> | Maybe<CabHireLocationInput>>;\n  vehicleType?: Maybe<CabHireVehicleType>;\n}>;\n\n\nexport type SearchCabHireQuery = (\n  { __typename?: 'Query' }\n  & { searchCabHire: (\n    { __typename?: 'CabHireResult' }\n    & { results: Array<(\n      { __typename?: 'CabHireQuote' }\n      & Pick<CabHireQuote, 'id' | 'source' | 'sourceId' | 'supplierName' | 'estimatedCO2' | 'co2PerItem' | 'co2PerPassenger' | 'price' | 'currency' | 'vehicleType' | 'tripDistanceMetres' | 'tripDurationSeconds' | 'departs' | 'tmcPreferred' | 'companyPreferred' | 'officePreferred' | 'tmcPreferredMessage' | 'companyPreferredMessage' | 'officePreferredMessage' | 'unavailable' | 'unavailableMessage'>\n      & { fromLocation: (\n        { __typename?: 'CabHireLocation' }\n        & Pick<CabHireLocation, 'address' | 'postcode' | 'latitude' | 'longitude'>\n      ), toLocation: (\n        { __typename?: 'CabHireLocation' }\n        & Pick<CabHireLocation, 'address' | 'postcode' | 'latitude' | 'longitude'>\n      ), vias: Array<(\n        { __typename?: 'CabHireLocation' }\n        & Pick<CabHireLocation, 'address' | 'postcode' | 'latitude' | 'longitude'>\n      )> }\n    )>, errors: Array<(\n      { __typename?: 'SearchError' }\n      & ErrorsFragment\n    )> }\n  ) }\n);\n\nexport type CarHireAvailabilityDetailRequestQueryVariables = Exact<{\n  locationDetails: CarHireInputIdentifiers;\n}>;\n\n\nexport type CarHireAvailabilityDetailRequestQuery = (\n  { __typename?: 'Query' }\n  & { carHireAvailabilityDetailRequest: (\n    { __typename?: 'CarHireDetailRequestResponse' }\n    & { identifiers?: Maybe<(\n      { __typename?: 'CarHireIdentifiers' }\n      & Pick<CarHireIdentifiers, 'locator' | 'rph' | 'status' | 'vehType' | 'locationCode' | 'extendedLocationCode' | 'locationName' | 'dropOffLocation' | 'pickupDateTime' | 'dropoffDateTime' | 'vendor'>\n    )>, vendor?: Maybe<(\n      { __typename?: 'CarHireVendor' }\n      & Pick<CarHireVendor, 'name' | 'logo'>\n    )>, address?: Maybe<(\n      { __typename?: 'CarHireAddress' }\n      & Pick<CarHireAddress, 'name' | 'topLine' | 'city' | 'region' | 'postCode' | 'country' | 'countryCode' | 'stateCode' | 'latitude' | 'longitude'>\n    )>, additionalInfo?: Maybe<Array<(\n      { __typename?: 'CarHireAdditionalInfoItem' }\n      & Pick<CarHireAdditionalInfoItem, 'name' | 'text' | 'json'>\n      & { custom?: Maybe<Array<Maybe<(\n        { __typename?: 'CarHireCustom' }\n        & Pick<CarHireCustom, 'name' | 'text'>\n      )>>> }\n    )>> }\n  ) }\n);\n\nexport type SearchCarHireQueryVariables = Exact<{\n  airport?: Maybe<CarHireAirportInput>;\n  city?: Maybe<CarHireCityInput>;\n  location?: Maybe<CarHireLocationInput>;\n  depot?: Maybe<InputCarHireDepot>;\n  pickupDateTime: Scalars['DateTime'];\n  dropoffDateTime: Scalars['DateTime'];\n  vendor?: Maybe<Scalars['String']>;\n  class?: Maybe<CarHireClass>;\n  type?: Maybe<CarHireType>;\n  transmission?: Maybe<CarHireTransmission>;\n  aircon?: Maybe<Scalars['Boolean']>;\n  estimatedDailyDistance?: Maybe<Scalars['Float']>;\n  estimatedDailyDistanceUnits?: Maybe<DistanceTypes>;\n}>;\n\n\nexport type SearchCarHireQuery = (\n  { __typename?: 'Query' }\n  & { searchCarHire: (\n    { __typename?: 'CarHireResult' }\n    & { results: Array<(\n      { __typename?: 'CarHireVehicleAvailibility' }\n      & Pick<CarHireVehicleAvailibility, 'source' | 'sourceId' | 'tmcPreferred' | 'companyPreferred' | 'officePreferred' | 'tmcPreferredMessage' | 'companyPreferredMessage' | 'officePreferredMessage' | 'unavailable' | 'unavailableMessage' | 'co2PerPassenger' | 'co2PerItem'>\n      & { identifiers?: Maybe<(\n        { __typename?: 'CarHireIdentifiers' }\n        & Pick<CarHireIdentifiers, 'locator' | 'rph' | 'status' | 'vehType' | 'locationCode' | 'extendedLocationCode' | 'locationName' | 'dropOffLocation' | 'pickupDateTime' | 'dropoffDateTime' | 'vendor'>\n      )>, displayRecord?: Maybe<(\n        { __typename?: 'CarHireDisplayRecord' }\n        & Pick<CarHireDisplayRecord, 'status' | 'pickup' | 'dropoff'>\n        & { vendor?: Maybe<(\n          { __typename?: 'CarHireVendor' }\n          & Pick<CarHireVendor, 'name' | 'logo'>\n        )>, vehicle?: Maybe<(\n          { __typename?: 'CarHireVehicle' }\n          & Pick<CarHireVehicle, 'class' | 'type' | 'transmission' | 'aircon' | 'description' | 'images'>\n        )>, charges?: Maybe<Array<Maybe<(\n          { __typename?: 'CarHireCharge' }\n          & Pick<CarHireCharge, 'label' | 'amount' | 'currencyCode'>\n        )>>>, pickupLocation?: Maybe<(\n          { __typename?: 'CarHireAddress' }\n          & Pick<CarHireAddress, 'name' | 'topLine' | 'city' | 'region' | 'postCode' | 'country' | 'countryCode' | 'stateCode' | 'latitude' | 'longitude'>\n        )>, returnLocation?: Maybe<(\n          { __typename?: 'CarHireAddress' }\n          & Pick<CarHireAddress, 'name' | 'topLine' | 'city' | 'region' | 'postCode' | 'country' | 'countryCode' | 'stateCode' | 'latitude' | 'longitude'>\n        )>, additionalInfo?: Maybe<Array<Maybe<(\n          { __typename?: 'CarHireAdditionalInfoItem' }\n          & Pick<CarHireAdditionalInfoItem, 'name' | 'text' | 'json'>\n          & { custom?: Maybe<Array<Maybe<(\n            { __typename?: 'CarHireCustom' }\n            & Pick<CarHireCustom, 'name' | 'text'>\n          )>>> }\n        )>>> }\n      )> }\n    )>, errors: Array<(\n      { __typename?: 'SearchError' }\n      & ErrorsFragment\n    )> }\n  ) }\n);\n\nexport type DeleteRecentSearchMutationVariables = Exact<{\n  id: Scalars['ID'];\n}>;\n\n\nexport type DeleteRecentSearchMutation = (\n  { __typename?: 'Mutation' }\n  & Pick<Mutation, 'deleteRecentSearch'>\n);\n\nexport type DeleteUserAddressMutationVariables = Exact<{\n  id: Scalars['ID'];\n}>;\n\n\nexport type DeleteUserAddressMutation = (\n  { __typename?: 'Mutation' }\n  & Pick<Mutation, 'deleteUserAddress'>\n);\n\nexport type ErrorsFragment = (\n  { __typename?: 'SearchError' }\n  & Pick<SearchError, 'errorMessage' | 'errorCode'>\n  & { service: (\n    { __typename?: 'Service' }\n    & Pick<Service, 'id' | 'type' | 'name' | 'description'>\n  ) }\n);\n\nexport type GroupedFieldsFragment = (\n  { __typename?: 'GroupFlights' }\n  & Pick<GroupFlights, 'referenceID' | 'flightID' | 'boundIndicator' | 'minPrice' | 'maxPrice'>\n  & { flights: (\n    { __typename?: 'MatchingFlights' }\n    & Pick<MatchingFlights, 'EconomyRestricted' | 'EconomyNoBags' | 'EconomyFlexi' | 'PremiumEconomy' | 'Business' | 'First'>\n  ) }\n);\n\nexport type SearchFlightsV2QueryVariables = Exact<{\n  passengers: Array<FlightPassengerObject> | FlightPassengerObject;\n  originAirport?: Maybe<Scalars['String']>;\n  destinationAirport?: Maybe<Scalars['String']>;\n  multiDestination?: Maybe<Array<Maybe<DestinationEntry>> | Maybe<DestinationEntry>>;\n  outboundDate?: Maybe<Scalars['Date']>;\n  outboundDepartureTimeWindow?: Maybe<Scalars['String']>;\n  outboundArrivalTimeWindow?: Maybe<Scalars['String']>;\n  outboundCabinClass?: Maybe<Array<Maybe<FlightCabinClass>> | Maybe<FlightCabinClass>>;\n  returnTrip: Scalars['Boolean'];\n  returnDate?: Maybe<Scalars['Date']>;\n  returnDepartureTimeWindow?: Maybe<Scalars['String']>;\n  returnArrivalTimeWindow?: Maybe<Scalars['String']>;\n  returnCabinClass?: Maybe<Array<Maybe<FlightCabinClass>> | Maybe<FlightCabinClass>>;\n  fareType: FareType;\n  requireFreeBag?: Maybe<Scalars['Boolean']>;\n  maxConnections?: Maybe<Scalars['Int']>;\n  preferredCarriers?: Maybe<Array<Maybe<Scalars['String']>> | Maybe<Scalars['String']>>;\n  includeNearbyAirports?: Maybe<Scalars['Boolean']>;\n  asSingles?: Maybe<Scalars['Boolean']>;\n  withGrouped: Scalars['Boolean'];\n}>;\n\n\nexport type SearchFlightsV2Query = (\n  { __typename?: 'Query' }\n  & { searchFlightsV2: (\n    { __typename?: 'FlightSearchResultV2' }\n    & { results: (\n      { __typename?: 'FEFlightSearchResults' }\n      & { journeys: Array<(\n        { __typename?: 'FlightItinerary' }\n        & Pick<FlightItinerary, 'uid' | 'passengerCount' | 'outboundTotalDuration' | 'inboundTotalDuration' | 'additional' | 'source' | 'sourceId' | 'version' | 'tmcPreferred' | 'companyPreferred' | 'officePreferred' | 'tmcPreferredMessage' | 'companyPreferredMessage' | 'officePreferredMessage' | 'unavailable' | 'unavailableMessage' | 'co2PerItem' | 'co2PerPassenger'>\n        & { outboundFlights: Array<(\n          { __typename?: 'FlightJourney' }\n          & Pick<FlightJourney, 'originAirport' | 'originTerminal' | 'originAirportName' | 'destinationAirport' | 'destinationTerminal' | 'destinationAirportName' | 'dateTimeDeparting' | 'dateTimeDepartingUTC' | 'dateTimeArriving' | 'dateTimeArrivingUTC' | 'marketingCarrier' | 'marketingCarrierName' | 'marketingFlightNumber' | 'operatingCarrier' | 'operatingCarrierName' | 'operatingFlightNumber' | 'equipmentCode' | 'equipmentName' | 'totalDuration' | 'cabinClass' | 'marketingNames' | 'vendorCode' | 'stops' | 'bookingCode' | 'marriageGroup' | 'fareBasisCode' | 'additional'>\n          & { originAirportDetail: (\n            { __typename?: 'AirportDetail' }\n            & Pick<AirportDetail, 'iata' | 'icao' | 'latitude' | 'longitude' | 'altitude' | 'state' | 'city' | 'road' | 'popularity' | 'area' | 'location' | 'offset' | 'airportName' | 'countryName' | 'countryCode' | 'postcode'>\n          ), destinationAirportDetail: (\n            { __typename?: 'AirportDetail' }\n            & Pick<AirportDetail, 'iata' | 'icao' | 'latitude' | 'longitude' | 'altitude' | 'state' | 'city' | 'road' | 'popularity' | 'area' | 'location' | 'offset' | 'airportName' | 'countryName' | 'countryCode' | 'postcode'>\n          ), marketingCarrierDetail: (\n            { __typename?: 'FlightCarrierDetail' }\n            & Pick<FlightCarrierDetail, 'name' | 'alias' | 'callsign' | 'iata' | 'icao' | 'logo' | 'banner' | 'popularity'>\n          ), operatingCarrierDetail: (\n            { __typename?: 'FlightCarrierDetail' }\n            & Pick<FlightCarrierDetail, 'name' | 'alias' | 'callsign' | 'iata' | 'icao' | 'logo' | 'banner' | 'popularity'>\n          ), fareConditions: (\n            { __typename?: 'FareConditions' }\n            & { cancellation?: Maybe<Array<Maybe<(\n              { __typename?: 'FareConditionEntry' }\n              & Pick<FareConditionEntry, 'name' | 'type' | 'currency' | 'amount' | 'remark' | 'changeFeeInd' | 'cancelFeeInd' | 'refundableInd'>\n            )>>>, change?: Maybe<Array<Maybe<(\n              { __typename?: 'FareConditionEntry' }\n              & Pick<FareConditionEntry, 'name' | 'type' | 'currency' | 'amount' | 'remark' | 'changeFeeInd' | 'cancelFeeInd' | 'refundableInd'>\n            )>>>, noShow?: Maybe<Array<Maybe<(\n              { __typename?: 'FareConditionEntry' }\n              & Pick<FareConditionEntry, 'name' | 'type' | 'currency' | 'amount' | 'remark' | 'changeFeeInd' | 'cancelFeeInd' | 'refundableInd'>\n            )>>>, upgrade?: Maybe<Array<Maybe<(\n              { __typename?: 'FareConditionEntry' }\n              & Pick<FareConditionEntry, 'name' | 'type' | 'currency' | 'amount' | 'remark' | 'changeFeeInd' | 'cancelFeeInd' | 'refundableInd'>\n            )>>>, other?: Maybe<Array<Maybe<(\n              { __typename?: 'FareConditionEntry' }\n              & Pick<FareConditionEntry, 'name' | 'type' | 'currency' | 'amount' | 'remark' | 'changeFeeInd' | 'cancelFeeInd' | 'refundableInd'>\n            )>>> }\n          ) }\n        )>, inboundFlights?: Maybe<Array<Maybe<(\n          { __typename?: 'FlightJourney' }\n          & Pick<FlightJourney, 'originAirport' | 'originTerminal' | 'originAirportName' | 'destinationAirport' | 'destinationTerminal' | 'destinationAirportName' | 'dateTimeDeparting' | 'dateTimeDepartingUTC' | 'dateTimeArriving' | 'dateTimeArrivingUTC' | 'marketingCarrier' | 'marketingCarrierName' | 'marketingFlightNumber' | 'operatingCarrier' | 'operatingCarrierName' | 'operatingFlightNumber' | 'equipmentCode' | 'equipmentName' | 'totalDuration' | 'cabinClass' | 'marketingNames' | 'vendorCode' | 'stops' | 'bookingCode' | 'marriageGroup' | 'fareBasisCode' | 'additional'>\n          & { originAirportDetail: (\n            { __typename?: 'AirportDetail' }\n            & Pick<AirportDetail, 'iata' | 'icao' | 'latitude' | 'longitude' | 'altitude' | 'state' | 'city' | 'road' | 'popularity' | 'area' | 'location' | 'offset' | 'airportName' | 'countryName' | 'countryCode' | 'postcode'>\n          ), destinationAirportDetail: (\n            { __typename?: 'AirportDetail' }\n            & Pick<AirportDetail, 'iata' | 'icao' | 'latitude' | 'longitude' | 'altitude' | 'state' | 'city' | 'road' | 'popularity' | 'area' | 'location' | 'offset' | 'airportName' | 'countryName' | 'countryCode' | 'postcode'>\n          ), marketingCarrierDetail: (\n            { __typename?: 'FlightCarrierDetail' }\n            & Pick<FlightCarrierDetail, 'name' | 'alias' | 'callsign' | 'iata' | 'icao' | 'logo' | 'banner' | 'popularity'>\n          ), operatingCarrierDetail: (\n            { __typename?: 'FlightCarrierDetail' }\n            & Pick<FlightCarrierDetail, 'name' | 'alias' | 'callsign' | 'iata' | 'icao' | 'logo' | 'banner' | 'popularity'>\n          ), fareConditions: (\n            { __typename?: 'FareConditions' }\n            & { cancellation?: Maybe<Array<Maybe<(\n              { __typename?: 'FareConditionEntry' }\n              & Pick<FareConditionEntry, 'name' | 'type' | 'currency' | 'amount' | 'remark' | 'changeFeeInd' | 'cancelFeeInd' | 'refundableInd'>\n            )>>>, change?: Maybe<Array<Maybe<(\n              { __typename?: 'FareConditionEntry' }\n              & Pick<FareConditionEntry, 'name' | 'type' | 'currency' | 'amount' | 'remark' | 'changeFeeInd' | 'cancelFeeInd' | 'refundableInd'>\n            )>>>, noShow?: Maybe<Array<Maybe<(\n              { __typename?: 'FareConditionEntry' }\n              & Pick<FareConditionEntry, 'name' | 'type' | 'currency' | 'amount' | 'remark' | 'changeFeeInd' | 'cancelFeeInd' | 'refundableInd'>\n            )>>>, upgrade?: Maybe<Array<Maybe<(\n              { __typename?: 'FareConditionEntry' }\n              & Pick<FareConditionEntry, 'name' | 'type' | 'currency' | 'amount' | 'remark' | 'changeFeeInd' | 'cancelFeeInd' | 'refundableInd'>\n            )>>>, other?: Maybe<Array<Maybe<(\n              { __typename?: 'FareConditionEntry' }\n              & Pick<FareConditionEntry, 'name' | 'type' | 'currency' | 'amount' | 'remark' | 'changeFeeInd' | 'cancelFeeInd' | 'refundableInd'>\n            )>>> }\n          ) }\n        )>>>, outboundCarbonEmissions?: Maybe<(\n          { __typename?: 'FlightCarbonEmissions' }\n          & Pick<FlightCarbonEmissions, 'amount' | 'unit'>\n        )>, inboundCarbonEmissions?: Maybe<(\n          { __typename?: 'FlightCarbonEmissions' }\n          & Pick<FlightCarbonEmissions, 'amount' | 'unit'>\n        )>, taxes?: Maybe<Array<Maybe<(\n          { __typename?: 'FlightAmount' }\n          & Pick<FlightAmount, 'description' | 'amount' | 'currency'>\n        )>>>, discounts?: Maybe<Array<Maybe<(\n          { __typename?: 'FlightAmount' }\n          & Pick<FlightAmount, 'description' | 'amount' | 'currency'>\n        )>>>, total: (\n          { __typename?: 'FlightFareTotal' }\n          & Pick<FlightFareTotal, 'price' | 'tax' | 'discount' | 'currency'>\n        ), fareConditions?: Maybe<(\n          { __typename?: 'FareConditions' }\n          & { cancellation?: Maybe<Array<Maybe<(\n            { __typename?: 'FareConditionEntry' }\n            & Pick<FareConditionEntry, 'name' | 'type' | 'currency' | 'amount' | 'remark' | 'changeFeeInd' | 'cancelFeeInd' | 'refundableInd'>\n          )>>>, change?: Maybe<Array<Maybe<(\n            { __typename?: 'FareConditionEntry' }\n            & Pick<FareConditionEntry, 'name' | 'type' | 'currency' | 'amount' | 'remark' | 'changeFeeInd' | 'cancelFeeInd' | 'refundableInd'>\n          )>>>, noShow?: Maybe<Array<Maybe<(\n            { __typename?: 'FareConditionEntry' }\n            & Pick<FareConditionEntry, 'name' | 'type' | 'currency' | 'amount' | 'remark' | 'changeFeeInd' | 'cancelFeeInd' | 'refundableInd'>\n          )>>>, upgrade?: Maybe<Array<Maybe<(\n            { __typename?: 'FareConditionEntry' }\n            & Pick<FareConditionEntry, 'name' | 'type' | 'currency' | 'amount' | 'remark' | 'changeFeeInd' | 'cancelFeeInd' | 'refundableInd'>\n          )>>>, other?: Maybe<Array<Maybe<(\n            { __typename?: 'FareConditionEntry' }\n            & Pick<FareConditionEntry, 'name' | 'type' | 'currency' | 'amount' | 'remark' | 'changeFeeInd' | 'cancelFeeInd' | 'refundableInd'>\n          )>>> }\n        )>, baggageAllowance?: Maybe<Array<Maybe<(\n          { __typename?: 'BaggageAllowance' }\n          & Pick<BaggageAllowance, 'type' | 'qty' | 'maxKG' | 'maxLBS'>\n        )>>> }\n      )>, multi: Array<(\n        { __typename?: 'ItinerarySummary' }\n        & Pick<ItinerarySummary, 'order' | 'origin' | 'destination' | 'minPrice' | 'maxPrice'>\n        & { results: Array<(\n          { __typename?: 'FlightItinerary' }\n          & Pick<FlightItinerary, 'uid' | 'passengerCount' | 'outboundTotalDuration' | 'inboundTotalDuration' | 'additional' | 'source' | 'sourceId' | 'version' | 'tmcPreferred' | 'companyPreferred' | 'officePreferred' | 'tmcPreferredMessage' | 'companyPreferredMessage' | 'officePreferredMessage' | 'unavailable' | 'unavailableMessage' | 'co2PerItem' | 'co2PerPassenger'>\n          & { outboundFlights: Array<(\n            { __typename?: 'FlightJourney' }\n            & Pick<FlightJourney, 'originAirport' | 'originTerminal' | 'originAirportName' | 'destinationAirport' | 'destinationTerminal' | 'destinationAirportName' | 'dateTimeDeparting' | 'dateTimeDepartingUTC' | 'dateTimeArriving' | 'dateTimeArrivingUTC' | 'marketingCarrier' | 'marketingCarrierName' | 'marketingFlightNumber' | 'operatingCarrier' | 'operatingCarrierName' | 'operatingFlightNumber' | 'equipmentCode' | 'equipmentName' | 'totalDuration' | 'cabinClass' | 'marketingNames' | 'vendorCode' | 'stops' | 'bookingCode' | 'marriageGroup' | 'fareBasisCode' | 'additional'>\n            & { originAirportDetail: (\n              { __typename?: 'AirportDetail' }\n              & Pick<AirportDetail, 'iata' | 'icao' | 'latitude' | 'longitude' | 'altitude' | 'state' | 'city' | 'road' | 'popularity' | 'area' | 'location' | 'offset' | 'airportName' | 'countryName' | 'countryCode' | 'postcode'>\n            ), destinationAirportDetail: (\n              { __typename?: 'AirportDetail' }\n              & Pick<AirportDetail, 'iata' | 'icao' | 'latitude' | 'longitude' | 'altitude' | 'state' | 'city' | 'road' | 'popularity' | 'area' | 'location' | 'offset' | 'airportName' | 'countryName' | 'countryCode' | 'postcode'>\n            ), marketingCarrierDetail: (\n              { __typename?: 'FlightCarrierDetail' }\n              & Pick<FlightCarrierDetail, 'name' | 'alias' | 'callsign' | 'iata' | 'icao' | 'logo' | 'banner' | 'popularity'>\n            ), operatingCarrierDetail: (\n              { __typename?: 'FlightCarrierDetail' }\n              & Pick<FlightCarrierDetail, 'name' | 'alias' | 'callsign' | 'iata' | 'icao' | 'logo' | 'banner' | 'popularity'>\n            ), fareConditions: (\n              { __typename?: 'FareConditions' }\n              & { cancellation?: Maybe<Array<Maybe<(\n                { __typename?: 'FareConditionEntry' }\n                & Pick<FareConditionEntry, 'name' | 'type' | 'currency' | 'amount' | 'remark' | 'changeFeeInd' | 'cancelFeeInd' | 'refundableInd'>\n              )>>>, change?: Maybe<Array<Maybe<(\n                { __typename?: 'FareConditionEntry' }\n                & Pick<FareConditionEntry, 'name' | 'type' | 'currency' | 'amount' | 'remark' | 'changeFeeInd' | 'cancelFeeInd' | 'refundableInd'>\n              )>>>, noShow?: Maybe<Array<Maybe<(\n                { __typename?: 'FareConditionEntry' }\n                & Pick<FareConditionEntry, 'name' | 'type' | 'currency' | 'amount' | 'remark' | 'changeFeeInd' | 'cancelFeeInd' | 'refundableInd'>\n              )>>>, upgrade?: Maybe<Array<Maybe<(\n                { __typename?: 'FareConditionEntry' }\n                & Pick<FareConditionEntry, 'name' | 'type' | 'currency' | 'amount' | 'remark' | 'changeFeeInd' | 'cancelFeeInd' | 'refundableInd'>\n              )>>>, other?: Maybe<Array<Maybe<(\n                { __typename?: 'FareConditionEntry' }\n                & Pick<FareConditionEntry, 'name' | 'type' | 'currency' | 'amount' | 'remark' | 'changeFeeInd' | 'cancelFeeInd' | 'refundableInd'>\n              )>>> }\n            ) }\n          )>, inboundFlights?: Maybe<Array<Maybe<(\n            { __typename?: 'FlightJourney' }\n            & Pick<FlightJourney, 'originAirport' | 'originTerminal' | 'originAirportName' | 'destinationAirport' | 'destinationTerminal' | 'destinationAirportName' | 'dateTimeDeparting' | 'dateTimeDepartingUTC' | 'dateTimeArriving' | 'dateTimeArrivingUTC' | 'marketingCarrier' | 'marketingCarrierName' | 'marketingFlightNumber' | 'operatingCarrier' | 'operatingCarrierName' | 'operatingFlightNumber' | 'equipmentCode' | 'equipmentName' | 'totalDuration' | 'cabinClass' | 'marketingNames' | 'vendorCode' | 'stops' | 'bookingCode' | 'marriageGroup' | 'fareBasisCode' | 'additional'>\n            & { originAirportDetail: (\n              { __typename?: 'AirportDetail' }\n              & Pick<AirportDetail, 'iata' | 'icao' | 'latitude' | 'longitude' | 'altitude' | 'state' | 'city' | 'road' | 'popularity' | 'area' | 'location' | 'offset' | 'airportName' | 'countryName' | 'countryCode' | 'postcode'>\n            ), destinationAirportDetail: (\n              { __typename?: 'AirportDetail' }\n              & Pick<AirportDetail, 'iata' | 'icao' | 'latitude' | 'longitude' | 'altitude' | 'state' | 'city' | 'road' | 'popularity' | 'area' | 'location' | 'offset' | 'airportName' | 'countryName' | 'countryCode' | 'postcode'>\n            ), marketingCarrierDetail: (\n              { __typename?: 'FlightCarrierDetail' }\n              & Pick<FlightCarrierDetail, 'name' | 'alias' | 'callsign' | 'iata' | 'icao' | 'logo' | 'banner' | 'popularity'>\n            ), operatingCarrierDetail: (\n              { __typename?: 'FlightCarrierDetail' }\n              & Pick<FlightCarrierDetail, 'name' | 'alias' | 'callsign' | 'iata' | 'icao' | 'logo' | 'banner' | 'popularity'>\n            ), fareConditions: (\n              { __typename?: 'FareConditions' }\n              & { cancellation?: Maybe<Array<Maybe<(\n                { __typename?: 'FareConditionEntry' }\n                & Pick<FareConditionEntry, 'name' | 'type' | 'currency' | 'amount' | 'remark' | 'changeFeeInd' | 'cancelFeeInd' | 'refundableInd'>\n              )>>>, change?: Maybe<Array<Maybe<(\n                { __typename?: 'FareConditionEntry' }\n                & Pick<FareConditionEntry, 'name' | 'type' | 'currency' | 'amount' | 'remark' | 'changeFeeInd' | 'cancelFeeInd' | 'refundableInd'>\n              )>>>, noShow?: Maybe<Array<Maybe<(\n                { __typename?: 'FareConditionEntry' }\n                & Pick<FareConditionEntry, 'name' | 'type' | 'currency' | 'amount' | 'remark' | 'changeFeeInd' | 'cancelFeeInd' | 'refundableInd'>\n              )>>>, upgrade?: Maybe<Array<Maybe<(\n                { __typename?: 'FareConditionEntry' }\n                & Pick<FareConditionEntry, 'name' | 'type' | 'currency' | 'amount' | 'remark' | 'changeFeeInd' | 'cancelFeeInd' | 'refundableInd'>\n              )>>>, other?: Maybe<Array<Maybe<(\n                { __typename?: 'FareConditionEntry' }\n                & Pick<FareConditionEntry, 'name' | 'type' | 'currency' | 'amount' | 'remark' | 'changeFeeInd' | 'cancelFeeInd' | 'refundableInd'>\n              )>>> }\n            ) }\n          )>>>, outboundCarbonEmissions?: Maybe<(\n            { __typename?: 'FlightCarbonEmissions' }\n            & Pick<FlightCarbonEmissions, 'amount' | 'unit'>\n          )>, inboundCarbonEmissions?: Maybe<(\n            { __typename?: 'FlightCarbonEmissions' }\n            & Pick<FlightCarbonEmissions, 'amount' | 'unit'>\n          )>, taxes?: Maybe<Array<Maybe<(\n            { __typename?: 'FlightAmount' }\n            & Pick<FlightAmount, 'description' | 'amount' | 'currency'>\n          )>>>, discounts?: Maybe<Array<Maybe<(\n            { __typename?: 'FlightAmount' }\n            & Pick<FlightAmount, 'description' | 'amount' | 'currency'>\n          )>>>, total: (\n            { __typename?: 'FlightFareTotal' }\n            & Pick<FlightFareTotal, 'price' | 'tax' | 'discount' | 'currency'>\n          ), fareConditions?: Maybe<(\n            { __typename?: 'FareConditions' }\n            & { cancellation?: Maybe<Array<Maybe<(\n              { __typename?: 'FareConditionEntry' }\n              & Pick<FareConditionEntry, 'name' | 'type' | 'currency' | 'amount' | 'remark' | 'changeFeeInd' | 'cancelFeeInd' | 'refundableInd'>\n            )>>>, change?: Maybe<Array<Maybe<(\n              { __typename?: 'FareConditionEntry' }\n              & Pick<FareConditionEntry, 'name' | 'type' | 'currency' | 'amount' | 'remark' | 'changeFeeInd' | 'cancelFeeInd' | 'refundableInd'>\n            )>>>, noShow?: Maybe<Array<Maybe<(\n              { __typename?: 'FareConditionEntry' }\n              & Pick<FareConditionEntry, 'name' | 'type' | 'currency' | 'amount' | 'remark' | 'changeFeeInd' | 'cancelFeeInd' | 'refundableInd'>\n            )>>>, upgrade?: Maybe<Array<Maybe<(\n              { __typename?: 'FareConditionEntry' }\n              & Pick<FareConditionEntry, 'name' | 'type' | 'currency' | 'amount' | 'remark' | 'changeFeeInd' | 'cancelFeeInd' | 'refundableInd'>\n            )>>>, other?: Maybe<Array<Maybe<(\n              { __typename?: 'FareConditionEntry' }\n              & Pick<FareConditionEntry, 'name' | 'type' | 'currency' | 'amount' | 'remark' | 'changeFeeInd' | 'cancelFeeInd' | 'refundableInd'>\n            )>>> }\n          )>, baggageAllowance?: Maybe<Array<Maybe<(\n            { __typename?: 'BaggageAllowance' }\n            & Pick<BaggageAllowance, 'type' | 'qty' | 'maxKG' | 'maxLBS'>\n          )>>> }\n        )> }\n      )>, grouped?: Maybe<Array<(\n        { __typename?: 'GroupFlights' }\n        & GroupedFieldsFragment\n      )>> }\n    ), errors: Array<(\n      { __typename?: 'SearchError' }\n      & ErrorsFragment\n    )> }\n  ) }\n);\n\nexport type GetCarHireDepotsQueryVariables = Exact<{\n  latitude: Scalars['Float'];\n  longitude: Scalars['Float'];\n  vendorCode?: Maybe<Scalars['String']>;\n}>;\n\n\nexport type GetCarHireDepotsQuery = (\n  { __typename?: 'Query' }\n  & { getCarHireDepots: Array<(\n    { __typename?: 'CarHireDepot' }\n    & Pick<CarHireDepot, 'countryCode' | 'locationCode' | 'extendedLocationCode' | 'vendorCode' | 'latitude' | 'longitude' | 'vendor' | 'addressLines' | 'cityName'>\n  )> }\n);\n\nexport type GetConfermaOfficeQueryVariables = Exact<{\n  officeId: Scalars['Int'];\n}>;\n\n\nexport type GetConfermaOfficeQuery = (\n  { __typename?: 'Query' }\n  & { getConfermaOffice: (\n    { __typename?: 'ConfermaOfficeResult' }\n    & { results?: Maybe<(\n      { __typename?: 'ConfermaOfficeInfo' }\n      & Pick<ConfermaOfficeInfo, 'id' | 'name' | 'closestAirport' | 'closestTrainStation' | 'longitude' | 'latitude'>\n      & { address?: Maybe<(\n        { __typename?: 'ConfermaOfficeAddress' }\n        & Pick<ConfermaOfficeAddress, 'addressName' | 'addressLine1' | 'addressLine2' | 'addressLine3' | 'postalCode' | 'city' | 'countryCode' | 'countryName' | 'telephoneNumber' | 'facsimileNumber' | 'emailAddress' | 'stateProvince' | 'mobileNumber'>\n      )>, closestHotels?: Maybe<Array<Maybe<(\n        { __typename?: 'ConfermaOfficeHotels' }\n        & Pick<ConfermaOfficeHotels, 'hotelId' | 'hotelName' | 'isPreferred'>\n      )>>> }\n    )>, errors: Array<(\n      { __typename?: 'SearchError' }\n      & Pick<SearchError, 'errorMessage' | 'errorCode'>\n      & { service: (\n        { __typename?: 'Service' }\n        & Pick<Service, 'id' | 'type' | 'name' | 'description' | 'supplierUrl' | 'active' | 'apiEndpointUrl' | 'basketItemTtl' | 'cancellable' | 'amendable' | 'detailSchema' | 'searchQuerySchema'>\n      ) }\n    )> }\n  ) }\n);\n\nexport type GetConfermaOfficeNamesQueryVariables = Exact<{ [key: string]: never; }>;\n\n\nexport type GetConfermaOfficeNamesQuery = (\n  { __typename?: 'Query' }\n  & { getConfermaOfficeNames: (\n    { __typename?: 'ConfermaOfficeNamesResult' }\n    & { results?: Maybe<Array<Maybe<(\n      { __typename?: 'ConfermaOfficeNames' }\n      & Pick<ConfermaOfficeNames, 'id' | 'name'>\n    )>>>, errors: Array<(\n      { __typename?: 'SearchError' }\n      & ErrorsFragment\n    )> }\n  ) }\n);\n\nexport type GetConfermaQuicklistQueryVariables = Exact<{\n  countryCode: Scalars['String'];\n}>;\n\n\nexport type GetConfermaQuicklistQuery = (\n  { __typename?: 'Query' }\n  & { getConfermaQuicklist: (\n    { __typename?: 'HotelSearchResult' }\n    & { results?: Maybe<Array<Maybe<(\n      { __typename?: 'HotelItinerary' }\n      & Pick<HotelItinerary, 'id' | 'name' | 'imageUrl' | 'group' | 'version' | 'tmcPreferredMessage' | 'companyPreferredMessage' | 'officePreferredMessage' | 'unavailableMessage'>\n      & { location: (\n        { __typename?: 'HotelLocation' }\n        & Pick<HotelLocation, 'distance' | 'distanceType' | 'longitude' | 'latitude'>\n      ), address: (\n        { __typename?: 'HotelAddress' }\n        & Pick<HotelAddress, 'addressLine1' | 'addressLine2' | 'addressLine3' | 'postOrZipCode' | 'countryCode' | 'telephone' | 'facsimile'>\n      ), transports?: Maybe<Array<Maybe<(\n        { __typename?: 'HotelTransport' }\n        & Pick<HotelTransport, 'type' | 'name' | 'code' | 'distance' | 'distanceType' | 'longitude' | 'latitude'>\n      )>>>, preferred: (\n        { __typename?: 'HotelPreferred' }\n        & Pick<HotelPreferred, 'client' | 'consumer'>\n      ), tags?: Maybe<Array<Maybe<(\n        { __typename?: 'HotelTag' }\n        & Pick<HotelTag, 'name' | 'display' | 'type' | 'icon'>\n      )>>>, availableRates?: Maybe<(\n        { __typename?: 'HotelAvailability' }\n        & Pick<HotelAvailability, 'hotelId' | 'imageUrl' | 'prpn' | 'currencyCode' | 'isBusy' | 'source' | 'version'>\n        & { rooms?: Maybe<Array<Maybe<(\n          { __typename?: 'HotelRoom' }\n          & Pick<HotelRoom, 'roomId' | 'roomType' | 'roomDescription' | 'rateCode' | 'rateDescription' | 'total' | 'currencyCode'>\n          & { currencyConversion?: Maybe<(\n            { __typename?: 'HotelConversion' }\n            & Pick<HotelConversion, 'rate' | 'localCode' | 'localTotal' | 'convertedCode' | 'convertedTotal'>\n          )>, deposit?: Maybe<(\n            { __typename?: 'HotelDeposit' }\n            & Pick<HotelDeposit, 'amount' | 'policy' | 'required'>\n          )>, nights: Array<(\n            { __typename?: 'HotelNight' }\n            & Pick<HotelNight, 'night' | 'rate' | 'info' | 'date'>\n          )>, policies: (\n            { __typename?: 'HotelPolicy' }\n            & Pick<HotelPolicy, 'cancellation' | 'deposit' | 'disabledAccess' | 'general' | 'guarantee' | 'refundAvailable'>\n          ), tax: (\n            { __typename?: 'HotelTax' }\n            & Pick<HotelTax, 'included' | 'rate'>\n          ), acceptedCards?: Maybe<Array<Maybe<(\n            { __typename?: 'HotelCard' }\n            & Pick<HotelCard, 'id' | 'name'>\n          )>>>, paymentTypes?: Maybe<Array<Maybe<(\n            { __typename?: 'HotelPaymentType' }\n            & Pick<HotelPaymentType, 'type' | 'name'>\n          )>>> }\n        )>>> }\n      )> }\n    )>>>, errors: Array<(\n      { __typename?: 'SearchError' }\n      & ErrorsFragment\n    )> }\n  ) }\n);\n\nexport type GetIrlSupplierStationQueryVariables = Exact<{\n  id?: Maybe<Scalars['ID']>;\n  supplier?: Maybe<IrlSupplier>;\n  code?: Maybe<Scalars['String']>;\n}>;\n\n\nexport type GetIrlSupplierStationQuery = (\n  { __typename?: 'Query' }\n  & { getIRLSupplierStation?: Maybe<(\n    { __typename?: 'IRLSupplierStation' }\n    & Pick<IrlSupplierStation, 'id' | 'name' | 'supplier' | 'stationCode' | 'nlcCode' | 'trainlineCode' | 'trainlineUniqueCode'>\n    & { locationDetails?: Maybe<(\n      { __typename?: 'LocationDetail' }\n      & Pick<LocationDetail, 'continent' | 'country' | 'countryCode' | 'state' | 'city' | 'postcode' | 'road' | 'gridReference' | 'northing' | 'easting'>\n      & { coordinates?: Maybe<(\n        { __typename?: 'GeoCoordinates' }\n        & Pick<GeoCoordinates, 'latitude' | 'longitude' | 'altitude'>\n      )> }\n    )> }\n  )> }\n);\n\nexport type GetRailStationQueryVariables = Exact<{\n  id?: Maybe<Scalars['ID']>;\n  code?: Maybe<Scalars['String']>;\n}>;\n\n\nexport type GetRailStationQuery = (\n  { __typename?: 'Query' }\n  & { getRailStation: (\n    { __typename?: 'RailStation' }\n    & Pick<RailStation, 'id' | 'name' | 'stationCode' | 'nlcCode' | 'trainlineCode' | 'trainlineUniqueCode'>\n    & { locationDetails?: Maybe<(\n      { __typename?: 'LocationDetail' }\n      & Pick<LocationDetail, 'continent' | 'country' | 'countryCode' | 'state' | 'city' | 'postcode' | 'road' | 'gridReference' | 'northing' | 'easting'>\n      & { coordinates?: Maybe<(\n        { __typename?: 'GeoCoordinates' }\n        & Pick<GeoCoordinates, 'latitude' | 'longitude' | 'altitude'>\n      )> }\n    )> }\n  ) }\n);\n\nexport type GetRailcardsQueryVariables = Exact<{ [key: string]: never; }>;\n\n\nexport type GetRailcardsQuery = (\n  { __typename?: 'Query' }\n  & { getRailcards: Array<(\n    { __typename?: 'ReferenceRailCardQualifier' }\n    & Pick<ReferenceRailCardQualifier, 'name' | 'code'>\n  )> }\n);\n\nexport type GetRiskAlertsQueryVariables = Exact<{\n  minLevel: RiskLevel;\n  maxLevel: RiskLevel;\n  countryIsoCode?: Maybe<Scalars['String']>;\n  airport?: Maybe<Scalars['ID']>;\n  railStation?: Maybe<Scalars['ID']>;\n  airportIata?: Maybe<Scalars['String']>;\n}>;\n\n\nexport type GetRiskAlertsQuery = (\n  { __typename?: 'Query' }\n  & { getRiskAlerts: Array<(\n    { __typename?: 'RiskAlert' }\n    & Pick<RiskAlert, 'id' | 'title' | 'description' | 'breaking' | 'risk' | 'category' | 'country' | 'location' | 'latitude' | 'longitude' | 'startDate' | 'endDate' | 'receivedDate'>\n  )> }\n);\n\nexport type GetUserAddressesQueryVariables = Exact<{ [key: string]: never; }>;\n\n\nexport type GetUserAddressesQuery = (\n  { __typename?: 'Query' }\n  & { getUserAddresses: Array<(\n    { __typename?: 'Address' }\n    & Pick<Address, 'id' | 'description' | 'numberOrName' | 'street' | 'town' | 'county' | 'postcode' | 'countryCode' | 'userPrimary' | 'officePrimary'>\n  )> }\n);\n\nexport type GetUserCompanyOfficesQueryVariables = Exact<{ [key: string]: never; }>;\n\n\nexport type GetUserCompanyOfficesQuery = (\n  { __typename?: 'Query' }\n  & { getUserCompanyOffices: Array<(\n    { __typename?: 'Office' }\n    & Pick<Office, 'id' | 'name'>\n    & { addresses: Array<(\n      { __typename?: 'Address' }\n      & Pick<Address, 'id' | 'description' | 'numberOrName' | 'street' | 'town' | 'county' | 'postcode' | 'countryCode' | 'userPrimary' | 'officePrimary'>\n    )> }\n  )> }\n);\n\nexport type GetUserCurrentCarbonAllowanceQueryVariables = Exact<{\n  user?: Maybe<Scalars['ID']>;\n}>;\n\n\nexport type GetUserCurrentCarbonAllowanceQuery = (\n  { __typename?: 'Query' }\n  & { getUserCurrentCarbonAllowance?: Maybe<(\n    { __typename?: 'CarbonAllowance' }\n    & Pick<CarbonAllowance, 'id' | 'startOfPeriod' | 'endOfPeriod' | 'remainingCo2' | 'totalCo2' | 'carbonPolicySource'>\n    & { company?: Maybe<(\n      { __typename?: 'Company' }\n      & Pick<Company, 'id' | 'name'>\n    )>, office?: Maybe<(\n      { __typename?: 'Office' }\n      & Pick<Office, 'id' | 'name'>\n    )>, user: (\n      { __typename?: 'User' }\n      & Pick<User, 'id' | 'forename' | 'surname' | 'email'>\n    ), periodConsumption: Array<(\n      { __typename?: 'CarbonConsumption' }\n      & Pick<CarbonConsumption, 'id' | 'consumed' | 'datetime'>\n    )> }\n  )> }\n);\n\nexport type GetUserMiAutoSuggestValuesQueryVariables = Exact<{\n  mi: Scalars['ID'];\n  partialLabel: Scalars['String'];\n}>;\n\n\nexport type GetUserMiAutoSuggestValuesQuery = (\n  { __typename?: 'Query' }\n  & { getUserMIAutoSuggestValues: Array<(\n    { __typename?: 'ManagementInfoValue' }\n    & Pick<ManagementInfoValue, 'id' | 'label' | 'value' | 'default' | 'fixed' | 'agentOnly'>\n  )> }\n);\n\nexport type GetUserPhoneQueryVariables = Exact<{ [key: string]: never; }>;\n\n\nexport type GetUserPhoneQuery = (\n  { __typename?: 'Query' }\n  & { getUserPhoneNumbers: Array<(\n    { __typename?: 'PhoneNumber' }\n    & Pick<PhoneNumber, 'id' | 'description' | 'countryCode' | 'areaCode' | 'number' | 'extension' | 'type' | 'officePrimary' | 'userPrimary'>\n  )> }\n);\n\nexport type GetUserRecentSearchesQueryVariables = Exact<{\n  serviceType?: Maybe<ServiceType>;\n}>;\n\n\nexport type GetUserRecentSearchesQuery = (\n  { __typename?: 'Query' }\n  & { getUserRecentSearches: Array<(\n    { __typename?: 'Search' }\n    & Pick<Search, 'id' | 'name' | 'serviceType' | 'searchArgs' | 'createdAt' | 'updatedAt' | 'travelDate'>\n    & { travellers?: Maybe<Array<(\n      { __typename?: 'User' }\n      & Pick<User, 'id' | 'title' | 'forename' | 'surname' | 'email' | 'username' | 'dob'>\n    )>> }\n  )> }\n);\n\nexport type SearchHotelsQueryVariables = Exact<{\n  startDate: Scalars['Date'];\n  endDate: Scalars['Date'];\n  cityName?: Maybe<Scalars['String']>;\n  postOrZipCode?: Maybe<Scalars['String']>;\n  countryCode?: Maybe<Scalars['String']>;\n  latitude?: Maybe<Scalars['Float']>;\n  longitude?: Maybe<Scalars['Float']>;\n  trainStationCode?: Maybe<Scalars['String']>;\n  iata?: Maybe<Scalars['String']>;\n  officeId?: Maybe<Scalars['Int']>;\n  rooms: Scalars['Int'];\n  adults: Scalars['Int'];\n  children?: Maybe<Scalars['Int']>;\n  currency: Scalars['String'];\n  distanceType: DistanceTypes;\n  distance: Scalars['Int'];\n  maxResults?: Maybe<Scalars['Int']>;\n  hotelName?: Maybe<Scalars['String']>;\n  groupName?: Maybe<Scalars['String']>;\n}>;\n\n\nexport type SearchHotelsQuery = (\n  { __typename?: 'Query' }\n  & { searchHotels: (\n    { __typename?: 'HotelSearchResult' }\n    & { results?: Maybe<Array<Maybe<(\n      { __typename?: 'HotelItinerary' }\n      & Pick<HotelItinerary, 'id' | 'name' | 'imageUrl' | 'group' | 'co2PerPassenger' | 'co2PerItem' | 'source' | 'sourceId' | 'version' | 'tmcPreferred' | 'companyPreferred' | 'officePreferred' | 'tmcPreferredMessage' | 'companyPreferredMessage' | 'officePreferredMessage' | 'unavailable' | 'unavailableMessage'>\n      & { location: (\n        { __typename?: 'HotelLocation' }\n        & Pick<HotelLocation, 'distance' | 'distanceType' | 'longitude' | 'latitude'>\n      ), address: (\n        { __typename?: 'HotelAddress' }\n        & Pick<HotelAddress, 'addressLine1' | 'addressLine2' | 'addressLine3' | 'postOrZipCode' | 'countryCode' | 'telephone' | 'facsimile'>\n      ), transports?: Maybe<Array<Maybe<(\n        { __typename?: 'HotelTransport' }\n        & Pick<HotelTransport, 'type' | 'name' | 'code' | 'distance' | 'distanceType' | 'longitude' | 'latitude'>\n      )>>>, preferred: (\n        { __typename?: 'HotelPreferred' }\n        & Pick<HotelPreferred, 'client' | 'consumer'>\n      ), tags?: Maybe<Array<Maybe<(\n        { __typename?: 'HotelTag' }\n        & Pick<HotelTag, 'name' | 'display' | 'type' | 'icon'>\n      )>>>, availableRates?: Maybe<(\n        { __typename?: 'HotelAvailability' }\n        & Pick<HotelAvailability, 'hotelId' | 'imageUrl' | 'prpn' | 'currencyCode' | 'isBusy' | 'source' | 'version'>\n        & { rooms?: Maybe<Array<Maybe<(\n          { __typename?: 'HotelRoom' }\n          & Pick<HotelRoom, 'roomId' | 'roomType' | 'roomDescription' | 'rateCode' | 'rateDescription' | 'total' | 'currencyCode'>\n          & { currencyConversion?: Maybe<(\n            { __typename?: 'HotelConversion' }\n            & Pick<HotelConversion, 'rate' | 'localCode' | 'localTotal' | 'convertedCode' | 'convertedTotal'>\n          )>, deposit?: Maybe<(\n            { __typename?: 'HotelDeposit' }\n            & Pick<HotelDeposit, 'amount' | 'policy' | 'required'>\n          )>, nights: Array<(\n            { __typename?: 'HotelNight' }\n            & Pick<HotelNight, 'night' | 'rate' | 'info' | 'date'>\n          )>, policies: (\n            { __typename?: 'HotelPolicy' }\n            & Pick<HotelPolicy, 'cancellation' | 'deposit' | 'disabledAccess' | 'general' | 'guarantee' | 'refundAvailable'>\n          ), tax: (\n            { __typename?: 'HotelTax' }\n            & Pick<HotelTax, 'included' | 'rate'>\n          ), acceptedCards?: Maybe<Array<Maybe<(\n            { __typename?: 'HotelCard' }\n            & Pick<HotelCard, 'id' | 'name'>\n          )>>>, paymentTypes?: Maybe<Array<Maybe<(\n            { __typename?: 'HotelPaymentType' }\n            & Pick<HotelPaymentType, 'type' | 'name'>\n          )>>> }\n        )>>> }\n      )> }\n    )>>>, errors: Array<(\n      { __typename?: 'SearchError' }\n      & Pick<SearchError, 'errorMessage' | 'errorCode'>\n      & { service: (\n        { __typename?: 'Service' }\n        & Pick<Service, 'id' | 'type' | 'name' | 'description' | 'detailSchema' | 'searchQuerySchema'>\n      ) }\n    )> }\n  ) }\n);\n\nexport type GetMultipleHotelsAvailabilityQueryVariables = Exact<{\n  hotel: Array<Scalars['String']> | Scalars['String'];\n  startDate: Scalars['Date'];\n  endDate: Scalars['Date'];\n  currency: Scalars['String'];\n  occupants: Scalars['Int'];\n  rooms?: Maybe<Scalars['Int']>;\n}>;\n\n\nexport type GetMultipleHotelsAvailabilityQuery = (\n  { __typename?: 'Query' }\n  & { getMultipleHotelsAvailability: (\n    { __typename?: 'HotelMultiAvailabilityResult' }\n    & { results?: Maybe<Array<Maybe<(\n      { __typename?: 'HotelAvailability' }\n      & Pick<HotelAvailability, 'hotelId' | 'prpn' | 'currencyCode' | 'isBusy' | 'source' | 'version'>\n      & { rooms?: Maybe<Array<Maybe<(\n        { __typename?: 'HotelRoom' }\n        & Pick<HotelRoom, 'roomId' | 'roomType' | 'roomDescription' | 'rateCode' | 'rateDescription' | 'total' | 'currencyCode'>\n        & { currencyConversion?: Maybe<(\n          { __typename?: 'HotelConversion' }\n          & Pick<HotelConversion, 'rate' | 'localCode' | 'localTotal' | 'convertedCode' | 'convertedTotal'>\n        )>, deposit?: Maybe<(\n          { __typename?: 'HotelDeposit' }\n          & Pick<HotelDeposit, 'amount' | 'policy' | 'required'>\n        )>, nights: Array<(\n          { __typename?: 'HotelNight' }\n          & Pick<HotelNight, 'night' | 'rate' | 'info' | 'date'>\n        )>, policies: (\n          { __typename?: 'HotelPolicy' }\n          & Pick<HotelPolicy, 'cancellation' | 'deposit' | 'disabledAccess' | 'general' | 'guarantee' | 'refundAvailable'>\n        ), tax: (\n          { __typename?: 'HotelTax' }\n          & Pick<HotelTax, 'included' | 'rate'>\n        ), acceptedCards?: Maybe<Array<Maybe<(\n          { __typename?: 'HotelCard' }\n          & Pick<HotelCard, 'id' | 'name'>\n        )>>>, paymentTypes?: Maybe<Array<Maybe<(\n          { __typename?: 'HotelPaymentType' }\n          & Pick<HotelPaymentType, 'type' | 'name'>\n        )>>> }\n      )>>> }\n    )>>>, errors: Array<(\n      { __typename?: 'SearchError' }\n      & ErrorsFragment\n    )> }\n  ) }\n);\n\nexport type IsPostcodeValidQueryVariables = Exact<{\n  postcode: Scalars['String'];\n}>;\n\n\nexport type IsPostcodeValidQuery = (\n  { __typename?: 'Query' }\n  & Pick<Query, 'isPostcodeValid'>\n);\n\nexport type Location_DetailFragment = (\n  { __typename?: 'LocationDetail' }\n  & Pick<LocationDetail, 'continent' | 'country' | 'countryCode' | 'state' | 'city' | 'postcode' | 'road' | 'gridReference' | 'northing' | 'easting'>\n  & { coordinates?: Maybe<(\n    { __typename?: 'GeoCoordinates' }\n    & Pick<GeoCoordinates, 'latitude' | 'longitude' | 'altitude'>\n  )> }\n);\n\nexport type SearchAirportsQueryVariables = Exact<{\n  query: Scalars['String'];\n  countryCode?: Maybe<Scalars['String']>;\n  hasLounge?: Maybe<Scalars['Boolean']>;\n  hasParking?: Maybe<Scalars['Boolean']>;\n  hasFastTrack?: Maybe<Scalars['Boolean']>;\n}>;\n\n\nexport type SearchAirportsQuery = (\n  { __typename?: 'Query' }\n  & { searchAirports: (\n    { __typename?: 'AirportResults' }\n    & { iataMatch?: Maybe<(\n      { __typename?: 'Airport' }\n      & Pick<Airport, 'id' | 'name' | 'iata' | 'icao' | 'terminals'>\n      & { locationDetails?: Maybe<(\n        { __typename?: 'LocationDetail' }\n        & Location_DetailFragment\n      )> }\n    )>, generalMatches: Array<(\n      { __typename?: 'Airport' }\n      & Pick<Airport, 'id' | 'name' | 'iata' | 'icao' | 'terminals'>\n      & { locationDetails?: Maybe<(\n        { __typename?: 'LocationDetail' }\n        & Location_DetailFragment\n      )> }\n    )> }\n  ) }\n);\n\nexport type SearchLoungesQueryVariables = Exact<{\n  locationCode: Scalars['String'];\n  arrivalDatetime: Scalars['DateTime'];\n  adults: Scalars['Int'];\n  children?: Maybe<Scalars['Int']>;\n  infants?: Maybe<Scalars['Int']>;\n  terminal?: Maybe<Scalars['String']>;\n}>;\n\n\nexport type SearchLoungesQuery = (\n  { __typename?: 'Query' }\n  & { searchLounges: (\n    { __typename?: 'LoungeSearchResult' }\n    & { results: Array<(\n      { __typename?: 'LoungeQuote' }\n      & Pick<LoungeQuote, 'source' | 'sourceId' | 'name' | 'code' | 'price' | 'currency' | 'tmcPreferred' | 'companyPreferred' | 'officePreferred' | 'tmcPreferredMessage' | 'companyPreferredMessage' | 'officePreferredMessage' | 'unavailable' | 'unavailableMessage' | 'co2PerPassenger' | 'co2PerItem'>\n      & { lounge: (\n        { __typename?: 'LoungeLocation' }\n        & Pick<LoungeLocation, 'code' | 'name' | 'airport' | 'terminal' | 'address' | 'telephone' | 'fax' | 'directions' | 'introduction' | 'logo' | 'mobileImage' | 'furtherImages' | 'adultAge' | 'childAge' | 'infantAge' | 'landside' | 'airside' | 'facilities' | 'openTime' | 'closeTime' | 'wifi' | 'tv' | 'snacks' | 'phone' | 'internet' | 'childrenAllowed' | 'disabledAccess' | 'drinks' | 'freeDrinks' | 'freeFood' | 'smokingPermitted' | 'magazines' | 'includedDrinks' | 'menuFood' | 'menuDrinks' | 'menuExtras' | 'whatsIncludedDrinks' | 'whatsIncludedExtras' | 'whatsIncludedFood' | 'groupInfo' | 'checkInInfo' | 'dressCode' | 'facilitiesInfo' | 'foodAndBeverage' | 'cancellationInfo' | 'amendmentsInfo' | 'misc'>\n      ) }\n    )>, errors: Array<(\n      { __typename?: 'SearchError' }\n      & ErrorsFragment\n    )> }\n  ) }\n);\n\nexport type MoveItemToADifferentBasketMutationVariables = Exact<{\n  basketItem: Scalars['ID'];\n  newBasket: Scalars['ID'];\n  withSupplemental?: Maybe<Scalars['Boolean']>;\n}>;\n\n\nexport type MoveItemToADifferentBasketMutation = (\n  { __typename?: 'Mutation' }\n  & { moveItemToADifferentBasket: (\n    { __typename?: 'Basket' }\n    & BasketFieldsFragment\n  ) }\n);\n\nexport type SearchParkingQueryVariables = Exact<{\n  arrivalDatetime: Scalars['DateTime'];\n  departDatetime: Scalars['DateTime'];\n  locationCode: Scalars['String'];\n  outFlightNumber?: Maybe<Scalars['String']>;\n  recommended?: Maybe<Scalars['Boolean']>;\n  onAirport?: Maybe<Scalars['Boolean']>;\n  meetAndGreet?: Maybe<Scalars['Boolean']>;\n  parkAndRide?: Maybe<Scalars['Boolean']>;\n  parkAndStroll?: Maybe<Scalars['Boolean']>;\n  carParkedForYou?: Maybe<Scalars['Boolean']>;\n  terminal?: Maybe<Scalars['String']>;\n}>;\n\n\nexport type SearchParkingQuery = (\n  { __typename?: 'Query' }\n  & { searchParking: (\n    { __typename?: 'ParkingSearchResult' }\n    & { results: Array<(\n      { __typename?: 'ParkingQuote' }\n      & Pick<ParkingQuote, 'source' | 'sourceId' | 'requiredInfo' | 'price' | 'currency' | 'misc' | 'tmcPreferred' | 'companyPreferred' | 'officePreferred' | 'tmcPreferredMessage' | 'companyPreferredMessage' | 'officePreferredMessage' | 'unavailable' | 'unavailableMessage' | 'co2PerPassenger' | 'co2PerItem'>\n      & { carPark: (\n        { __typename?: 'ParkingLocation' }\n        & Pick<ParkingLocation, 'code' | 'name' | 'airport' | 'terminal' | 'latitude' | 'longitude' | 'address' | 'distanceToAirport' | 'onAirport' | 'carParkedForYou' | 'meetAndGreet' | 'telephone' | 'fax' | 'directions' | 'arrivalProcedure' | 'departureProcedure' | 'maximumCarSize' | 'introduction' | 'information' | 'transferInformation' | 'transferOperatingTimes' | 'transferTime' | 'logo' | 'defaultImage' | 'brandImage' | 'mobileImage' | 'furtherImages' | 'misc'>\n      ) }\n    )>, errors: Array<(\n      { __typename?: 'SearchError' }\n      & ErrorsFragment\n    )> }\n  ) }\n);\n\nexport type SearchRailQueryVariables = Exact<{\n  countryCode: Scalars['String'];\n  journeyType: RailJourneyType;\n  class?: Maybe<RailClass>;\n  outboundArrivalDateTime?: Maybe<Scalars['DateTime']>;\n  outboundDepartureDateTime?: Maybe<Scalars['DateTime']>;\n  departureLocationId: Scalars['ID'];\n  arrivalLocationId: Scalars['ID'];\n  adults: Scalars['Int'];\n  children?: Maybe<Scalars['Int']>;\n  returnArrivalDateTime?: Maybe<Scalars['DateTime']>;\n  returnDepartureDateTime?: Maybe<Scalars['DateTime']>;\n  railCardQualifiers?: Maybe<Array<Scalars['String']> | Scalars['String']>;\n  viaLocationId?: Maybe<Scalars['ID']>;\n  extraTimeToChange?: Maybe<Scalars['Boolean']>;\n  plusBusOut?: Maybe<RailPlusBusAvail>;\n  plusBusReturn?: Maybe<RailPlusBusAvail>;\n}>;\n\n\nexport type SearchRailQuery = (\n  { __typename?: 'Query' }\n  & { searchRail: (\n    { __typename?: 'RailSearchResult' }\n    & { results: Array<(\n      { __typename?: 'RailJourneyOptions' }\n      & Pick<RailJourneyOptions, 'source' | 'sourceId'>\n      & { outbound?: Maybe<Array<(\n        { __typename?: 'RailJourneyOption' }\n        & Pick<RailJourneyOption, 'co2PerItem' | 'from' | 'fromCode' | 'to' | 'toCode' | 'co2PerPassenger' | 'departDateTime' | 'arriveDateTime' | 'changes' | 'unsellable'>\n        & { identifiers?: Maybe<(\n          { __typename?: 'RailIdentifiers' }\n          & Pick<RailIdentifiers, 'transactionIdentifier' | 'journeyIdentifier' | 'provider' | 'fareIdentifier' | 'direction' | 'singleOrReturn' | 'bookingRef'>\n        )>, travellers?: Maybe<Array<(\n          { __typename?: 'RailTraveller' }\n          & Pick<RailTraveller, 'status' | 'id' | 'dob' | 'railcard' | 'givenName' | 'surname' | 'nameTitle' | 'contactInfo' | 'deliveryEmailAddress' | 'fare'>\n        )>>, segments?: Maybe<Array<(\n          { __typename?: 'RailSegment' }\n          & Pick<RailSegment, 'id' | 'operator' | 'depart' | 'departDateTime' | 'arrive' | 'arriveDateTime' | 'reservableStatus' | 'seatPreferenceGroup'>\n          & { seatPreferenceTypes?: Maybe<Array<(\n            { __typename?: 'RailSeatPreferenceType' }\n            & Pick<RailSeatPreferenceType, 'name' | 'allowedValues'>\n          )>>, seats?: Maybe<Array<(\n            { __typename?: 'RailSeat' }\n            & Pick<RailSeat, 'location' | 'coach' | 'number' | 'direction' | 'position' | 'deck' | 'seatType' | 'seatSelection' | 'facilities' | 'note'>\n          )>>, callingPoints?: Maybe<Array<(\n            { __typename?: 'RailCallingPoint' }\n            & Pick<RailCallingPoint, 'stationName' | 'stationCode' | 'arrivalDateTime' | 'departureDateTime' | 'scheduledPlatform' | 'stationClassification' | 'stoppingPattern'>\n          )>> }\n        )>>, providers?: Maybe<Array<(\n          { __typename?: 'RailProvider' }\n          & Pick<RailProvider, 'providerId' | 'name'>\n          & { cheapestTicket?: Maybe<(\n            { __typename?: 'RailTicketOption' }\n            & Pick<RailTicketOption, 'type' | 'class' | 'singleOrReturn' | 'price' | 'reservableStatus' | 'currency' | 'route' | 'routeCode' | 'availableSeats'>\n            & { identifiers?: Maybe<(\n              { __typename?: 'RailIdentifiers' }\n              & Pick<RailIdentifiers, 'transactionIdentifier' | 'journeyIdentifier' | 'provider' | 'fareIdentifier' | 'direction' | 'singleOrReturn' | 'bookingRef'>\n            )>, terms?: Maybe<(\n              { __typename?: 'RailTicketTerms' }\n              & Pick<RailTicketTerms, 'error' | 'ticketTypeCode' | 'trainOperatingCompanyCode' | 'ticketTypeName' | 'ticketTypeAltName' | 'ticketTypeClass' | 'reservationRule' | 'journeyType' | 'preBookingRequirement' | 'generalValidity' | 'validOutRule' | 'validReturnRule' | 'generalDiscount' | 'childDiscount' | 'railcardDiscount' | 'refundCancellationRule' | 'changeRule' | 'ticketTypeConditionsDescription' | 'journeyBreakRule' | 'availabilityRule' | 'todAvailable' | 'kioskAvailable' | 'startDate' | 'endDate'>\n              & { dynamicConditions?: Maybe<Array<Maybe<(\n                { __typename?: 'DynamicCondition' }\n                & Pick<DynamicCondition, 'name' | 'description'>\n              )>>> }\n            )>, tickets?: Maybe<Array<Maybe<(\n              { __typename?: 'RailTicket' }\n              & Pick<RailTicket, 'price' | 'type' | 'route' | 'numChildren' | 'numAdults'>\n              & { segments?: Maybe<Array<(\n                { __typename?: 'RailSegment' }\n                & Pick<RailSegment, 'id' | 'operator' | 'depart' | 'departDateTime' | 'arrive' | 'arriveDateTime' | 'reservableStatus' | 'seatPreferenceGroup'>\n              )>> }\n            )>>>, ticketQueueList?: Maybe<Array<Maybe<(\n              { __typename?: 'RailTicketQueue' }\n              & Pick<RailTicketQueue, 'id' | 'name' | 'type'>\n            )>>>, accountsList?: Maybe<Array<Maybe<(\n              { __typename?: 'RailAccount' }\n              & Pick<RailAccount, 'id' | 'reference' | 'description' | 'isDefault' | 'type'>\n            )>>> }\n          )>, ticketOptions?: Maybe<Array<Maybe<(\n            { __typename?: 'RailTicketOption' }\n            & Pick<RailTicketOption, 'type' | 'class' | 'singleOrReturn' | 'price' | 'reservableStatus' | 'currency' | 'route' | 'routeCode' | 'availableSeats'>\n            & { identifiers?: Maybe<(\n              { __typename?: 'RailIdentifiers' }\n              & Pick<RailIdentifiers, 'transactionIdentifier' | 'journeyIdentifier' | 'provider' | 'fareIdentifier' | 'direction' | 'singleOrReturn' | 'bookingRef'>\n              & { allowedWith: Array<(\n                { __typename?: 'RailIdentifiers' }\n                & Pick<RailIdentifiers, 'transactionIdentifier' | 'journeyIdentifier' | 'provider' | 'fareIdentifier' | 'direction' | 'singleOrReturn' | 'bookingRef'>\n              )> }\n            )>, terms?: Maybe<(\n              { __typename?: 'RailTicketTerms' }\n              & Pick<RailTicketTerms, 'error' | 'ticketTypeCode' | 'trainOperatingCompanyCode' | 'ticketTypeName' | 'ticketTypeAltName' | 'ticketTypeClass' | 'reservationRule' | 'journeyType' | 'preBookingRequirement' | 'generalValidity' | 'validOutRule' | 'validReturnRule' | 'generalDiscount' | 'childDiscount' | 'railcardDiscount' | 'refundCancellationRule' | 'changeRule' | 'ticketTypeConditionsDescription' | 'journeyBreakRule' | 'availabilityRule' | 'todAvailable' | 'kioskAvailable' | 'startDate' | 'endDate'>\n            )>, tickets?: Maybe<Array<Maybe<(\n              { __typename?: 'RailTicket' }\n              & Pick<RailTicket, 'price' | 'type' | 'route' | 'numChildren' | 'numAdults'>\n            )>>>, ticketQueueList?: Maybe<Array<Maybe<(\n              { __typename?: 'RailTicketQueue' }\n              & Pick<RailTicketQueue, 'id' | 'name' | 'type'>\n            )>>>, accountsList?: Maybe<Array<Maybe<(\n              { __typename?: 'RailAccount' }\n              & Pick<RailAccount, 'id' | 'reference' | 'description' | 'isDefault' | 'type'>\n            )>>> }\n          )>>>, bookedTicket?: Maybe<(\n            { __typename?: 'RailTicketOption' }\n            & Pick<RailTicketOption, 'type' | 'class' | 'singleOrReturn' | 'price' | 'reservableStatus' | 'currency' | 'route' | 'routeCode'>\n            & { identifiers?: Maybe<(\n              { __typename?: 'RailIdentifiers' }\n              & Pick<RailIdentifiers, 'transactionIdentifier' | 'journeyIdentifier' | 'provider' | 'fareIdentifier' | 'direction' | 'singleOrReturn' | 'bookingRef'>\n            )>, terms?: Maybe<(\n              { __typename?: 'RailTicketTerms' }\n              & Pick<RailTicketTerms, 'error' | 'ticketTypeCode' | 'trainOperatingCompanyCode' | 'ticketTypeName' | 'ticketTypeAltName' | 'ticketTypeClass' | 'reservationRule' | 'journeyType' | 'preBookingRequirement' | 'generalValidity' | 'validOutRule' | 'validReturnRule' | 'generalDiscount' | 'childDiscount' | 'railcardDiscount' | 'refundCancellationRule' | 'changeRule' | 'ticketTypeConditionsDescription' | 'journeyBreakRule' | 'availabilityRule' | 'todAvailable' | 'kioskAvailable' | 'startDate' | 'endDate'>\n            )>, tickets?: Maybe<Array<Maybe<(\n              { __typename?: 'RailTicket' }\n              & Pick<RailTicket, 'price' | 'type' | 'route' | 'numChildren' | 'numAdults'>\n            )>>>, ticketQueueList?: Maybe<Array<Maybe<(\n              { __typename?: 'RailTicketQueue' }\n              & Pick<RailTicketQueue, 'id' | 'name' | 'type'>\n            )>>>, accountsList?: Maybe<Array<Maybe<(\n              { __typename?: 'RailAccount' }\n              & Pick<RailAccount, 'id' | 'reference' | 'description' | 'isDefault' | 'type'>\n            )>>> }\n          )> }\n        )>>, ticketExtras?: Maybe<Array<(\n          { __typename?: 'RailTicketExtra' }\n          & Pick<RailTicketExtra, 'type' | 'location' | 'date' | 'description' | 'amount' | 'adultAmount' | 'childAmount' | 'currency'>\n          & { identifiers?: Maybe<(\n            { __typename?: 'RailTicketExtraIdentifiers' }\n            & Pick<RailTicketExtraIdentifiers, 'type' | 'location' | 'date' | 'journeyId' | 'isOrigin'>\n          )> }\n        )>>, plusBus?: Maybe<(\n          { __typename?: 'RailPlusBus' }\n          & Pick<RailPlusBus, 'originPlusBusNLC' | 'originStationNLC' | 'destinationPlusBusNLC' | 'destinationStationNLC'>\n        )> }\n      )>>, return?: Maybe<Array<(\n        { __typename?: 'RailJourneyOption' }\n        & Pick<RailJourneyOption, 'co2PerItem' | 'from' | 'fromCode' | 'to' | 'toCode' | 'departDateTime' | 'arriveDateTime' | 'changes' | 'unsellable'>\n        & { identifiers?: Maybe<(\n          { __typename?: 'RailIdentifiers' }\n          & Pick<RailIdentifiers, 'transactionIdentifier' | 'journeyIdentifier' | 'provider' | 'fareIdentifier' | 'direction' | 'singleOrReturn' | 'bookingRef'>\n        )>, travellers?: Maybe<Array<(\n          { __typename?: 'RailTraveller' }\n          & Pick<RailTraveller, 'status' | 'id' | 'dob' | 'railcard' | 'givenName' | 'surname' | 'nameTitle' | 'contactInfo' | 'deliveryEmailAddress' | 'fare'>\n        )>>, segments?: Maybe<Array<(\n          { __typename?: 'RailSegment' }\n          & Pick<RailSegment, 'id' | 'operator' | 'depart' | 'departDateTime' | 'arrive' | 'arriveDateTime' | 'reservableStatus' | 'seatPreferenceGroup'>\n          & { callingPoints?: Maybe<Array<(\n            { __typename?: 'RailCallingPoint' }\n            & Pick<RailCallingPoint, 'stationName' | 'stationCode' | 'arrivalDateTime' | 'departureDateTime' | 'scheduledPlatform' | 'stationClassification' | 'stoppingPattern'>\n          )>> }\n        )>>, providers?: Maybe<Array<(\n          { __typename?: 'RailProvider' }\n          & Pick<RailProvider, 'providerId' | 'name'>\n          & { cheapestTicket?: Maybe<(\n            { __typename?: 'RailTicketOption' }\n            & Pick<RailTicketOption, 'type' | 'class' | 'singleOrReturn' | 'price' | 'reservableStatus' | 'currency' | 'route' | 'routeCode' | 'availableSeats'>\n            & { identifiers?: Maybe<(\n              { __typename?: 'RailIdentifiers' }\n              & Pick<RailIdentifiers, 'transactionIdentifier' | 'journeyIdentifier' | 'provider' | 'fareIdentifier' | 'direction' | 'singleOrReturn' | 'bookingRef'>\n            )>, terms?: Maybe<(\n              { __typename?: 'RailTicketTerms' }\n              & Pick<RailTicketTerms, 'error' | 'ticketTypeCode' | 'trainOperatingCompanyCode' | 'ticketTypeName' | 'ticketTypeAltName' | 'ticketTypeClass' | 'reservationRule' | 'journeyType' | 'preBookingRequirement' | 'generalValidity' | 'validOutRule' | 'validReturnRule' | 'generalDiscount' | 'childDiscount' | 'railcardDiscount' | 'refundCancellationRule' | 'changeRule' | 'ticketTypeConditionsDescription' | 'journeyBreakRule' | 'availabilityRule' | 'todAvailable' | 'kioskAvailable' | 'startDate' | 'endDate'>\n              & { dynamicConditions?: Maybe<Array<Maybe<(\n                { __typename?: 'DynamicCondition' }\n                & Pick<DynamicCondition, 'name' | 'description'>\n              )>>> }\n            )>, tickets?: Maybe<Array<Maybe<(\n              { __typename?: 'RailTicket' }\n              & Pick<RailTicket, 'price' | 'type' | 'route' | 'numChildren' | 'numAdults'>\n              & { segments?: Maybe<Array<(\n                { __typename?: 'RailSegment' }\n                & Pick<RailSegment, 'id' | 'operator' | 'depart' | 'departDateTime' | 'arrive' | 'arriveDateTime' | 'reservableStatus' | 'seatPreferenceGroup'>\n              )>> }\n            )>>>, ticketQueueList?: Maybe<Array<Maybe<(\n              { __typename?: 'RailTicketQueue' }\n              & Pick<RailTicketQueue, 'id' | 'name' | 'type'>\n            )>>>, accountsList?: Maybe<Array<Maybe<(\n              { __typename?: 'RailAccount' }\n              & Pick<RailAccount, 'id' | 'reference' | 'description' | 'isDefault' | 'type'>\n            )>>> }\n          )>, ticketOptions?: Maybe<Array<Maybe<(\n            { __typename?: 'RailTicketOption' }\n            & Pick<RailTicketOption, 'type' | 'class' | 'singleOrReturn' | 'price' | 'reservableStatus' | 'currency' | 'route' | 'routeCode' | 'availableSeats'>\n            & { identifiers?: Maybe<(\n              { __typename?: 'RailIdentifiers' }\n              & Pick<RailIdentifiers, 'transactionIdentifier' | 'journeyIdentifier' | 'provider' | 'fareIdentifier' | 'direction' | 'singleOrReturn' | 'bookingRef'>\n              & { allowedWith: Array<(\n                { __typename?: 'RailIdentifiers' }\n                & Pick<RailIdentifiers, 'transactionIdentifier' | 'journeyIdentifier' | 'provider' | 'fareIdentifier' | 'direction' | 'singleOrReturn' | 'bookingRef'>\n              )> }\n            )>, terms?: Maybe<(\n              { __typename?: 'RailTicketTerms' }\n              & Pick<RailTicketTerms, 'error' | 'ticketTypeCode' | 'trainOperatingCompanyCode' | 'ticketTypeName' | 'ticketTypeAltName' | 'ticketTypeClass' | 'reservationRule' | 'journeyType' | 'preBookingRequirement' | 'generalValidity' | 'validOutRule' | 'validReturnRule' | 'generalDiscount' | 'childDiscount' | 'railcardDiscount' | 'refundCancellationRule' | 'changeRule' | 'ticketTypeConditionsDescription' | 'journeyBreakRule' | 'availabilityRule' | 'todAvailable' | 'kioskAvailable' | 'startDate' | 'endDate'>\n            )>, tickets?: Maybe<Array<Maybe<(\n              { __typename?: 'RailTicket' }\n              & Pick<RailTicket, 'price' | 'type' | 'route' | 'numChildren' | 'numAdults'>\n            )>>>, ticketQueueList?: Maybe<Array<Maybe<(\n              { __typename?: 'RailTicketQueue' }\n              & Pick<RailTicketQueue, 'id' | 'name' | 'type'>\n            )>>>, accountsList?: Maybe<Array<Maybe<(\n              { __typename?: 'RailAccount' }\n              & Pick<RailAccount, 'id' | 'reference' | 'description' | 'isDefault' | 'type'>\n            )>>> }\n          )>>>, bookedTicket?: Maybe<(\n            { __typename?: 'RailTicketOption' }\n            & Pick<RailTicketOption, 'type' | 'class' | 'singleOrReturn' | 'price' | 'reservableStatus' | 'currency' | 'route' | 'routeCode'>\n            & { identifiers?: Maybe<(\n              { __typename?: 'RailIdentifiers' }\n              & Pick<RailIdentifiers, 'transactionIdentifier' | 'journeyIdentifier' | 'provider' | 'fareIdentifier' | 'direction' | 'singleOrReturn' | 'bookingRef'>\n            )>, terms?: Maybe<(\n              { __typename?: 'RailTicketTerms' }\n              & Pick<RailTicketTerms, 'error' | 'ticketTypeCode' | 'trainOperatingCompanyCode' | 'ticketTypeName' | 'ticketTypeAltName' | 'ticketTypeClass' | 'reservationRule' | 'journeyType' | 'preBookingRequirement' | 'generalValidity' | 'validOutRule' | 'validReturnRule' | 'generalDiscount' | 'childDiscount' | 'railcardDiscount' | 'refundCancellationRule' | 'changeRule' | 'ticketTypeConditionsDescription' | 'journeyBreakRule' | 'availabilityRule' | 'todAvailable' | 'kioskAvailable' | 'startDate' | 'endDate'>\n            )>, tickets?: Maybe<Array<Maybe<(\n              { __typename?: 'RailTicket' }\n              & Pick<RailTicket, 'price' | 'type' | 'route' | 'numChildren' | 'numAdults'>\n            )>>>, ticketQueueList?: Maybe<Array<Maybe<(\n              { __typename?: 'RailTicketQueue' }\n              & Pick<RailTicketQueue, 'id' | 'name' | 'type'>\n            )>>>, accountsList?: Maybe<Array<Maybe<(\n              { __typename?: 'RailAccount' }\n              & Pick<RailAccount, 'id' | 'reference' | 'description' | 'isDefault' | 'type'>\n            )>>> }\n          )> }\n        )>>, ticketExtras?: Maybe<Array<(\n          { __typename?: 'RailTicketExtra' }\n          & Pick<RailTicketExtra, 'type' | 'location' | 'date' | 'description' | 'amount' | 'adultAmount' | 'childAmount' | 'currency'>\n        )>>, plusBus?: Maybe<(\n          { __typename?: 'RailPlusBus' }\n          & Pick<RailPlusBus, 'originPlusBusNLC' | 'originStationNLC' | 'destinationPlusBusNLC' | 'destinationStationNLC'>\n        )> }\n      )>> }\n    )>, errors: Array<(\n      { __typename?: 'SearchError' }\n      & ErrorsFragment\n    )> }\n  ) }\n);\n\nexport type SaveRecentSearchMutationVariables = Exact<{\n  serviceType: ServiceType;\n  searchArgs: Scalars['JSON'];\n  travelDate: Scalars['DateTime'];\n  travellers?: Maybe<Array<Maybe<Scalars['ID']>> | Maybe<Scalars['ID']>>;\n}>;\n\n\nexport type SaveRecentSearchMutation = (\n  { __typename?: 'Mutation' }\n  & { saveRecentSearch: Array<(\n    { __typename?: 'Search' }\n    & Pick<Search, 'id'>\n  )> }\n);\n\nexport type SaveUserAddressMutationVariables = Exact<{\n  description: Scalars['String'];\n  numberOrName?: Maybe<Scalars['String']>;\n  street?: Maybe<Scalars['String']>;\n  town?: Maybe<Scalars['String']>;\n  county?: Maybe<Scalars['String']>;\n  postcode?: Maybe<Scalars['String']>;\n  countryCode?: Maybe<Scalars['String']>;\n  userPrimary?: Maybe<Scalars['Boolean']>;\n}>;\n\n\nexport type SaveUserAddressMutation = (\n  { __typename?: 'Mutation' }\n  & { saveUserAddress: (\n    { __typename?: 'Address' }\n    & Pick<Address, 'id' | 'description' | 'numberOrName' | 'street' | 'town' | 'county' | 'postcode' | 'countryCode' | 'userPrimary' | 'officePrimary'>\n  ) }\n);\n\nexport type SearchAirlinesQueryVariables = Exact<{\n  query: Scalars['String'];\n}>;\n\n\nexport type SearchAirlinesQuery = (\n  { __typename?: 'Query' }\n  & { searchAirlines: (\n    { __typename?: 'AirlineResults' }\n    & { iataMatch?: Maybe<(\n      { __typename?: 'AirlineResult' }\n      & Pick<AirlineResult, 'id' | 'name' | 'iata' | 'icao' | 'alias' | 'callsign' | 'active' | 'continent' | 'country' | 'countryCode' | 'bannerImage' | 'logoImage'>\n    )>, generalMatches: Array<(\n      { __typename?: 'AirlineResult' }\n      & Pick<AirlineResult, 'id' | 'name' | 'iata' | 'icao' | 'alias' | 'callsign' | 'active' | 'continent' | 'country' | 'countryCode' | 'bannerImage' | 'logoImage'>\n    )> }\n  ) }\n);\n\nexport type SearchCitiesQueryVariables = Exact<{\n  query: Scalars['String'];\n  countryCode?: Maybe<Scalars['String']>;\n}>;\n\n\nexport type SearchCitiesQuery = (\n  { __typename?: 'Query' }\n  & { searchCities: Array<(\n    { __typename?: 'City' }\n    & Pick<City, 'id' | 'name' | 'country' | 'countryCode' | 'continentName'>\n    & { coordinates: (\n      { __typename?: 'GeoCoordinates' }\n      & Pick<GeoCoordinates, 'latitude' | 'longitude' | 'altitude'>\n    ) }\n  )> }\n);\n\nexport type SearchConfermaCitiesQueryVariables = Exact<{\n  cityName: Scalars['String'];\n  countryCode: Scalars['String'];\n}>;\n\n\nexport type SearchConfermaCitiesQuery = (\n  { __typename?: 'Query' }\n  & { searchConfermaCities: (\n    { __typename?: 'ConfermaCityLocation' }\n    & Pick<ConfermaCityLocation, 'foundExact'>\n    & { suggestions?: Maybe<Array<Maybe<(\n      { __typename?: 'ConfermaCityLocationOptions' }\n      & Pick<ConfermaCityLocationOptions, 'name' | 'countryCode' | 'latitude' | 'longitude'>\n    )>>> }\n  ) }\n);\n\nexport type SearchEurostarQueryVariables = Exact<{\n  passengers: Array<FlightPassengerObject> | FlightPassengerObject;\n  originAirport?: Maybe<Scalars['String']>;\n  destinationAirport?: Maybe<Scalars['String']>;\n  multiDestination?: Maybe<Array<Maybe<DestinationEntry>> | Maybe<DestinationEntry>>;\n  outboundDate?: Maybe<Scalars['Date']>;\n  outboundDepartureTimeWindow?: Maybe<Scalars['String']>;\n  outboundArrivalTimeWindow?: Maybe<Scalars['String']>;\n  outboundCabinClass?: Maybe<Array<Maybe<FlightCabinClass>> | Maybe<FlightCabinClass>>;\n  returnTrip: Scalars['Boolean'];\n  returnDate?: Maybe<Scalars['Date']>;\n  returnDepartureTimeWindow?: Maybe<Scalars['String']>;\n  returnArrivalTimeWindow?: Maybe<Scalars['String']>;\n  returnCabinClass?: Maybe<Array<Maybe<FlightCabinClass>> | Maybe<FlightCabinClass>>;\n  fareType: FareType;\n  requireFreeBag?: Maybe<Scalars['Boolean']>;\n  maxConnections?: Maybe<Scalars['Int']>;\n  preferredCarriers?: Maybe<Array<Maybe<Scalars['String']>> | Maybe<Scalars['String']>>;\n  includeNearbyAirports?: Maybe<Scalars['Boolean']>;\n  asSingles?: Maybe<Scalars['Boolean']>;\n}>;\n\n\nexport type SearchEurostarQuery = (\n  { __typename?: 'Query' }\n  & { searchEurostar: (\n    { __typename?: 'FlightSearchResultV2' }\n    & { results: (\n      { __typename?: 'FEFlightSearchResults' }\n      & { journeys: Array<(\n        { __typename?: 'FlightItinerary' }\n        & Pick<FlightItinerary, 'uid' | 'passengerCount' | 'outboundTotalDuration' | 'inboundTotalDuration' | 'additional' | 'source' | 'sourceId' | 'version' | 'tmcPreferred' | 'companyPreferred' | 'officePreferred' | 'tmcPreferredMessage' | 'companyPreferredMessage' | 'officePreferredMessage' | 'unavailable' | 'unavailableMessage' | 'co2PerItem' | 'co2PerPassenger'>\n        & { outboundFlights: Array<(\n          { __typename?: 'FlightJourney' }\n          & Pick<FlightJourney, 'originAirport' | 'originTerminal' | 'originAirportName' | 'destinationAirport' | 'destinationTerminal' | 'destinationAirportName' | 'dateTimeDeparting' | 'dateTimeDepartingUTC' | 'dateTimeArriving' | 'dateTimeArrivingUTC' | 'marketingCarrier' | 'marketingCarrierName' | 'marketingFlightNumber' | 'operatingCarrier' | 'operatingCarrierName' | 'operatingFlightNumber' | 'equipmentCode' | 'equipmentName' | 'totalDuration' | 'cabinClass' | 'marketingNames' | 'vendorCode' | 'stops' | 'bookingCode' | 'marriageGroup' | 'fareBasisCode' | 'additional'>\n          & { fareInfo?: Maybe<(\n            { __typename?: 'FlightSpecialFareInfo' }\n            & Pick<FlightSpecialFareInfo, 'title' | 'type' | 'code' | 'supplierCode'>\n          )>, originAirportDetail: (\n            { __typename?: 'AirportDetail' }\n            & Pick<AirportDetail, 'iata' | 'icao' | 'latitude' | 'longitude' | 'altitude' | 'state' | 'city' | 'road' | 'popularity' | 'area' | 'location' | 'offset' | 'airportName' | 'countryName' | 'countryCode' | 'postcode'>\n          ), destinationAirportDetail: (\n            { __typename?: 'AirportDetail' }\n            & Pick<AirportDetail, 'iata' | 'icao' | 'latitude' | 'longitude' | 'altitude' | 'state' | 'city' | 'road' | 'popularity' | 'area' | 'location' | 'offset' | 'airportName' | 'countryName' | 'countryCode' | 'postcode'>\n          ), marketingCarrierDetail: (\n            { __typename?: 'FlightCarrierDetail' }\n            & Pick<FlightCarrierDetail, 'name' | 'alias' | 'callsign' | 'iata' | 'icao' | 'logo' | 'banner' | 'popularity'>\n          ), operatingCarrierDetail: (\n            { __typename?: 'FlightCarrierDetail' }\n            & Pick<FlightCarrierDetail, 'name' | 'alias' | 'callsign' | 'iata' | 'icao' | 'logo' | 'banner' | 'popularity'>\n          ), fareConditions: (\n            { __typename?: 'FareConditions' }\n            & { cancellation?: Maybe<Array<Maybe<(\n              { __typename?: 'FareConditionEntry' }\n              & Pick<FareConditionEntry, 'name' | 'type' | 'currency' | 'amount' | 'remark' | 'changeFeeInd' | 'cancelFeeInd' | 'refundableInd'>\n            )>>>, change?: Maybe<Array<Maybe<(\n              { __typename?: 'FareConditionEntry' }\n              & Pick<FareConditionEntry, 'name' | 'type' | 'currency' | 'amount' | 'remark' | 'changeFeeInd' | 'cancelFeeInd' | 'refundableInd'>\n            )>>>, noShow?: Maybe<Array<Maybe<(\n              { __typename?: 'FareConditionEntry' }\n              & Pick<FareConditionEntry, 'name' | 'type' | 'currency' | 'amount' | 'remark' | 'changeFeeInd' | 'cancelFeeInd' | 'refundableInd'>\n            )>>>, upgrade?: Maybe<Array<Maybe<(\n              { __typename?: 'FareConditionEntry' }\n              & Pick<FareConditionEntry, 'name' | 'type' | 'currency' | 'amount' | 'remark' | 'changeFeeInd' | 'cancelFeeInd' | 'refundableInd'>\n            )>>>, other?: Maybe<Array<Maybe<(\n              { __typename?: 'FareConditionEntry' }\n              & Pick<FareConditionEntry, 'name' | 'type' | 'currency' | 'amount' | 'remark' | 'changeFeeInd' | 'cancelFeeInd' | 'refundableInd'>\n            )>>> }\n          ) }\n        )>, inboundFlights?: Maybe<Array<Maybe<(\n          { __typename?: 'FlightJourney' }\n          & Pick<FlightJourney, 'originAirport' | 'originTerminal' | 'originAirportName' | 'destinationAirport' | 'destinationTerminal' | 'destinationAirportName' | 'dateTimeDeparting' | 'dateTimeDepartingUTC' | 'dateTimeArriving' | 'dateTimeArrivingUTC' | 'marketingCarrier' | 'marketingCarrierName' | 'marketingFlightNumber' | 'operatingCarrier' | 'operatingCarrierName' | 'operatingFlightNumber' | 'equipmentCode' | 'equipmentName' | 'totalDuration' | 'cabinClass' | 'marketingNames' | 'vendorCode' | 'stops' | 'bookingCode' | 'marriageGroup' | 'fareBasisCode' | 'additional'>\n          & { fareInfo?: Maybe<(\n            { __typename?: 'FlightSpecialFareInfo' }\n            & Pick<FlightSpecialFareInfo, 'title' | 'type' | 'code' | 'supplierCode'>\n          )>, originAirportDetail: (\n            { __typename?: 'AirportDetail' }\n            & Pick<AirportDetail, 'iata' | 'icao' | 'latitude' | 'longitude' | 'altitude' | 'state' | 'city' | 'road' | 'popularity' | 'area' | 'location' | 'offset' | 'airportName' | 'countryName' | 'countryCode' | 'postcode'>\n          ), destinationAirportDetail: (\n            { __typename?: 'AirportDetail' }\n            & Pick<AirportDetail, 'iata' | 'icao' | 'latitude' | 'longitude' | 'altitude' | 'state' | 'city' | 'road' | 'popularity' | 'area' | 'location' | 'offset' | 'airportName' | 'countryName' | 'countryCode' | 'postcode'>\n          ), marketingCarrierDetail: (\n            { __typename?: 'FlightCarrierDetail' }\n            & Pick<FlightCarrierDetail, 'name' | 'alias' | 'callsign' | 'iata' | 'icao' | 'logo' | 'banner' | 'popularity'>\n          ), operatingCarrierDetail: (\n            { __typename?: 'FlightCarrierDetail' }\n            & Pick<FlightCarrierDetail, 'name' | 'alias' | 'callsign' | 'iata' | 'icao' | 'logo' | 'banner' | 'popularity'>\n          ), fareConditions: (\n            { __typename?: 'FareConditions' }\n            & { cancellation?: Maybe<Array<Maybe<(\n              { __typename?: 'FareConditionEntry' }\n              & Pick<FareConditionEntry, 'name' | 'type' | 'currency' | 'amount' | 'remark' | 'changeFeeInd' | 'cancelFeeInd' | 'refundableInd'>\n            )>>>, change?: Maybe<Array<Maybe<(\n              { __typename?: 'FareConditionEntry' }\n              & Pick<FareConditionEntry, 'name' | 'type' | 'currency' | 'amount' | 'remark' | 'changeFeeInd' | 'cancelFeeInd' | 'refundableInd'>\n            )>>>, noShow?: Maybe<Array<Maybe<(\n              { __typename?: 'FareConditionEntry' }\n              & Pick<FareConditionEntry, 'name' | 'type' | 'currency' | 'amount' | 'remark' | 'changeFeeInd' | 'cancelFeeInd' | 'refundableInd'>\n            )>>>, upgrade?: Maybe<Array<Maybe<(\n              { __typename?: 'FareConditionEntry' }\n              & Pick<FareConditionEntry, 'name' | 'type' | 'currency' | 'amount' | 'remark' | 'changeFeeInd' | 'cancelFeeInd' | 'refundableInd'>\n            )>>>, other?: Maybe<Array<Maybe<(\n              { __typename?: 'FareConditionEntry' }\n              & Pick<FareConditionEntry, 'name' | 'type' | 'currency' | 'amount' | 'remark' | 'changeFeeInd' | 'cancelFeeInd' | 'refundableInd'>\n            )>>> }\n          ) }\n        )>>>, outboundCarbonEmissions?: Maybe<(\n          { __typename?: 'FlightCarbonEmissions' }\n          & Pick<FlightCarbonEmissions, 'amount' | 'unit'>\n        )>, inboundCarbonEmissions?: Maybe<(\n          { __typename?: 'FlightCarbonEmissions' }\n          & Pick<FlightCarbonEmissions, 'amount' | 'unit'>\n        )>, taxes?: Maybe<Array<Maybe<(\n          { __typename?: 'FlightAmount' }\n          & Pick<FlightAmount, 'description' | 'amount' | 'currency'>\n        )>>>, discounts?: Maybe<Array<Maybe<(\n          { __typename?: 'FlightAmount' }\n          & Pick<FlightAmount, 'description' | 'amount' | 'currency'>\n        )>>>, total: (\n          { __typename?: 'FlightFareTotal' }\n          & Pick<FlightFareTotal, 'price' | 'tax' | 'discount' | 'currency'>\n        ), fareConditions?: Maybe<(\n          { __typename?: 'FareConditions' }\n          & { cancellation?: Maybe<Array<Maybe<(\n            { __typename?: 'FareConditionEntry' }\n            & Pick<FareConditionEntry, 'name' | 'type' | 'currency' | 'amount' | 'remark' | 'changeFeeInd' | 'cancelFeeInd' | 'refundableInd'>\n          )>>>, change?: Maybe<Array<Maybe<(\n            { __typename?: 'FareConditionEntry' }\n            & Pick<FareConditionEntry, 'name' | 'type' | 'currency' | 'amount' | 'remark' | 'changeFeeInd' | 'cancelFeeInd' | 'refundableInd'>\n          )>>>, noShow?: Maybe<Array<Maybe<(\n            { __typename?: 'FareConditionEntry' }\n            & Pick<FareConditionEntry, 'name' | 'type' | 'currency' | 'amount' | 'remark' | 'changeFeeInd' | 'cancelFeeInd' | 'refundableInd'>\n          )>>>, upgrade?: Maybe<Array<Maybe<(\n            { __typename?: 'FareConditionEntry' }\n            & Pick<FareConditionEntry, 'name' | 'type' | 'currency' | 'amount' | 'remark' | 'changeFeeInd' | 'cancelFeeInd' | 'refundableInd'>\n          )>>>, other?: Maybe<Array<Maybe<(\n            { __typename?: 'FareConditionEntry' }\n            & Pick<FareConditionEntry, 'name' | 'type' | 'currency' | 'amount' | 'remark' | 'changeFeeInd' | 'cancelFeeInd' | 'refundableInd'>\n          )>>> }\n        )>, baggageAllowance?: Maybe<Array<Maybe<(\n          { __typename?: 'BaggageAllowance' }\n          & Pick<BaggageAllowance, 'type' | 'qty' | 'maxKG' | 'maxLBS'>\n        )>>> }\n      )>, multi: Array<(\n        { __typename?: 'ItinerarySummary' }\n        & Pick<ItinerarySummary, 'order' | 'origin' | 'destination' | 'minPrice' | 'maxPrice'>\n        & { results: Array<(\n          { __typename?: 'FlightItinerary' }\n          & Pick<FlightItinerary, 'uid' | 'passengerCount' | 'outboundTotalDuration' | 'inboundTotalDuration' | 'additional' | 'source' | 'sourceId' | 'version' | 'tmcPreferred' | 'companyPreferred' | 'officePreferred' | 'tmcPreferredMessage' | 'companyPreferredMessage' | 'officePreferredMessage' | 'unavailable' | 'unavailableMessage' | 'co2PerItem' | 'co2PerPassenger'>\n          & { outboundFlights: Array<(\n            { __typename?: 'FlightJourney' }\n            & Pick<FlightJourney, 'originAirport' | 'originTerminal' | 'originAirportName' | 'destinationAirport' | 'destinationTerminal' | 'destinationAirportName' | 'dateTimeDeparting' | 'dateTimeDepartingUTC' | 'dateTimeArriving' | 'dateTimeArrivingUTC' | 'marketingCarrier' | 'marketingCarrierName' | 'marketingFlightNumber' | 'operatingCarrier' | 'operatingCarrierName' | 'operatingFlightNumber' | 'equipmentCode' | 'equipmentName' | 'totalDuration' | 'cabinClass' | 'marketingNames' | 'vendorCode' | 'stops' | 'bookingCode' | 'marriageGroup' | 'fareBasisCode' | 'additional'>\n            & { fareInfo?: Maybe<(\n              { __typename?: 'FlightSpecialFareInfo' }\n              & Pick<FlightSpecialFareInfo, 'title' | 'type' | 'code' | 'supplierCode'>\n            )>, originAirportDetail: (\n              { __typename?: 'AirportDetail' }\n              & Pick<AirportDetail, 'iata' | 'icao' | 'latitude' | 'longitude' | 'altitude' | 'state' | 'city' | 'road' | 'popularity' | 'area' | 'location' | 'offset' | 'airportName' | 'countryName' | 'countryCode' | 'postcode'>\n            ), destinationAirportDetail: (\n              { __typename?: 'AirportDetail' }\n              & Pick<AirportDetail, 'iata' | 'icao' | 'latitude' | 'longitude' | 'altitude' | 'state' | 'city' | 'road' | 'popularity' | 'area' | 'location' | 'offset' | 'airportName' | 'countryName' | 'countryCode' | 'postcode'>\n            ), marketingCarrierDetail: (\n              { __typename?: 'FlightCarrierDetail' }\n              & Pick<FlightCarrierDetail, 'name' | 'alias' | 'callsign' | 'iata' | 'icao' | 'logo' | 'banner' | 'popularity'>\n            ), operatingCarrierDetail: (\n              { __typename?: 'FlightCarrierDetail' }\n              & Pick<FlightCarrierDetail, 'name' | 'alias' | 'callsign' | 'iata' | 'icao' | 'logo' | 'banner' | 'popularity'>\n            ), fareConditions: (\n              { __typename?: 'FareConditions' }\n              & { cancellation?: Maybe<Array<Maybe<(\n                { __typename?: 'FareConditionEntry' }\n                & Pick<FareConditionEntry, 'name' | 'type' | 'currency' | 'amount' | 'remark' | 'changeFeeInd' | 'cancelFeeInd' | 'refundableInd'>\n              )>>>, change?: Maybe<Array<Maybe<(\n                { __typename?: 'FareConditionEntry' }\n                & Pick<FareConditionEntry, 'name' | 'type' | 'currency' | 'amount' | 'remark' | 'changeFeeInd' | 'cancelFeeInd' | 'refundableInd'>\n              )>>>, noShow?: Maybe<Array<Maybe<(\n                { __typename?: 'FareConditionEntry' }\n                & Pick<FareConditionEntry, 'name' | 'type' | 'currency' | 'amount' | 'remark' | 'changeFeeInd' | 'cancelFeeInd' | 'refundableInd'>\n              )>>>, upgrade?: Maybe<Array<Maybe<(\n                { __typename?: 'FareConditionEntry' }\n                & Pick<FareConditionEntry, 'name' | 'type' | 'currency' | 'amount' | 'remark' | 'changeFeeInd' | 'cancelFeeInd' | 'refundableInd'>\n              )>>>, other?: Maybe<Array<Maybe<(\n                { __typename?: 'FareConditionEntry' }\n                & Pick<FareConditionEntry, 'name' | 'type' | 'currency' | 'amount' | 'remark' | 'changeFeeInd' | 'cancelFeeInd' | 'refundableInd'>\n              )>>> }\n            ) }\n          )>, inboundFlights?: Maybe<Array<Maybe<(\n            { __typename?: 'FlightJourney' }\n            & Pick<FlightJourney, 'originAirport' | 'originTerminal' | 'originAirportName' | 'destinationAirport' | 'destinationTerminal' | 'destinationAirportName' | 'dateTimeDeparting' | 'dateTimeDepartingUTC' | 'dateTimeArriving' | 'dateTimeArrivingUTC' | 'marketingCarrier' | 'marketingCarrierName' | 'marketingFlightNumber' | 'operatingCarrier' | 'operatingCarrierName' | 'operatingFlightNumber' | 'equipmentCode' | 'equipmentName' | 'totalDuration' | 'cabinClass' | 'marketingNames' | 'vendorCode' | 'stops' | 'bookingCode' | 'marriageGroup' | 'fareBasisCode' | 'additional'>\n            & { fareInfo?: Maybe<(\n              { __typename?: 'FlightSpecialFareInfo' }\n              & Pick<FlightSpecialFareInfo, 'title' | 'type' | 'code' | 'supplierCode'>\n            )>, originAirportDetail: (\n              { __typename?: 'AirportDetail' }\n              & Pick<AirportDetail, 'iata' | 'icao' | 'latitude' | 'longitude' | 'altitude' | 'state' | 'city' | 'road' | 'popularity' | 'area' | 'location' | 'offset' | 'airportName' | 'countryName' | 'countryCode' | 'postcode'>\n            ), destinationAirportDetail: (\n              { __typename?: 'AirportDetail' }\n              & Pick<AirportDetail, 'iata' | 'icao' | 'latitude' | 'longitude' | 'altitude' | 'state' | 'city' | 'road' | 'popularity' | 'area' | 'location' | 'offset' | 'airportName' | 'countryName' | 'countryCode' | 'postcode'>\n            ), marketingCarrierDetail: (\n              { __typename?: 'FlightCarrierDetail' }\n              & Pick<FlightCarrierDetail, 'name' | 'alias' | 'callsign' | 'iata' | 'icao' | 'logo' | 'banner' | 'popularity'>\n            ), operatingCarrierDetail: (\n              { __typename?: 'FlightCarrierDetail' }\n              & Pick<FlightCarrierDetail, 'name' | 'alias' | 'callsign' | 'iata' | 'icao' | 'logo' | 'banner' | 'popularity'>\n            ), fareConditions: (\n              { __typename?: 'FareConditions' }\n              & { cancellation?: Maybe<Array<Maybe<(\n                { __typename?: 'FareConditionEntry' }\n                & Pick<FareConditionEntry, 'name' | 'type' | 'currency' | 'amount' | 'remark' | 'changeFeeInd' | 'cancelFeeInd' | 'refundableInd'>\n              )>>>, change?: Maybe<Array<Maybe<(\n                { __typename?: 'FareConditionEntry' }\n                & Pick<FareConditionEntry, 'name' | 'type' | 'currency' | 'amount' | 'remark' | 'changeFeeInd' | 'cancelFeeInd' | 'refundableInd'>\n              )>>>, noShow?: Maybe<Array<Maybe<(\n                { __typename?: 'FareConditionEntry' }\n                & Pick<FareConditionEntry, 'name' | 'type' | 'currency' | 'amount' | 'remark' | 'changeFeeInd' | 'cancelFeeInd' | 'refundableInd'>\n              )>>>, upgrade?: Maybe<Array<Maybe<(\n                { __typename?: 'FareConditionEntry' }\n                & Pick<FareConditionEntry, 'name' | 'type' | 'currency' | 'amount' | 'remark' | 'changeFeeInd' | 'cancelFeeInd' | 'refundableInd'>\n              )>>>, other?: Maybe<Array<Maybe<(\n                { __typename?: 'FareConditionEntry' }\n                & Pick<FareConditionEntry, 'name' | 'type' | 'currency' | 'amount' | 'remark' | 'changeFeeInd' | 'cancelFeeInd' | 'refundableInd'>\n              )>>> }\n            ) }\n          )>>>, outboundCarbonEmissions?: Maybe<(\n            { __typename?: 'FlightCarbonEmissions' }\n            & Pick<FlightCarbonEmissions, 'amount' | 'unit'>\n          )>, inboundCarbonEmissions?: Maybe<(\n            { __typename?: 'FlightCarbonEmissions' }\n            & Pick<FlightCarbonEmissions, 'amount' | 'unit'>\n          )>, taxes?: Maybe<Array<Maybe<(\n            { __typename?: 'FlightAmount' }\n            & Pick<FlightAmount, 'description' | 'amount' | 'currency'>\n          )>>>, discounts?: Maybe<Array<Maybe<(\n            { __typename?: 'FlightAmount' }\n            & Pick<FlightAmount, 'description' | 'amount' | 'currency'>\n          )>>>, total: (\n            { __typename?: 'FlightFareTotal' }\n            & Pick<FlightFareTotal, 'price' | 'tax' | 'discount' | 'currency'>\n          ), fareConditions?: Maybe<(\n            { __typename?: 'FareConditions' }\n            & { cancellation?: Maybe<Array<Maybe<(\n              { __typename?: 'FareConditionEntry' }\n              & Pick<FareConditionEntry, 'name' | 'type' | 'currency' | 'amount' | 'remark' | 'changeFeeInd' | 'cancelFeeInd' | 'refundableInd'>\n            )>>>, change?: Maybe<Array<Maybe<(\n              { __typename?: 'FareConditionEntry' }\n              & Pick<FareConditionEntry, 'name' | 'type' | 'currency' | 'amount' | 'remark' | 'changeFeeInd' | 'cancelFeeInd' | 'refundableInd'>\n            )>>>, noShow?: Maybe<Array<Maybe<(\n              { __typename?: 'FareConditionEntry' }\n              & Pick<FareConditionEntry, 'name' | 'type' | 'currency' | 'amount' | 'remark' | 'changeFeeInd' | 'cancelFeeInd' | 'refundableInd'>\n            )>>>, upgrade?: Maybe<Array<Maybe<(\n              { __typename?: 'FareConditionEntry' }\n              & Pick<FareConditionEntry, 'name' | 'type' | 'currency' | 'amount' | 'remark' | 'changeFeeInd' | 'cancelFeeInd' | 'refundableInd'>\n            )>>>, other?: Maybe<Array<Maybe<(\n              { __typename?: 'FareConditionEntry' }\n              & Pick<FareConditionEntry, 'name' | 'type' | 'currency' | 'amount' | 'remark' | 'changeFeeInd' | 'cancelFeeInd' | 'refundableInd'>\n            )>>> }\n          )>, baggageAllowance?: Maybe<Array<Maybe<(\n            { __typename?: 'BaggageAllowance' }\n            & Pick<BaggageAllowance, 'type' | 'qty' | 'maxKG' | 'maxLBS'>\n          )>>> }\n        )> }\n      )>, grouped?: Maybe<Array<(\n        { __typename?: 'GroupFlights' }\n        & Pick<GroupFlights, 'referenceID' | 'flightID' | 'boundIndicator' | 'minPrice' | 'maxPrice'>\n        & { flights: (\n          { __typename?: 'MatchingFlights' }\n          & Pick<MatchingFlights, 'LiteEconomy' | 'EconomyRestricted' | 'EconomyNoBags' | 'Economy' | 'PremiumEconomy' | 'Business' | 'PremiumBusiness' | 'First' | 'PremiumFirst'>\n        ) }\n      )>> }\n    ), errors: Array<(\n      { __typename?: 'SearchError' }\n      & ErrorsFragment\n    )> }\n  ) }\n);\n\nexport type SearchHotelChainsQueryVariables = Exact<{\n  query: Scalars['String'];\n}>;\n\n\nexport type SearchHotelChainsQuery = (\n  { __typename?: 'Query' }\n  & Pick<Query, 'searchHotelChains'>\n);\n\nexport type SearchIrlQueryVariables = Exact<{\n  supplier: IrlSupplier;\n  countryCode: Scalars['String'];\n  journeyType: IrlJourneyType;\n  class?: Maybe<IrlClass>;\n  outboundDepartureDateTime: Scalars['DateTime'];\n  departureLocationId: Scalars['ID'];\n  arrivalLocationId: Scalars['ID'];\n  adults: Scalars['Int'];\n  children?: Maybe<Scalars['Int']>;\n  returnDepartureDateTime?: Maybe<Scalars['DateTime']>;\n}>;\n\n\nexport type SearchIrlQuery = (\n  { __typename?: 'Query' }\n  & { searchIRL: (\n    { __typename?: 'IRLSearchResult' }\n    & { results: Array<(\n      { __typename?: 'IRLJourneyOptions' }\n      & Pick<IrlJourneyOptions, 'source' | 'sourceId'>\n      & { outbound?: Maybe<Array<(\n        { __typename?: 'IRLJourneyOption' }\n        & Pick<IrlJourneyOption, 'from' | 'fromCode' | 'to' | 'toCode' | 'departDateTime' | 'arriveDateTime' | 'changes' | 'unsellable'>\n        & { identifiers?: Maybe<(\n          { __typename?: 'IRLIdentifiers' }\n          & Pick<IrlIdentifiers, 'transactionIdentifier' | 'signature' | 'journeyIdentifier' | 'provider' | 'fareIdentifier' | 'direction' | 'singleOrReturn' | 'bookingRef'>\n        )>, travellers?: Maybe<Array<(\n          { __typename?: 'IRLTraveller' }\n          & Pick<IrlTraveller, 'status' | 'id' | 'dob' | 'railcard' | 'givenName' | 'surname' | 'nameTitle' | 'contactInfo' | 'deliveryEmailAddress' | 'fare'>\n        )>>, segments?: Maybe<Array<(\n          { __typename?: 'IRLSegment' }\n          & Pick<IrlSegment, 'id' | 'operator' | 'depart' | 'departDateTime' | 'arrive' | 'arriveDateTime' | 'reservableStatus' | 'seatPreferenceGroup'>\n          & { seatPreferenceTypes?: Maybe<Array<(\n            { __typename?: 'IRLSeatPreferenceType' }\n            & Pick<IrlSeatPreferenceType, 'name' | 'allowedValues'>\n          )>>, seats?: Maybe<Array<(\n            { __typename?: 'IRLSeat' }\n            & Pick<IrlSeat, 'location' | 'coach' | 'number' | 'direction' | 'position' | 'deck' | 'seatType' | 'seatSelection' | 'facilities' | 'note'>\n          )>> }\n        )>>, providers?: Maybe<Array<(\n          { __typename?: 'IRLProvider' }\n          & Pick<IrlProvider, 'providerId' | 'name'>\n          & { cheapestTicket?: Maybe<(\n            { __typename?: 'IRLTicketOption' }\n            & Pick<IrlTicketOption, 'type' | 'class' | 'singleOrReturn' | 'price' | 'reservableStatus' | 'currency' | 'route' | 'routeCode'>\n            & { identifiers?: Maybe<(\n              { __typename?: 'IRLIdentifiers' }\n              & Pick<IrlIdentifiers, 'transactionIdentifier' | 'signature' | 'journeyIdentifier' | 'provider' | 'fareIdentifier' | 'direction' | 'singleOrReturn' | 'bookingRef'>\n            )>, tickets?: Maybe<Array<Maybe<(\n              { __typename?: 'IRLTicket' }\n              & Pick<IrlTicket, 'price' | 'type' | 'route' | 'numChildren' | 'numAdults'>\n              & { segments?: Maybe<Array<(\n                { __typename?: 'IRLSegment' }\n                & Pick<IrlSegment, 'id' | 'operator' | 'depart' | 'departDateTime' | 'arrive' | 'arriveDateTime' | 'reservableStatus' | 'seatPreferenceGroup'>\n                & { seatPreferenceTypes?: Maybe<Array<(\n                  { __typename?: 'IRLSeatPreferenceType' }\n                  & Pick<IrlSeatPreferenceType, 'name' | 'allowedValues'>\n                )>>, seats?: Maybe<Array<(\n                  { __typename?: 'IRLSeat' }\n                  & Pick<IrlSeat, 'location' | 'coach' | 'number' | 'direction' | 'position' | 'deck' | 'seatType' | 'seatSelection' | 'facilities' | 'note'>\n                )>> }\n              )>> }\n            )>>> }\n          )>, ticketOptions?: Maybe<Array<Maybe<(\n            { __typename?: 'IRLTicketOption' }\n            & Pick<IrlTicketOption, 'type' | 'class' | 'singleOrReturn' | 'price' | 'reservableStatus' | 'currency' | 'route' | 'routeCode'>\n            & { identifiers?: Maybe<(\n              { __typename?: 'IRLIdentifiers' }\n              & Pick<IrlIdentifiers, 'transactionIdentifier' | 'signature' | 'journeyIdentifier' | 'provider' | 'fareIdentifier' | 'direction' | 'singleOrReturn' | 'bookingRef'>\n            )>, tickets?: Maybe<Array<Maybe<(\n              { __typename?: 'IRLTicket' }\n              & Pick<IrlTicket, 'price' | 'type' | 'route' | 'numChildren' | 'numAdults'>\n              & { segments?: Maybe<Array<(\n                { __typename?: 'IRLSegment' }\n                & Pick<IrlSegment, 'id' | 'operator' | 'depart' | 'departDateTime' | 'arrive' | 'arriveDateTime' | 'reservableStatus' | 'seatPreferenceGroup'>\n                & { seatPreferenceTypes?: Maybe<Array<(\n                  { __typename?: 'IRLSeatPreferenceType' }\n                  & Pick<IrlSeatPreferenceType, 'name' | 'allowedValues'>\n                )>>, seats?: Maybe<Array<(\n                  { __typename?: 'IRLSeat' }\n                  & Pick<IrlSeat, 'location' | 'coach' | 'number' | 'direction' | 'position' | 'deck' | 'seatType' | 'seatSelection' | 'facilities' | 'note'>\n                )>> }\n              )>> }\n            )>>> }\n          )>>>, bookedTicket?: Maybe<(\n            { __typename?: 'IRLTicketOption' }\n            & Pick<IrlTicketOption, 'type' | 'class' | 'singleOrReturn' | 'price' | 'reservableStatus' | 'currency' | 'route' | 'routeCode'>\n            & { identifiers?: Maybe<(\n              { __typename?: 'IRLIdentifiers' }\n              & Pick<IrlIdentifiers, 'transactionIdentifier' | 'signature' | 'journeyIdentifier' | 'provider' | 'fareIdentifier' | 'direction' | 'singleOrReturn' | 'bookingRef'>\n            )>, tickets?: Maybe<Array<Maybe<(\n              { __typename?: 'IRLTicket' }\n              & Pick<IrlTicket, 'price' | 'type' | 'route' | 'numChildren' | 'numAdults'>\n              & { segments?: Maybe<Array<(\n                { __typename?: 'IRLSegment' }\n                & Pick<IrlSegment, 'id' | 'operator' | 'depart' | 'departDateTime' | 'arrive' | 'arriveDateTime' | 'reservableStatus' | 'seatPreferenceGroup'>\n                & { seatPreferenceTypes?: Maybe<Array<(\n                  { __typename?: 'IRLSeatPreferenceType' }\n                  & Pick<IrlSeatPreferenceType, 'name' | 'allowedValues'>\n                )>>, seats?: Maybe<Array<(\n                  { __typename?: 'IRLSeat' }\n                  & Pick<IrlSeat, 'location' | 'coach' | 'number' | 'direction' | 'position' | 'deck' | 'seatType' | 'seatSelection' | 'facilities' | 'note'>\n                )>> }\n              )>> }\n            )>>> }\n          )> }\n        )>>, ticketExtras?: Maybe<Array<(\n          { __typename?: 'IRLTicketExtra' }\n          & Pick<IrlTicketExtra, 'type' | 'location' | 'date' | 'description' | 'amount' | 'adultAmount' | 'childAmount' | 'currency'>\n          & { identifiers?: Maybe<(\n            { __typename?: 'IRLTicketExtraIdentifiers' }\n            & Pick<IrlTicketExtraIdentifiers, 'type' | 'location' | 'date' | 'journeyId' | 'isOrigin'>\n          )> }\n        )>>, plusBus?: Maybe<(\n          { __typename?: 'IRLPlusBus' }\n          & Pick<IrlPlusBus, 'originPlusBusNLC' | 'originStationNLC' | 'destinationPlusBusNLC' | 'destinationStationNLC'>\n        )> }\n      )>>, return?: Maybe<Array<(\n        { __typename?: 'IRLJourneyOption' }\n        & Pick<IrlJourneyOption, 'from' | 'fromCode' | 'to' | 'toCode' | 'departDateTime' | 'arriveDateTime' | 'changes' | 'unsellable'>\n        & { identifiers?: Maybe<(\n          { __typename?: 'IRLIdentifiers' }\n          & Pick<IrlIdentifiers, 'transactionIdentifier' | 'signature' | 'journeyIdentifier' | 'provider' | 'fareIdentifier' | 'direction' | 'singleOrReturn' | 'bookingRef'>\n        )>, travellers?: Maybe<Array<(\n          { __typename?: 'IRLTraveller' }\n          & Pick<IrlTraveller, 'status' | 'id' | 'dob' | 'railcard' | 'givenName' | 'surname' | 'nameTitle' | 'contactInfo' | 'deliveryEmailAddress' | 'fare'>\n        )>>, segments?: Maybe<Array<(\n          { __typename?: 'IRLSegment' }\n          & Pick<IrlSegment, 'id' | 'operator' | 'depart' | 'departDateTime' | 'arrive' | 'arriveDateTime' | 'reservableStatus' | 'seatPreferenceGroup'>\n          & { seatPreferenceTypes?: Maybe<Array<(\n            { __typename?: 'IRLSeatPreferenceType' }\n            & Pick<IrlSeatPreferenceType, 'name' | 'allowedValues'>\n          )>>, seats?: Maybe<Array<(\n            { __typename?: 'IRLSeat' }\n            & Pick<IrlSeat, 'location' | 'coach' | 'number' | 'direction' | 'position' | 'deck' | 'seatType' | 'seatSelection' | 'facilities' | 'note'>\n          )>> }\n        )>>, providers?: Maybe<Array<(\n          { __typename?: 'IRLProvider' }\n          & Pick<IrlProvider, 'providerId' | 'name'>\n          & { cheapestTicket?: Maybe<(\n            { __typename?: 'IRLTicketOption' }\n            & Pick<IrlTicketOption, 'type' | 'class' | 'singleOrReturn' | 'price' | 'reservableStatus' | 'currency' | 'route' | 'routeCode'>\n            & { identifiers?: Maybe<(\n              { __typename?: 'IRLIdentifiers' }\n              & Pick<IrlIdentifiers, 'transactionIdentifier' | 'signature' | 'journeyIdentifier' | 'provider' | 'fareIdentifier' | 'direction' | 'singleOrReturn' | 'bookingRef'>\n            )>, tickets?: Maybe<Array<Maybe<(\n              { __typename?: 'IRLTicket' }\n              & Pick<IrlTicket, 'price' | 'type' | 'route' | 'numChildren' | 'numAdults'>\n              & { segments?: Maybe<Array<(\n                { __typename?: 'IRLSegment' }\n                & Pick<IrlSegment, 'id' | 'operator' | 'depart' | 'departDateTime' | 'arrive' | 'arriveDateTime' | 'reservableStatus' | 'seatPreferenceGroup'>\n                & { seatPreferenceTypes?: Maybe<Array<(\n                  { __typename?: 'IRLSeatPreferenceType' }\n                  & Pick<IrlSeatPreferenceType, 'name' | 'allowedValues'>\n                )>>, seats?: Maybe<Array<(\n                  { __typename?: 'IRLSeat' }\n                  & Pick<IrlSeat, 'location' | 'coach' | 'number' | 'direction' | 'position' | 'deck' | 'seatType' | 'seatSelection' | 'facilities' | 'note'>\n                )>> }\n              )>> }\n            )>>> }\n          )>, ticketOptions?: Maybe<Array<Maybe<(\n            { __typename?: 'IRLTicketOption' }\n            & Pick<IrlTicketOption, 'type' | 'class' | 'singleOrReturn' | 'price' | 'reservableStatus' | 'currency' | 'route' | 'routeCode'>\n            & { identifiers?: Maybe<(\n              { __typename?: 'IRLIdentifiers' }\n              & Pick<IrlIdentifiers, 'transactionIdentifier' | 'signature' | 'journeyIdentifier' | 'provider' | 'fareIdentifier' | 'direction' | 'singleOrReturn' | 'bookingRef'>\n            )>, tickets?: Maybe<Array<Maybe<(\n              { __typename?: 'IRLTicket' }\n              & Pick<IrlTicket, 'price' | 'type' | 'route' | 'numChildren' | 'numAdults'>\n              & { segments?: Maybe<Array<(\n                { __typename?: 'IRLSegment' }\n                & Pick<IrlSegment, 'id' | 'operator' | 'depart' | 'departDateTime' | 'arrive' | 'arriveDateTime' | 'reservableStatus' | 'seatPreferenceGroup'>\n                & { seatPreferenceTypes?: Maybe<Array<(\n                  { __typename?: 'IRLSeatPreferenceType' }\n                  & Pick<IrlSeatPreferenceType, 'name' | 'allowedValues'>\n                )>>, seats?: Maybe<Array<(\n                  { __typename?: 'IRLSeat' }\n                  & Pick<IrlSeat, 'location' | 'coach' | 'number' | 'direction' | 'position' | 'deck' | 'seatType' | 'seatSelection' | 'facilities' | 'note'>\n                )>> }\n              )>> }\n            )>>> }\n          )>>>, bookedTicket?: Maybe<(\n            { __typename?: 'IRLTicketOption' }\n            & Pick<IrlTicketOption, 'type' | 'class' | 'singleOrReturn' | 'price' | 'reservableStatus' | 'currency' | 'route' | 'routeCode'>\n            & { identifiers?: Maybe<(\n              { __typename?: 'IRLIdentifiers' }\n              & Pick<IrlIdentifiers, 'transactionIdentifier' | 'signature' | 'journeyIdentifier' | 'provider' | 'fareIdentifier' | 'direction' | 'singleOrReturn' | 'bookingRef'>\n            )>, tickets?: Maybe<Array<Maybe<(\n              { __typename?: 'IRLTicket' }\n              & Pick<IrlTicket, 'price' | 'type' | 'route' | 'numChildren' | 'numAdults'>\n              & { segments?: Maybe<Array<(\n                { __typename?: 'IRLSegment' }\n                & Pick<IrlSegment, 'id' | 'operator' | 'depart' | 'departDateTime' | 'arrive' | 'arriveDateTime' | 'reservableStatus' | 'seatPreferenceGroup'>\n                & { seatPreferenceTypes?: Maybe<Array<(\n                  { __typename?: 'IRLSeatPreferenceType' }\n                  & Pick<IrlSeatPreferenceType, 'name' | 'allowedValues'>\n                )>>, seats?: Maybe<Array<(\n                  { __typename?: 'IRLSeat' }\n                  & Pick<IrlSeat, 'location' | 'coach' | 'number' | 'direction' | 'position' | 'deck' | 'seatType' | 'seatSelection' | 'facilities' | 'note'>\n                )>> }\n              )>> }\n            )>>> }\n          )> }\n        )>>, ticketExtras?: Maybe<Array<(\n          { __typename?: 'IRLTicketExtra' }\n          & Pick<IrlTicketExtra, 'type' | 'location' | 'date' | 'description' | 'amount' | 'adultAmount' | 'childAmount' | 'currency'>\n          & { identifiers?: Maybe<(\n            { __typename?: 'IRLTicketExtraIdentifiers' }\n            & Pick<IrlTicketExtraIdentifiers, 'type' | 'location' | 'date' | 'journeyId' | 'isOrigin'>\n          )> }\n        )>>, plusBus?: Maybe<(\n          { __typename?: 'IRLPlusBus' }\n          & Pick<IrlPlusBus, 'originPlusBusNLC' | 'originStationNLC' | 'destinationPlusBusNLC' | 'destinationStationNLC'>\n        )> }\n      )>> }\n    )>, errors: Array<(\n      { __typename?: 'SearchError' }\n      & ErrorsFragment\n    )> }\n  ) }\n);\n\nexport type SearchIrlSupplierStationsQueryVariables = Exact<{\n  query: Scalars['String'];\n  supplier?: Maybe<IrlSupplier>;\n}>;\n\n\nexport type SearchIrlSupplierStationsQuery = (\n  { __typename?: 'Query' }\n  & { searchIRLSupplierStations: Array<(\n    { __typename?: 'IRLSupplierStation' }\n    & Pick<IrlSupplierStation, 'id' | 'name' | 'supplier' | 'stationCode' | 'nlcCode' | 'trainlineCode' | 'trainlineUniqueCode'>\n    & { locationDetails?: Maybe<(\n      { __typename?: 'LocationDetail' }\n      & Pick<LocationDetail, 'continent' | 'country' | 'countryCode' | 'state' | 'city' | 'postcode' | 'road' | 'gridReference' | 'northing' | 'easting'>\n      & { coordinates?: Maybe<(\n        { __typename?: 'GeoCoordinates' }\n        & Pick<GeoCoordinates, 'latitude' | 'longitude' | 'altitude'>\n      )> }\n    )> }\n  )> }\n);\n\nexport type SearchPostcodesQueryVariables = Exact<{\n  postcode: Scalars['String'];\n}>;\n\n\nexport type SearchPostcodesQuery = (\n  { __typename?: 'Query' }\n  & { getPostcodeDetails: (\n    { __typename?: 'PostcodeDetails' }\n    & Pick<PostcodeDetails, 'postcode' | 'latitude' | 'longitude'>\n  ) }\n);\n\nexport type SearchRailStationsQueryVariables = Exact<{\n  query: Scalars['String'];\n  countryCode?: Maybe<Scalars['String']>;\n}>;\n\n\nexport type SearchRailStationsQuery = (\n  { __typename?: 'Query' }\n  & { searchRailStations: Array<(\n    { __typename?: 'RailStation' }\n    & Pick<RailStation, 'id' | 'name' | 'stationCode' | 'nlcCode' | 'trainlineCode' | 'trainlineUniqueCode'>\n    & { locationDetails?: Maybe<(\n      { __typename?: 'LocationDetail' }\n      & Pick<LocationDetail, 'continent' | 'country' | 'countryCode' | 'state' | 'city' | 'postcode' | 'road' | 'gridReference' | 'northing' | 'easting'>\n      & { coordinates?: Maybe<(\n        { __typename?: 'GeoCoordinates' }\n        & Pick<GeoCoordinates, 'latitude' | 'longitude' | 'altitude'>\n      )> }\n    )> }\n  )> }\n);\n\nexport type SearchUserAddressQueryVariables = Exact<{ [key: string]: never; }>;\n\n\nexport type SearchUserAddressQuery = (\n  { __typename?: 'Query' }\n  & { getUserAddresses: Array<(\n    { __typename?: 'Address' }\n    & Pick<Address, 'id' | 'description' | 'numberOrName' | 'street' | 'town' | 'county' | 'postcode' | 'countryCode' | 'userPrimary' | 'officePrimary'>\n  )> }\n);\n\nexport type SetBasketItemMiGroupMutationVariables = Exact<{\n  basketItem: Scalars['ID'];\n  group?: Maybe<Scalars['String']>;\n  withSupplemental?: Maybe<Scalars['Boolean']>;\n}>;\n\n\nexport type SetBasketItemMiGroupMutation = (\n  { __typename?: 'Mutation' }\n  & { setBasketItemMIGroup: (\n    { __typename?: 'Basket' }\n    & BasketFieldsFragment\n  ) }\n);\n\nexport type SetBasketItemLeadPassengerMutationVariables = Exact<{\n  id: Scalars['ID'];\n  user: Scalars['ID'];\n  withSupplemental: Scalars['Boolean'];\n}>;\n\n\nexport type SetBasketItemLeadPassengerMutation = (\n  { __typename?: 'Mutation' }\n  & { setBasketItemLeadPassenger: (\n    { __typename?: 'Basket' }\n    & BasketFieldsFragment\n  ) }\n);\n\nexport type SetBasketItemMiValueMutationVariables = Exact<{\n  mi: Scalars['ID'];\n  miValue?: Maybe<Scalars['ID']>;\n  miFreeValue?: Maybe<Scalars['String']>;\n  user?: Maybe<Scalars['ID']>;\n  withSupplemental?: Maybe<Scalars['Boolean']>;\n}>;\n\n\nexport type SetBasketItemMiValueMutation = (\n  { __typename?: 'Mutation' }\n  & { setBasketItemMIValue: (\n    { __typename?: 'Basket' }\n    & BasketFieldsFragment\n  ) }\n);\n\nexport type SetBasketItemPaymentMethodMutationVariables = Exact<{\n  basketItem: Scalars['ID'];\n  paymentMethod: Scalars['ID'];\n  withSupplemental?: Maybe<Scalars['Boolean']>;\n}>;\n\n\nexport type SetBasketItemPaymentMethodMutation = (\n  { __typename?: 'Mutation' }\n  & { setBasketItemPaymentMethod: (\n    { __typename?: 'Basket' }\n    & BasketFieldsFragment\n  ) }\n);\n\nexport type UpdateBasketNotesMutationVariables = Exact<{\n  id?: Maybe<Scalars['ID']>;\n  reference?: Maybe<Scalars['String']>;\n  notes: Scalars['String'];\n  withSupplemental?: Maybe<Scalars['Boolean']>;\n}>;\n\n\nexport type UpdateBasketNotesMutation = (\n  { __typename?: 'Mutation' }\n  & { updateBasketNotes: (\n    { __typename?: 'Basket' }\n    & BasketFieldsFragment\n  ) }\n);\n\nexport type UpdateBasketTitleMutationVariables = Exact<{\n  id?: Maybe<Scalars['ID']>;\n  reference?: Maybe<Scalars['String']>;\n  newTitle: Scalars['String'];\n  withSupplemental?: Maybe<Scalars['Boolean']>;\n}>;\n\n\nexport type UpdateBasketTitleMutation = (\n  { __typename?: 'Mutation' }\n  & { updateBasketTitle: (\n    { __typename?: 'Basket' }\n    & BasketFieldsFragment\n  ) }\n);\n\nexport type UserFieldsFragment = (\n  { __typename?: 'User' }\n  & Pick<User, 'id' | 'title' | 'forename' | 'surname' | 'email' | 'username' | 'employeeId' | 'createdAt' | 'updatedAt' | 'dob' | 'admin' | 'tmcAdmin' | 'companyAdmin' | 'bookerType' | 'authMethods' | 'active' | 'passwordLastUpdated'>\n  & { selectedLanguage: (\n    { __typename?: 'Language' }\n    & Pick<Language, 'id' | 'name' | 'isoCode'>\n  ), availableLanguages: Array<(\n    { __typename?: 'Language' }\n    & Pick<Language, 'id' | 'name' | 'isoCode'>\n  )>, passports: Array<(\n    { __typename?: 'Passport' }\n    & Pick<Passport, 'id' | 'number' | 'codeOfIssuingState' | 'nationality' | 'sex' | 'dob' | 'surname' | 'givenNames' | 'dateOfIssue' | 'createdAt' | 'updatedAt'>\n  )>, addresses: Array<(\n    { __typename?: 'Address' }\n    & Pick<Address, 'id' | 'description' | 'numberOrName' | 'street' | 'town' | 'county' | 'postcode' | 'countryCode' | 'userPrimary' | 'officePrimary'>\n  )>, phoneNumbers: Array<(\n    { __typename?: 'PhoneNumber' }\n    & Pick<PhoneNumber, 'id' | 'description' | 'countryCode' | 'areaCode' | 'number' | 'extension' | 'type' | 'officePrimary' | 'userPrimary'>\n  )> }\n);\n\nexport type GetUserServicesQueryVariables = Exact<{ [key: string]: never; }>;\n\n\nexport type GetUserServicesQuery = (\n  { __typename?: 'Query' }\n  & { getUserServices: Array<(\n    { __typename?: 'Service' }\n    & Pick<Service, 'id' | 'cancellable' | 'amendable' | 'type' | 'name' | 'description' | 'detailSchema' | 'searchQuerySchema'>\n  )> }\n);\n\nexport type GetUserUiConfigsQueryVariables = Exact<{ [key: string]: never; }>;\n\n\nexport type GetUserUiConfigsQuery = (\n  { __typename?: 'Query' }\n  & { getUserUIConfigs: (\n    { __typename?: 'UIConfigCollection' }\n    & { all: Array<(\n      { __typename?: 'UIConfig' }\n      & Pick<UiConfig, 'id' | 'config' | 'key'>\n    )> }\n  ) }\n);\n\nexport type GetUserMessagesQueryVariables = Exact<{ [key: string]: never; }>;\n\n\nexport type GetUserMessagesQuery = (\n  { __typename?: 'Query' }\n  & { getUserMessages: Array<(\n    { __typename?: 'Message' }\n    & Pick<Message, 'id' | 'name' | 'description' | 'config' | 'target' | 'key'>\n  )> }\n);\n\nexport type GetUserPhoneNumbersQueryVariables = Exact<{ [key: string]: never; }>;\n\n\nexport type GetUserPhoneNumbersQuery = (\n  { __typename?: 'Query' }\n  & { getUserPhoneNumbers: Array<(\n    { __typename?: 'PhoneNumber' }\n    & Pick<PhoneNumber, 'id' | 'description' | 'countryCode' | 'areaCode' | 'number' | 'extension' | 'type' | 'officePrimary' | 'userPrimary'>\n  )> }\n);\n\nexport type SetUserLanguageMutationVariables = Exact<{\n  language?: Maybe<Scalars['ID']>;\n}>;\n\n\nexport type SetUserLanguageMutation = (\n  { __typename?: 'Mutation' }\n  & { setUserLanguage: (\n    { __typename?: 'User' }\n    & Pick<User, 'id'>\n    & { selectedLanguage: (\n      { __typename?: 'Language' }\n      & Pick<Language, 'id' | 'name'>\n    ) }\n  ) }\n);\n\nexport type GetUserQueryVariables = Exact<{\n  id?: Maybe<Scalars['ID']>;\n}>;\n\n\nexport type GetUserQuery = (\n  { __typename?: 'Query' }\n  & { getUser: (\n    { __typename?: 'User' }\n    & UserFieldsFragment\n  ) }\n);\n\nexport type SearchUserCanBookForQueryVariables = Exact<{\n  email?: Maybe<Scalars['String']>;\n  userName?: Maybe<Scalars['String']>;\n  employeeId?: Maybe<Scalars['String']>;\n}>;\n\n\nexport type SearchUserCanBookForQuery = (\n  { __typename?: 'Query' }\n  & { searchUserCanBookFor: Array<(\n    { __typename?: 'User' }\n    & Pick<User, 'id' | 'forename' | 'surname' | 'email'>\n  )> }\n);\n\nexport type ValidateUserMiFreeValueQueryVariables = Exact<{\n  mi: Scalars['ID'];\n  freeValue: Scalars['String'];\n}>;\n\n\nexport type ValidateUserMiFreeValueQuery = (\n  { __typename?: 'Query' }\n  & Pick<Query, 'validateUserMIFreeValue'>\n);\n\nexport namespace AcceptNewPrice {\n  export type Variables = AcceptNewPriceMutationVariables;\n  export type Mutation = AcceptNewPriceMutation;\n  export type AcceptNewPrice = AcceptNewPriceMutation['acceptNewPrice'];\n}\n\nexport namespace AddUsersToBasketItem {\n  export type Variables = AddUsersToBasketItemMutationVariables;\n  export type Mutation = AddUsersToBasketItemMutation;\n  export type AddUsersToBasketItem = AddUsersToBasketItemMutation['addUsersToBasketItem'];\n}\n\nexport namespace TravellerFields {\n  export type Fragment = TravellerFieldsFragment;\n}\n\nexport namespace OwnerFields {\n  export type Fragment = OwnerFieldsFragment;\n}\n\nexport namespace BasketFields {\n  export type Fragment = BasketFieldsFragment;\n  export type Owner = BasketFieldsFragment['owner'];\n  export type BasketItems = BasketFieldsFragment['basketItems'][number];\n  export type AvailablePaymentMethods = BasketFieldsFragment['basketItems'][number]['availablePaymentMethods'][number];\n  export type SelectedPaymentMethod = BasketFieldsFragment['basketItems'][number]['selectedPaymentMethod'];\n  export type Service = BasketFieldsFragment['basketItems'][number]['service'];\n  export type Users = BasketFieldsFragment['basketItems'][number]['users'][number];\n  export type UserPassengerTypes = BasketFieldsFragment['basketItems'][number]['userPassengerTypes'][number];\n  export type LeadPassenger = BasketFieldsFragment['basketItems'][number]['leadPassenger'];\n  export type ManagementInfo = BasketFieldsFragment['basketItems'][number]['managementInfo'][number];\n  export type FixedValue = BasketFieldsFragment['basketItems'][number]['managementInfo'][number]['fixedValue'];\n  export type DefaultValue = BasketFieldsFragment['basketItems'][number]['managementInfo'][number]['defaultValue'];\n  export type Values = BasketFieldsFragment['basketItems'][number]['managementInfo'][number]['values'][number];\n  export type SelectedValues = BasketFieldsFragment['basketItems'][number]['managementInfo'][number]['selectedValues'][number];\n  export type Value = BasketFieldsFragment['basketItems'][number]['managementInfo'][number]['selectedValues'][number]['value'];\n  export type User = BasketFieldsFragment['basketItems'][number]['managementInfo'][number]['selectedValues'][number]['user'];\n  export type CompanyGroup = BasketFieldsFragment['companyGroup'];\n}\n\nexport namespace GetUserBaskets {\n  export type Variables = GetUserBasketsQueryVariables;\n  export type Query = GetUserBasketsQuery;\n  export type GetUserBaskets = GetUserBasketsQuery['getUserBaskets'][number];\n}\n\nexport namespace DeleteBasket {\n  export type Variables = DeleteBasketMutationVariables;\n  export type Mutation = DeleteBasketMutation;\n}\n\nexport namespace CreateBasket {\n  export type Variables = CreateBasketMutationVariables;\n  export type Mutation = CreateBasketMutation;\n  export type CreateBasket = CreateBasketMutation['createBasket'];\n}\n\nexport namespace RemoveItemFromBasket {\n  export type Variables = RemoveItemFromBasketMutationVariables;\n  export type Mutation = RemoveItemFromBasketMutation;\n  export type RemoveItemFromBasket = RemoveItemFromBasketMutation['removeItemFromBasket'];\n}\n\nexport namespace SendBasketForApproval {\n  export type Variables = SendBasketForApprovalMutationVariables;\n  export type Mutation = SendBasketForApprovalMutation;\n  export type SendBasketForApproval = SendBasketForApprovalMutation['sendBasketForApproval'];\n}\n\nexport namespace AddItemToBasket {\n  export type Variables = AddItemToBasketMutationVariables;\n  export type Mutation = AddItemToBasketMutation;\n  export type AddItemToBasket = AddItemToBasketMutation['addItemToBasket'];\n}\n\nexport namespace GetUserBasket {\n  export type Variables = GetUserBasketQueryVariables;\n  export type Query = GetUserBasketQuery;\n  export type GetUserBasket = GetUserBasketQuery['getUserBasket'];\n}\n\nexport namespace RevalidateBasket {\n  export type Variables = RevalidateBasketMutationVariables;\n  export type Mutation = RevalidateBasketMutation;\n  export type RevalidateBasket = RevalidateBasketMutation['revalidateBasket'];\n}\n\nexport namespace BookBasket {\n  export type Variables = BookBasketMutationVariables;\n  export type Mutation = BookBasketMutation;\n  export type BookBasket = BookBasketMutation['bookBasket'];\n}\n\nexport namespace SearchCabHire {\n  export type Variables = SearchCabHireQueryVariables;\n  export type Query = SearchCabHireQuery;\n  export type SearchCabHire = SearchCabHireQuery['searchCabHire'];\n  export type Results = SearchCabHireQuery['searchCabHire']['results'][number];\n  export type FromLocation = SearchCabHireQuery['searchCabHire']['results'][number]['fromLocation'];\n  export type ToLocation = SearchCabHireQuery['searchCabHire']['results'][number]['toLocation'];\n  export type Vias = SearchCabHireQuery['searchCabHire']['results'][number]['vias'][number];\n  export type Errors = SearchCabHireQuery['searchCabHire']['errors'][number];\n}\n\nexport namespace CarHireAvailabilityDetailRequest {\n  export type Variables = CarHireAvailabilityDetailRequestQueryVariables;\n  export type Query = CarHireAvailabilityDetailRequestQuery;\n  export type CarHireAvailabilityDetailRequest = CarHireAvailabilityDetailRequestQuery['carHireAvailabilityDetailRequest'];\n  export type Identifiers = CarHireAvailabilityDetailRequestQuery['carHireAvailabilityDetailRequest']['identifiers'];\n  export type Vendor = CarHireAvailabilityDetailRequestQuery['carHireAvailabilityDetailRequest']['vendor'];\n  export type Address = CarHireAvailabilityDetailRequestQuery['carHireAvailabilityDetailRequest']['address'];\n  export type AdditionalInfo = CarHireAvailabilityDetailRequestQuery['carHireAvailabilityDetailRequest']['additionalInfo'][number];\n  export type Custom = CarHireAvailabilityDetailRequestQuery['carHireAvailabilityDetailRequest']['additionalInfo'][number]['custom'][number];\n}\n\nexport namespace SearchCarHire {\n  export type Variables = SearchCarHireQueryVariables;\n  export type Query = SearchCarHireQuery;\n  export type SearchCarHire = SearchCarHireQuery['searchCarHire'];\n  export type Results = SearchCarHireQuery['searchCarHire']['results'][number];\n  export type Identifiers = SearchCarHireQuery['searchCarHire']['results'][number]['identifiers'];\n  export type DisplayRecord = SearchCarHireQuery['searchCarHire']['results'][number]['displayRecord'];\n  export type Vendor = SearchCarHireQuery['searchCarHire']['results'][number]['displayRecord']['vendor'];\n  export type Vehicle = SearchCarHireQuery['searchCarHire']['results'][number]['displayRecord']['vehicle'];\n  export type Charges = SearchCarHireQuery['searchCarHire']['results'][number]['displayRecord']['charges'][number];\n  export type PickupLocation = SearchCarHireQuery['searchCarHire']['results'][number]['displayRecord']['pickupLocation'];\n  export type ReturnLocation = SearchCarHireQuery['searchCarHire']['results'][number]['displayRecord']['returnLocation'];\n  export type AdditionalInfo = SearchCarHireQuery['searchCarHire']['results'][number]['displayRecord']['additionalInfo'][number];\n  export type Custom = SearchCarHireQuery['searchCarHire']['results'][number]['displayRecord']['additionalInfo'][number]['custom'][number];\n  export type Errors = SearchCarHireQuery['searchCarHire']['errors'][number];\n}\n\nexport namespace DeleteRecentSearch {\n  export type Variables = DeleteRecentSearchMutationVariables;\n  export type Mutation = DeleteRecentSearchMutation;\n}\n\nexport namespace DeleteUserAddress {\n  export type Variables = DeleteUserAddressMutationVariables;\n  export type Mutation = DeleteUserAddressMutation;\n}\n\nexport namespace Errors {\n  export type Fragment = ErrorsFragment;\n  export type Service = ErrorsFragment['service'];\n}\n\nexport namespace GroupedFields {\n  export type Fragment = GroupedFieldsFragment;\n  export type Flights = GroupedFieldsFragment['flights'];\n}\n\nexport namespace SearchFlightsV2 {\n  export type Variables = SearchFlightsV2QueryVariables;\n  export type Query = SearchFlightsV2Query;\n  export type SearchFlightsV2 = SearchFlightsV2Query['searchFlightsV2'];\n  export type Results = SearchFlightsV2Query['searchFlightsV2']['results'];\n  export type Journeys = SearchFlightsV2Query['searchFlightsV2']['results']['journeys'][number];\n  export type OutboundFlights = SearchFlightsV2Query['searchFlightsV2']['results']['journeys'][number]['outboundFlights'][number];\n  export type OriginAirportDetail = SearchFlightsV2Query['searchFlightsV2']['results']['journeys'][number]['outboundFlights'][number]['originAirportDetail'];\n  export type DestinationAirportDetail = SearchFlightsV2Query['searchFlightsV2']['results']['journeys'][number]['outboundFlights'][number]['destinationAirportDetail'];\n  export type MarketingCarrierDetail = SearchFlightsV2Query['searchFlightsV2']['results']['journeys'][number]['outboundFlights'][number]['marketingCarrierDetail'];\n  export type OperatingCarrierDetail = SearchFlightsV2Query['searchFlightsV2']['results']['journeys'][number]['outboundFlights'][number]['operatingCarrierDetail'];\n  export type FareConditions = SearchFlightsV2Query['searchFlightsV2']['results']['journeys'][number]['outboundFlights'][number]['fareConditions'];\n  export type Cancellation = SearchFlightsV2Query['searchFlightsV2']['results']['journeys'][number]['outboundFlights'][number]['fareConditions']['cancellation'][number];\n  export type Change = SearchFlightsV2Query['searchFlightsV2']['results']['journeys'][number]['outboundFlights'][number]['fareConditions']['change'][number];\n  export type NoShow = SearchFlightsV2Query['searchFlightsV2']['results']['journeys'][number]['outboundFlights'][number]['fareConditions']['noShow'][number];\n  export type Upgrade = SearchFlightsV2Query['searchFlightsV2']['results']['journeys'][number]['outboundFlights'][number]['fareConditions']['upgrade'][number];\n  export type Other = SearchFlightsV2Query['searchFlightsV2']['results']['journeys'][number]['outboundFlights'][number]['fareConditions']['other'][number];\n  export type InboundFlights = SearchFlightsV2Query['searchFlightsV2']['results']['journeys'][number]['inboundFlights'][number];\n  export type _OriginAirportDetail = SearchFlightsV2Query['searchFlightsV2']['results']['journeys'][number]['inboundFlights'][number]['originAirportDetail'];\n  export type _DestinationAirportDetail = SearchFlightsV2Query['searchFlightsV2']['results']['journeys'][number]['inboundFlights'][number]['destinationAirportDetail'];\n  export type _MarketingCarrierDetail = SearchFlightsV2Query['searchFlightsV2']['results']['journeys'][number]['inboundFlights'][number]['marketingCarrierDetail'];\n  export type _OperatingCarrierDetail = SearchFlightsV2Query['searchFlightsV2']['results']['journeys'][number]['inboundFlights'][number]['operatingCarrierDetail'];\n  export type _FareConditions = SearchFlightsV2Query['searchFlightsV2']['results']['journeys'][number]['inboundFlights'][number]['fareConditions'];\n  export type _Cancellation = SearchFlightsV2Query['searchFlightsV2']['results']['journeys'][number]['inboundFlights'][number]['fareConditions']['cancellation'][number];\n  export type _Change = SearchFlightsV2Query['searchFlightsV2']['results']['journeys'][number]['inboundFlights'][number]['fareConditions']['change'][number];\n  export type _NoShow = SearchFlightsV2Query['searchFlightsV2']['results']['journeys'][number]['inboundFlights'][number]['fareConditions']['noShow'][number];\n  export type _Upgrade = SearchFlightsV2Query['searchFlightsV2']['results']['journeys'][number]['inboundFlights'][number]['fareConditions']['upgrade'][number];\n  export type _Other = SearchFlightsV2Query['searchFlightsV2']['results']['journeys'][number]['inboundFlights'][number]['fareConditions']['other'][number];\n  export type OutboundCarbonEmissions = SearchFlightsV2Query['searchFlightsV2']['results']['journeys'][number]['outboundCarbonEmissions'];\n  export type InboundCarbonEmissions = SearchFlightsV2Query['searchFlightsV2']['results']['journeys'][number]['inboundCarbonEmissions'];\n  export type Taxes = SearchFlightsV2Query['searchFlightsV2']['results']['journeys'][number]['taxes'][number];\n  export type Discounts = SearchFlightsV2Query['searchFlightsV2']['results']['journeys'][number]['discounts'][number];\n  export type Total = SearchFlightsV2Query['searchFlightsV2']['results']['journeys'][number]['total'];\n  export type __FareConditions = SearchFlightsV2Query['searchFlightsV2']['results']['journeys'][number]['fareConditions'];\n  export type __Cancellation = SearchFlightsV2Query['searchFlightsV2']['results']['journeys'][number]['fareConditions']['cancellation'][number];\n  export type __Change = SearchFlightsV2Query['searchFlightsV2']['results']['journeys'][number]['fareConditions']['change'][number];\n  export type __NoShow = SearchFlightsV2Query['searchFlightsV2']['results']['journeys'][number]['fareConditions']['noShow'][number];\n  export type __Upgrade = SearchFlightsV2Query['searchFlightsV2']['results']['journeys'][number]['fareConditions']['upgrade'][number];\n  export type __Other = SearchFlightsV2Query['searchFlightsV2']['results']['journeys'][number]['fareConditions']['other'][number];\n  export type BaggageAllowance = SearchFlightsV2Query['searchFlightsV2']['results']['journeys'][number]['baggageAllowance'][number];\n  export type Multi = SearchFlightsV2Query['searchFlightsV2']['results']['multi'][number];\n  export type _Results = SearchFlightsV2Query['searchFlightsV2']['results']['multi'][number]['results'][number];\n  export type _OutboundFlights = SearchFlightsV2Query['searchFlightsV2']['results']['multi'][number]['results'][number]['outboundFlights'][number];\n  export type __OriginAirportDetail = SearchFlightsV2Query['searchFlightsV2']['results']['multi'][number]['results'][number]['outboundFlights'][number]['originAirportDetail'];\n  export type __DestinationAirportDetail = SearchFlightsV2Query['searchFlightsV2']['results']['multi'][number]['results'][number]['outboundFlights'][number]['destinationAirportDetail'];\n  export type __MarketingCarrierDetail = SearchFlightsV2Query['searchFlightsV2']['results']['multi'][number]['results'][number]['outboundFlights'][number]['marketingCarrierDetail'];\n  export type __OperatingCarrierDetail = SearchFlightsV2Query['searchFlightsV2']['results']['multi'][number]['results'][number]['outboundFlights'][number]['operatingCarrierDetail'];\n  export type ___FareConditions = SearchFlightsV2Query['searchFlightsV2']['results']['multi'][number]['results'][number]['outboundFlights'][number]['fareConditions'];\n  export type ___Cancellation = SearchFlightsV2Query['searchFlightsV2']['results']['multi'][number]['results'][number]['outboundFlights'][number]['fareConditions']['cancellation'][number];\n  export type ___Change = SearchFlightsV2Query['searchFlightsV2']['results']['multi'][number]['results'][number]['outboundFlights'][number]['fareConditions']['change'][number];\n  export type ___NoShow = SearchFlightsV2Query['searchFlightsV2']['results']['multi'][number]['results'][number]['outboundFlights'][number]['fareConditions']['noShow'][number];\n  export type ___Upgrade = SearchFlightsV2Query['searchFlightsV2']['results']['multi'][number]['results'][number]['outboundFlights'][number]['fareConditions']['upgrade'][number];\n  export type ___Other = SearchFlightsV2Query['searchFlightsV2']['results']['multi'][number]['results'][number]['outboundFlights'][number]['fareConditions']['other'][number];\n  export type _InboundFlights = SearchFlightsV2Query['searchFlightsV2']['results']['multi'][number]['results'][number]['inboundFlights'][number];\n  export type ___OriginAirportDetail = SearchFlightsV2Query['searchFlightsV2']['results']['multi'][number]['results'][number]['inboundFlights'][number]['originAirportDetail'];\n  export type ___DestinationAirportDetail = SearchFlightsV2Query['searchFlightsV2']['results']['multi'][number]['results'][number]['inboundFlights'][number]['destinationAirportDetail'];\n  export type ___MarketingCarrierDetail = SearchFlightsV2Query['searchFlightsV2']['results']['multi'][number]['results'][number]['inboundFlights'][number]['marketingCarrierDetail'];\n  export type ___OperatingCarrierDetail = SearchFlightsV2Query['searchFlightsV2']['results']['multi'][number]['results'][number]['inboundFlights'][number]['operatingCarrierDetail'];\n  export type ____FareConditions = SearchFlightsV2Query['searchFlightsV2']['results']['multi'][number]['results'][number]['inboundFlights'][number]['fareConditions'];\n  export type ____Cancellation = SearchFlightsV2Query['searchFlightsV2']['results']['multi'][number]['results'][number]['inboundFlights'][number]['fareConditions']['cancellation'][number];\n  export type ____Change = SearchFlightsV2Query['searchFlightsV2']['results']['multi'][number]['results'][number]['inboundFlights'][number]['fareConditions']['change'][number];\n  export type ____NoShow = SearchFlightsV2Query['searchFlightsV2']['results']['multi'][number]['results'][number]['inboundFlights'][number]['fareConditions']['noShow'][number];\n  export type ____Upgrade = SearchFlightsV2Query['searchFlightsV2']['results']['multi'][number]['results'][number]['inboundFlights'][number]['fareConditions']['upgrade'][number];\n  export type ____Other = SearchFlightsV2Query['searchFlightsV2']['results']['multi'][number]['results'][number]['inboundFlights'][number]['fareConditions']['other'][number];\n  export type _OutboundCarbonEmissions = SearchFlightsV2Query['searchFlightsV2']['results']['multi'][number]['results'][number]['outboundCarbonEmissions'];\n  export type _InboundCarbonEmissions = SearchFlightsV2Query['searchFlightsV2']['results']['multi'][number]['results'][number]['inboundCarbonEmissions'];\n  export type _Taxes = SearchFlightsV2Query['searchFlightsV2']['results']['multi'][number]['results'][number]['taxes'][number];\n  export type _Discounts = SearchFlightsV2Query['searchFlightsV2']['results']['multi'][number]['results'][number]['discounts'][number];\n  export type _Total = SearchFlightsV2Query['searchFlightsV2']['results']['multi'][number]['results'][number]['total'];\n  export type _____FareConditions = SearchFlightsV2Query['searchFlightsV2']['results']['multi'][number]['results'][number]['fareConditions'];\n  export type _____Cancellation = SearchFlightsV2Query['searchFlightsV2']['results']['multi'][number]['results'][number]['fareConditions']['cancellation'][number];\n  export type _____Change = SearchFlightsV2Query['searchFlightsV2']['results']['multi'][number]['results'][number]['fareConditions']['change'][number];\n  export type _____NoShow = SearchFlightsV2Query['searchFlightsV2']['results']['multi'][number]['results'][number]['fareConditions']['noShow'][number];\n  export type _____Upgrade = SearchFlightsV2Query['searchFlightsV2']['results']['multi'][number]['results'][number]['fareConditions']['upgrade'][number];\n  export type _____Other = SearchFlightsV2Query['searchFlightsV2']['results']['multi'][number]['results'][number]['fareConditions']['other'][number];\n  export type _BaggageAllowance = SearchFlightsV2Query['searchFlightsV2']['results']['multi'][number]['results'][number]['baggageAllowance'][number];\n  export type Grouped = SearchFlightsV2Query['searchFlightsV2']['results']['grouped'][number];\n  export type Errors = SearchFlightsV2Query['searchFlightsV2']['errors'][number];\n}\n\nexport namespace GetCarHireDepots {\n  export type Variables = GetCarHireDepotsQueryVariables;\n  export type Query = GetCarHireDepotsQuery;\n  export type GetCarHireDepots = GetCarHireDepotsQuery['getCarHireDepots'][number];\n}\n\nexport namespace GetConfermaOffice {\n  export type Variables = GetConfermaOfficeQueryVariables;\n  export type Query = GetConfermaOfficeQuery;\n  export type GetConfermaOffice = GetConfermaOfficeQuery['getConfermaOffice'];\n  export type Results = GetConfermaOfficeQuery['getConfermaOffice']['results'];\n  export type Address = GetConfermaOfficeQuery['getConfermaOffice']['results']['address'];\n  export type ClosestHotels = GetConfermaOfficeQuery['getConfermaOffice']['results']['closestHotels'][number];\n  export type Errors = GetConfermaOfficeQuery['getConfermaOffice']['errors'][number];\n  export type Service = GetConfermaOfficeQuery['getConfermaOffice']['errors'][number]['service'];\n}\n\nexport namespace GetConfermaOfficeNames {\n  export type Variables = GetConfermaOfficeNamesQueryVariables;\n  export type Query = GetConfermaOfficeNamesQuery;\n  export type GetConfermaOfficeNames = GetConfermaOfficeNamesQuery['getConfermaOfficeNames'];\n  export type Results = GetConfermaOfficeNamesQuery['getConfermaOfficeNames']['results'][number];\n  export type Errors = GetConfermaOfficeNamesQuery['getConfermaOfficeNames']['errors'][number];\n}\n\nexport namespace GetConfermaQuicklist {\n  export type Variables = GetConfermaQuicklistQueryVariables;\n  export type Query = GetConfermaQuicklistQuery;\n  export type GetConfermaQuicklist = GetConfermaQuicklistQuery['getConfermaQuicklist'];\n  export type Results = GetConfermaQuicklistQuery['getConfermaQuicklist']['results'][number];\n  export type Location = GetConfermaQuicklistQuery['getConfermaQuicklist']['results'][number]['location'];\n  export type Address = GetConfermaQuicklistQuery['getConfermaQuicklist']['results'][number]['address'];\n  export type Transports = GetConfermaQuicklistQuery['getConfermaQuicklist']['results'][number]['transports'][number];\n  export type Preferred = GetConfermaQuicklistQuery['getConfermaQuicklist']['results'][number]['preferred'];\n  export type Tags = GetConfermaQuicklistQuery['getConfermaQuicklist']['results'][number]['tags'][number];\n  export type AvailableRates = GetConfermaQuicklistQuery['getConfermaQuicklist']['results'][number]['availableRates'];\n  export type Rooms = GetConfermaQuicklistQuery['getConfermaQuicklist']['results'][number]['availableRates']['rooms'][number];\n  export type CurrencyConversion = GetConfermaQuicklistQuery['getConfermaQuicklist']['results'][number]['availableRates']['rooms'][number]['currencyConversion'];\n  export type Deposit = GetConfermaQuicklistQuery['getConfermaQuicklist']['results'][number]['availableRates']['rooms'][number]['deposit'];\n  export type Nights = GetConfermaQuicklistQuery['getConfermaQuicklist']['results'][number]['availableRates']['rooms'][number]['nights'][number];\n  export type Policies = GetConfermaQuicklistQuery['getConfermaQuicklist']['results'][number]['availableRates']['rooms'][number]['policies'];\n  export type Tax = GetConfermaQuicklistQuery['getConfermaQuicklist']['results'][number]['availableRates']['rooms'][number]['tax'];\n  export type AcceptedCards = GetConfermaQuicklistQuery['getConfermaQuicklist']['results'][number]['availableRates']['rooms'][number]['acceptedCards'][number];\n  export type PaymentTypes = GetConfermaQuicklistQuery['getConfermaQuicklist']['results'][number]['availableRates']['rooms'][number]['paymentTypes'][number];\n  export type Errors = GetConfermaQuicklistQuery['getConfermaQuicklist']['errors'][number];\n}\n\nexport namespace GetIrlSupplierStation {\n  export type Variables = GetIrlSupplierStationQueryVariables;\n  export type Query = GetIrlSupplierStationQuery;\n  export type GetIrlSupplierStation = GetIrlSupplierStationQuery['getIRLSupplierStation'];\n  export type LocationDetails = GetIrlSupplierStationQuery['getIRLSupplierStation']['locationDetails'];\n  export type Coordinates = GetIrlSupplierStationQuery['getIRLSupplierStation']['locationDetails']['coordinates'];\n}\n\nexport namespace GetRailStation {\n  export type Variables = GetRailStationQueryVariables;\n  export type Query = GetRailStationQuery;\n  export type GetRailStation = GetRailStationQuery['getRailStation'];\n  export type LocationDetails = GetRailStationQuery['getRailStation']['locationDetails'];\n  export type Coordinates = GetRailStationQuery['getRailStation']['locationDetails']['coordinates'];\n}\n\nexport namespace GetRailcards {\n  export type Variables = GetRailcardsQueryVariables;\n  export type Query = GetRailcardsQuery;\n  export type GetRailcards = GetRailcardsQuery['getRailcards'][number];\n}\n\nexport namespace GetRiskAlerts {\n  export type Variables = GetRiskAlertsQueryVariables;\n  export type Query = GetRiskAlertsQuery;\n  export type GetRiskAlerts = GetRiskAlertsQuery['getRiskAlerts'][number];\n}\n\nexport namespace GetUserAddresses {\n  export type Variables = GetUserAddressesQueryVariables;\n  export type Query = GetUserAddressesQuery;\n  export type GetUserAddresses = GetUserAddressesQuery['getUserAddresses'][number];\n}\n\nexport namespace GetUserCompanyOffices {\n  export type Variables = GetUserCompanyOfficesQueryVariables;\n  export type Query = GetUserCompanyOfficesQuery;\n  export type GetUserCompanyOffices = GetUserCompanyOfficesQuery['getUserCompanyOffices'][number];\n  export type Addresses = GetUserCompanyOfficesQuery['getUserCompanyOffices'][number]['addresses'][number];\n}\n\nexport namespace GetUserCurrentCarbonAllowance {\n  export type Variables = GetUserCurrentCarbonAllowanceQueryVariables;\n  export type Query = GetUserCurrentCarbonAllowanceQuery;\n  export type GetUserCurrentCarbonAllowance = GetUserCurrentCarbonAllowanceQuery['getUserCurrentCarbonAllowance'];\n  export type Company = GetUserCurrentCarbonAllowanceQuery['getUserCurrentCarbonAllowance']['company'];\n  export type Office = GetUserCurrentCarbonAllowanceQuery['getUserCurrentCarbonAllowance']['office'];\n  export type User = GetUserCurrentCarbonAllowanceQuery['getUserCurrentCarbonAllowance']['user'];\n  export type PeriodConsumption = GetUserCurrentCarbonAllowanceQuery['getUserCurrentCarbonAllowance']['periodConsumption'][number];\n}\n\nexport namespace GetUserMiAutoSuggestValues {\n  export type Variables = GetUserMiAutoSuggestValuesQueryVariables;\n  export type Query = GetUserMiAutoSuggestValuesQuery;\n  export type GetUserMiAutoSuggestValues = GetUserMiAutoSuggestValuesQuery['getUserMIAutoSuggestValues'][number];\n}\n\nexport namespace GetUserPhone {\n  export type Variables = GetUserPhoneQueryVariables;\n  export type Query = GetUserPhoneQuery;\n  export type GetUserPhoneNumbers = GetUserPhoneQuery['getUserPhoneNumbers'][number];\n}\n\nexport namespace GetUserRecentSearches {\n  export type Variables = GetUserRecentSearchesQueryVariables;\n  export type Query = GetUserRecentSearchesQuery;\n  export type GetUserRecentSearches = GetUserRecentSearchesQuery['getUserRecentSearches'][number];\n  export type Travellers = GetUserRecentSearchesQuery['getUserRecentSearches'][number]['travellers'][number];\n}\n\nexport namespace SearchHotels {\n  export type Variables = SearchHotelsQueryVariables;\n  export type Query = SearchHotelsQuery;\n  export type SearchHotels = SearchHotelsQuery['searchHotels'];\n  export type Results = SearchHotelsQuery['searchHotels']['results'][number];\n  export type Location = SearchHotelsQuery['searchHotels']['results'][number]['location'];\n  export type Address = SearchHotelsQuery['searchHotels']['results'][number]['address'];\n  export type Transports = SearchHotelsQuery['searchHotels']['results'][number]['transports'][number];\n  export type Preferred = SearchHotelsQuery['searchHotels']['results'][number]['preferred'];\n  export type Tags = SearchHotelsQuery['searchHotels']['results'][number]['tags'][number];\n  export type AvailableRates = SearchHotelsQuery['searchHotels']['results'][number]['availableRates'];\n  export type Rooms = SearchHotelsQuery['searchHotels']['results'][number]['availableRates']['rooms'][number];\n  export type CurrencyConversion = SearchHotelsQuery['searchHotels']['results'][number]['availableRates']['rooms'][number]['currencyConversion'];\n  export type Deposit = SearchHotelsQuery['searchHotels']['results'][number]['availableRates']['rooms'][number]['deposit'];\n  export type Nights = SearchHotelsQuery['searchHotels']['results'][number]['availableRates']['rooms'][number]['nights'][number];\n  export type Policies = SearchHotelsQuery['searchHotels']['results'][number]['availableRates']['rooms'][number]['policies'];\n  export type Tax = SearchHotelsQuery['searchHotels']['results'][number]['availableRates']['rooms'][number]['tax'];\n  export type AcceptedCards = SearchHotelsQuery['searchHotels']['results'][number]['availableRates']['rooms'][number]['acceptedCards'][number];\n  export type PaymentTypes = SearchHotelsQuery['searchHotels']['results'][number]['availableRates']['rooms'][number]['paymentTypes'][number];\n  export type Errors = SearchHotelsQuery['searchHotels']['errors'][number];\n  export type Service = SearchHotelsQuery['searchHotels']['errors'][number]['service'];\n}\n\nexport namespace GetMultipleHotelsAvailability {\n  export type Variables = GetMultipleHotelsAvailabilityQueryVariables;\n  export type Query = GetMultipleHotelsAvailabilityQuery;\n  export type GetMultipleHotelsAvailability = GetMultipleHotelsAvailabilityQuery['getMultipleHotelsAvailability'];\n  export type Results = GetMultipleHotelsAvailabilityQuery['getMultipleHotelsAvailability']['results'][number];\n  export type Rooms = GetMultipleHotelsAvailabilityQuery['getMultipleHotelsAvailability']['results'][number]['rooms'][number];\n  export type CurrencyConversion = GetMultipleHotelsAvailabilityQuery['getMultipleHotelsAvailability']['results'][number]['rooms'][number]['currencyConversion'];\n  export type Deposit = GetMultipleHotelsAvailabilityQuery['getMultipleHotelsAvailability']['results'][number]['rooms'][number]['deposit'];\n  export type Nights = GetMultipleHotelsAvailabilityQuery['getMultipleHotelsAvailability']['results'][number]['rooms'][number]['nights'][number];\n  export type Policies = GetMultipleHotelsAvailabilityQuery['getMultipleHotelsAvailability']['results'][number]['rooms'][number]['policies'];\n  export type Tax = GetMultipleHotelsAvailabilityQuery['getMultipleHotelsAvailability']['results'][number]['rooms'][number]['tax'];\n  export type AcceptedCards = GetMultipleHotelsAvailabilityQuery['getMultipleHotelsAvailability']['results'][number]['rooms'][number]['acceptedCards'][number];\n  export type PaymentTypes = GetMultipleHotelsAvailabilityQuery['getMultipleHotelsAvailability']['results'][number]['rooms'][number]['paymentTypes'][number];\n  export type Errors = GetMultipleHotelsAvailabilityQuery['getMultipleHotelsAvailability']['errors'][number];\n}\n\nexport namespace IsPostcodeValid {\n  export type Variables = IsPostcodeValidQueryVariables;\n  export type Query = IsPostcodeValidQuery;\n}\n\nexport namespace Location_Detail {\n  export type Fragment = Location_DetailFragment;\n  export type Coordinates = Location_DetailFragment['coordinates'];\n}\n\nexport namespace SearchAirports {\n  export type Variables = SearchAirportsQueryVariables;\n  export type Query = SearchAirportsQuery;\n  export type SearchAirports = SearchAirportsQuery['searchAirports'];\n  export type IataMatch = SearchAirportsQuery['searchAirports']['iataMatch'];\n  export type LocationDetails = SearchAirportsQuery['searchAirports']['iataMatch']['locationDetails'];\n  export type GeneralMatches = SearchAirportsQuery['searchAirports']['generalMatches'][number];\n  export type _LocationDetails = SearchAirportsQuery['searchAirports']['generalMatches'][number]['locationDetails'];\n}\n\nexport namespace SearchLounges {\n  export type Variables = SearchLoungesQueryVariables;\n  export type Query = SearchLoungesQuery;\n  export type SearchLounges = SearchLoungesQuery['searchLounges'];\n  export type Results = SearchLoungesQuery['searchLounges']['results'][number];\n  export type Lounge = SearchLoungesQuery['searchLounges']['results'][number]['lounge'];\n  export type Errors = SearchLoungesQuery['searchLounges']['errors'][number];\n}\n\nexport namespace MoveItemToADifferentBasket {\n  export type Variables = MoveItemToADifferentBasketMutationVariables;\n  export type Mutation = MoveItemToADifferentBasketMutation;\n  export type MoveItemToADifferentBasket = MoveItemToADifferentBasketMutation['moveItemToADifferentBasket'];\n}\n\nexport namespace SearchParking {\n  export type Variables = SearchParkingQueryVariables;\n  export type Query = SearchParkingQuery;\n  export type SearchParking = SearchParkingQuery['searchParking'];\n  export type Results = SearchParkingQuery['searchParking']['results'][number];\n  export type CarPark = SearchParkingQuery['searchParking']['results'][number]['carPark'];\n  export type Errors = SearchParkingQuery['searchParking']['errors'][number];\n}\n\nexport namespace SearchRail {\n  export type Variables = SearchRailQueryVariables;\n  export type Query = SearchRailQuery;\n  export type SearchRail = SearchRailQuery['searchRail'];\n  export type Results = SearchRailQuery['searchRail']['results'][number];\n  export type Outbound = SearchRailQuery['searchRail']['results'][number]['outbound'][number];\n  export type Identifiers = SearchRailQuery['searchRail']['results'][number]['outbound'][number]['identifiers'];\n  export type Travellers = SearchRailQuery['searchRail']['results'][number]['outbound'][number]['travellers'][number];\n  export type Segments = SearchRailQuery['searchRail']['results'][number]['outbound'][number]['segments'][number];\n  export type SeatPreferenceTypes = SearchRailQuery['searchRail']['results'][number]['outbound'][number]['segments'][number]['seatPreferenceTypes'][number];\n  export type Seats = SearchRailQuery['searchRail']['results'][number]['outbound'][number]['segments'][number]['seats'][number];\n  export type CallingPoints = SearchRailQuery['searchRail']['results'][number]['outbound'][number]['segments'][number]['callingPoints'][number];\n  export type Providers = SearchRailQuery['searchRail']['results'][number]['outbound'][number]['providers'][number];\n  export type CheapestTicket = SearchRailQuery['searchRail']['results'][number]['outbound'][number]['providers'][number]['cheapestTicket'];\n  export type _Identifiers = SearchRailQuery['searchRail']['results'][number]['outbound'][number]['providers'][number]['cheapestTicket']['identifiers'];\n  export type Terms = SearchRailQuery['searchRail']['results'][number]['outbound'][number]['providers'][number]['cheapestTicket']['terms'];\n  export type DynamicConditions = SearchRailQuery['searchRail']['results'][number]['outbound'][number]['providers'][number]['cheapestTicket']['terms']['dynamicConditions'][number];\n  export type Tickets = SearchRailQuery['searchRail']['results'][number]['outbound'][number]['providers'][number]['cheapestTicket']['tickets'][number];\n  export type _Segments = SearchRailQuery['searchRail']['results'][number]['outbound'][number]['providers'][number]['cheapestTicket']['tickets'][number]['segments'][number];\n  export type TicketQueueList = SearchRailQuery['searchRail']['results'][number]['outbound'][number]['providers'][number]['cheapestTicket']['ticketQueueList'][number];\n  export type AccountsList = SearchRailQuery['searchRail']['results'][number]['outbound'][number]['providers'][number]['cheapestTicket']['accountsList'][number];\n  export type TicketOptions = SearchRailQuery['searchRail']['results'][number]['outbound'][number]['providers'][number]['ticketOptions'][number];\n  export type __Identifiers = SearchRailQuery['searchRail']['results'][number]['outbound'][number]['providers'][number]['ticketOptions'][number]['identifiers'];\n  export type AllowedWith = SearchRailQuery['searchRail']['results'][number]['outbound'][number]['providers'][number]['ticketOptions'][number]['identifiers']['allowedWith'][number];\n  export type _Terms = SearchRailQuery['searchRail']['results'][number]['outbound'][number]['providers'][number]['ticketOptions'][number]['terms'];\n  export type _Tickets = SearchRailQuery['searchRail']['results'][number]['outbound'][number]['providers'][number]['ticketOptions'][number]['tickets'][number];\n  export type _TicketQueueList = SearchRailQuery['searchRail']['results'][number]['outbound'][number]['providers'][number]['ticketOptions'][number]['ticketQueueList'][number];\n  export type _AccountsList = SearchRailQuery['searchRail']['results'][number]['outbound'][number]['providers'][number]['ticketOptions'][number]['accountsList'][number];\n  export type BookedTicket = SearchRailQuery['searchRail']['results'][number]['outbound'][number]['providers'][number]['bookedTicket'];\n  export type ___Identifiers = SearchRailQuery['searchRail']['results'][number]['outbound'][number]['providers'][number]['bookedTicket']['identifiers'];\n  export type __Terms = SearchRailQuery['searchRail']['results'][number]['outbound'][number]['providers'][number]['bookedTicket']['terms'];\n  export type __Tickets = SearchRailQuery['searchRail']['results'][number]['outbound'][number]['providers'][number]['bookedTicket']['tickets'][number];\n  export type __TicketQueueList = SearchRailQuery['searchRail']['results'][number]['outbound'][number]['providers'][number]['bookedTicket']['ticketQueueList'][number];\n  export type __AccountsList = SearchRailQuery['searchRail']['results'][number]['outbound'][number]['providers'][number]['bookedTicket']['accountsList'][number];\n  export type TicketExtras = SearchRailQuery['searchRail']['results'][number]['outbound'][number]['ticketExtras'][number];\n  export type ____Identifiers = SearchRailQuery['searchRail']['results'][number]['outbound'][number]['ticketExtras'][number]['identifiers'];\n  export type PlusBus = SearchRailQuery['searchRail']['results'][number]['outbound'][number]['plusBus'];\n  export type Return = SearchRailQuery['searchRail']['results'][number]['return'][number];\n  export type _____Identifiers = SearchRailQuery['searchRail']['results'][number]['return'][number]['identifiers'];\n  export type _Travellers = SearchRailQuery['searchRail']['results'][number]['return'][number]['travellers'][number];\n  export type __Segments = SearchRailQuery['searchRail']['results'][number]['return'][number]['segments'][number];\n  export type _CallingPoints = SearchRailQuery['searchRail']['results'][number]['return'][number]['segments'][number]['callingPoints'][number];\n  export type _Providers = SearchRailQuery['searchRail']['results'][number]['return'][number]['providers'][number];\n  export type _CheapestTicket = SearchRailQuery['searchRail']['results'][number]['return'][number]['providers'][number]['cheapestTicket'];\n  export type ______Identifiers = SearchRailQuery['searchRail']['results'][number]['return'][number]['providers'][number]['cheapestTicket']['identifiers'];\n  export type ___Terms = SearchRailQuery['searchRail']['results'][number]['return'][number]['providers'][number]['cheapestTicket']['terms'];\n  export type _DynamicConditions = SearchRailQuery['searchRail']['results'][number]['return'][number]['providers'][number]['cheapestTicket']['terms']['dynamicConditions'][number];\n  export type ___Tickets = SearchRailQuery['searchRail']['results'][number]['return'][number]['providers'][number]['cheapestTicket']['tickets'][number];\n  export type ___Segments = SearchRailQuery['searchRail']['results'][number]['return'][number]['providers'][number]['cheapestTicket']['tickets'][number]['segments'][number];\n  export type ___TicketQueueList = SearchRailQuery['searchRail']['results'][number]['return'][number]['providers'][number]['cheapestTicket']['ticketQueueList'][number];\n  export type ___AccountsList = SearchRailQuery['searchRail']['results'][number]['return'][number]['providers'][number]['cheapestTicket']['accountsList'][number];\n  export type _TicketOptions = SearchRailQuery['searchRail']['results'][number]['return'][number]['providers'][number]['ticketOptions'][number];\n  export type _______Identifiers = SearchRailQuery['searchRail']['results'][number]['return'][number]['providers'][number]['ticketOptions'][number]['identifiers'];\n  export type _AllowedWith = SearchRailQuery['searchRail']['results'][number]['return'][number]['providers'][number]['ticketOptions'][number]['identifiers']['allowedWith'][number];\n  export type ____Terms = SearchRailQuery['searchRail']['results'][number]['return'][number]['providers'][number]['ticketOptions'][number]['terms'];\n  export type ____Tickets = SearchRailQuery['searchRail']['results'][number]['return'][number]['providers'][number]['ticketOptions'][number]['tickets'][number];\n  export type ____TicketQueueList = SearchRailQuery['searchRail']['results'][number]['return'][number]['providers'][number]['ticketOptions'][number]['ticketQueueList'][number];\n  export type ____AccountsList = SearchRailQuery['searchRail']['results'][number]['return'][number]['providers'][number]['ticketOptions'][number]['accountsList'][number];\n  export type _BookedTicket = SearchRailQuery['searchRail']['results'][number]['return'][number]['providers'][number]['bookedTicket'];\n  export type ________Identifiers = SearchRailQuery['searchRail']['results'][number]['return'][number]['providers'][number]['bookedTicket']['identifiers'];\n  export type _____Terms = SearchRailQuery['searchRail']['results'][number]['return'][number]['providers'][number]['bookedTicket']['terms'];\n  export type _____Tickets = SearchRailQuery['searchRail']['results'][number]['return'][number]['providers'][number]['bookedTicket']['tickets'][number];\n  export type _____TicketQueueList = SearchRailQuery['searchRail']['results'][number]['return'][number]['providers'][number]['bookedTicket']['ticketQueueList'][number];\n  export type _____AccountsList = SearchRailQuery['searchRail']['results'][number]['return'][number]['providers'][number]['bookedTicket']['accountsList'][number];\n  export type _TicketExtras = SearchRailQuery['searchRail']['results'][number]['return'][number]['ticketExtras'][number];\n  export type _PlusBus = SearchRailQuery['searchRail']['results'][number]['return'][number]['plusBus'];\n  export type Errors = SearchRailQuery['searchRail']['errors'][number];\n}\n\nexport namespace SaveRecentSearch {\n  export type Variables = SaveRecentSearchMutationVariables;\n  export type Mutation = SaveRecentSearchMutation;\n  export type SaveRecentSearch = SaveRecentSearchMutation['saveRecentSearch'][number];\n}\n\nexport namespace SaveUserAddress {\n  export type Variables = SaveUserAddressMutationVariables;\n  export type Mutation = SaveUserAddressMutation;\n  export type SaveUserAddress = SaveUserAddressMutation['saveUserAddress'];\n}\n\nexport namespace SearchAirlines {\n  export type Variables = SearchAirlinesQueryVariables;\n  export type Query = SearchAirlinesQuery;\n  export type SearchAirlines = SearchAirlinesQuery['searchAirlines'];\n  export type IataMatch = SearchAirlinesQuery['searchAirlines']['iataMatch'];\n  export type GeneralMatches = SearchAirlinesQuery['searchAirlines']['generalMatches'][number];\n}\n\nexport namespace SearchCities {\n  export type Variables = SearchCitiesQueryVariables;\n  export type Query = SearchCitiesQuery;\n  export type SearchCities = SearchCitiesQuery['searchCities'][number];\n  export type Coordinates = SearchCitiesQuery['searchCities'][number]['coordinates'];\n}\n\nexport namespace SearchConfermaCities {\n  export type Variables = SearchConfermaCitiesQueryVariables;\n  export type Query = SearchConfermaCitiesQuery;\n  export type SearchConfermaCities = SearchConfermaCitiesQuery['searchConfermaCities'];\n  export type Suggestions = SearchConfermaCitiesQuery['searchConfermaCities']['suggestions'][number];\n}\n\nexport namespace SearchEurostar {\n  export type Variables = SearchEurostarQueryVariables;\n  export type Query = SearchEurostarQuery;\n  export type SearchEurostar = SearchEurostarQuery['searchEurostar'];\n  export type Results = SearchEurostarQuery['searchEurostar']['results'];\n  export type Journeys = SearchEurostarQuery['searchEurostar']['results']['journeys'][number];\n  export type OutboundFlights = SearchEurostarQuery['searchEurostar']['results']['journeys'][number]['outboundFlights'][number];\n  export type FareInfo = SearchEurostarQuery['searchEurostar']['results']['journeys'][number]['outboundFlights'][number]['fareInfo'];\n  export type OriginAirportDetail = SearchEurostarQuery['searchEurostar']['results']['journeys'][number]['outboundFlights'][number]['originAirportDetail'];\n  export type DestinationAirportDetail = SearchEurostarQuery['searchEurostar']['results']['journeys'][number]['outboundFlights'][number]['destinationAirportDetail'];\n  export type MarketingCarrierDetail = SearchEurostarQuery['searchEurostar']['results']['journeys'][number]['outboundFlights'][number]['marketingCarrierDetail'];\n  export type OperatingCarrierDetail = SearchEurostarQuery['searchEurostar']['results']['journeys'][number]['outboundFlights'][number]['operatingCarrierDetail'];\n  export type FareConditions = SearchEurostarQuery['searchEurostar']['results']['journeys'][number]['outboundFlights'][number]['fareConditions'];\n  export type Cancellation = SearchEurostarQuery['searchEurostar']['results']['journeys'][number]['outboundFlights'][number]['fareConditions']['cancellation'][number];\n  export type Change = SearchEurostarQuery['searchEurostar']['results']['journeys'][number]['outboundFlights'][number]['fareConditions']['change'][number];\n  export type NoShow = SearchEurostarQuery['searchEurostar']['results']['journeys'][number]['outboundFlights'][number]['fareConditions']['noShow'][number];\n  export type Upgrade = SearchEurostarQuery['searchEurostar']['results']['journeys'][number]['outboundFlights'][number]['fareConditions']['upgrade'][number];\n  export type Other = SearchEurostarQuery['searchEurostar']['results']['journeys'][number]['outboundFlights'][number]['fareConditions']['other'][number];\n  export type InboundFlights = SearchEurostarQuery['searchEurostar']['results']['journeys'][number]['inboundFlights'][number];\n  export type _FareInfo = SearchEurostarQuery['searchEurostar']['results']['journeys'][number]['inboundFlights'][number]['fareInfo'];\n  export type _OriginAirportDetail = SearchEurostarQuery['searchEurostar']['results']['journeys'][number]['inboundFlights'][number]['originAirportDetail'];\n  export type _DestinationAirportDetail = SearchEurostarQuery['searchEurostar']['results']['journeys'][number]['inboundFlights'][number]['destinationAirportDetail'];\n  export type _MarketingCarrierDetail = SearchEurostarQuery['searchEurostar']['results']['journeys'][number]['inboundFlights'][number]['marketingCarrierDetail'];\n  export type _OperatingCarrierDetail = SearchEurostarQuery['searchEurostar']['results']['journeys'][number]['inboundFlights'][number]['operatingCarrierDetail'];\n  export type _FareConditions = SearchEurostarQuery['searchEurostar']['results']['journeys'][number]['inboundFlights'][number]['fareConditions'];\n  export type _Cancellation = SearchEurostarQuery['searchEurostar']['results']['journeys'][number]['inboundFlights'][number]['fareConditions']['cancellation'][number];\n  export type _Change = SearchEurostarQuery['searchEurostar']['results']['journeys'][number]['inboundFlights'][number]['fareConditions']['change'][number];\n  export type _NoShow = SearchEurostarQuery['searchEurostar']['results']['journeys'][number]['inboundFlights'][number]['fareConditions']['noShow'][number];\n  export type _Upgrade = SearchEurostarQuery['searchEurostar']['results']['journeys'][number]['inboundFlights'][number]['fareConditions']['upgrade'][number];\n  export type _Other = SearchEurostarQuery['searchEurostar']['results']['journeys'][number]['inboundFlights'][number]['fareConditions']['other'][number];\n  export type OutboundCarbonEmissions = SearchEurostarQuery['searchEurostar']['results']['journeys'][number]['outboundCarbonEmissions'];\n  export type InboundCarbonEmissions = SearchEurostarQuery['searchEurostar']['results']['journeys'][number]['inboundCarbonEmissions'];\n  export type Taxes = SearchEurostarQuery['searchEurostar']['results']['journeys'][number]['taxes'][number];\n  export type Discounts = SearchEurostarQuery['searchEurostar']['results']['journeys'][number]['discounts'][number];\n  export type Total = SearchEurostarQuery['searchEurostar']['results']['journeys'][number]['total'];\n  export type __FareConditions = SearchEurostarQuery['searchEurostar']['results']['journeys'][number]['fareConditions'];\n  export type __Cancellation = SearchEurostarQuery['searchEurostar']['results']['journeys'][number]['fareConditions']['cancellation'][number];\n  export type __Change = SearchEurostarQuery['searchEurostar']['results']['journeys'][number]['fareConditions']['change'][number];\n  export type __NoShow = SearchEurostarQuery['searchEurostar']['results']['journeys'][number]['fareConditions']['noShow'][number];\n  export type __Upgrade = SearchEurostarQuery['searchEurostar']['results']['journeys'][number]['fareConditions']['upgrade'][number];\n  export type __Other = SearchEurostarQuery['searchEurostar']['results']['journeys'][number]['fareConditions']['other'][number];\n  export type BaggageAllowance = SearchEurostarQuery['searchEurostar']['results']['journeys'][number]['baggageAllowance'][number];\n  export type Multi = SearchEurostarQuery['searchEurostar']['results']['multi'][number];\n  export type _Results = SearchEurostarQuery['searchEurostar']['results']['multi'][number]['results'][number];\n  export type _OutboundFlights = SearchEurostarQuery['searchEurostar']['results']['multi'][number]['results'][number]['outboundFlights'][number];\n  export type __FareInfo = SearchEurostarQuery['searchEurostar']['results']['multi'][number]['results'][number]['outboundFlights'][number]['fareInfo'];\n  export type __OriginAirportDetail = SearchEurostarQuery['searchEurostar']['results']['multi'][number]['results'][number]['outboundFlights'][number]['originAirportDetail'];\n  export type __DestinationAirportDetail = SearchEurostarQuery['searchEurostar']['results']['multi'][number]['results'][number]['outboundFlights'][number]['destinationAirportDetail'];\n  export type __MarketingCarrierDetail = SearchEurostarQuery['searchEurostar']['results']['multi'][number]['results'][number]['outboundFlights'][number]['marketingCarrierDetail'];\n  export type __OperatingCarrierDetail = SearchEurostarQuery['searchEurostar']['results']['multi'][number]['results'][number]['outboundFlights'][number]['operatingCarrierDetail'];\n  export type ___FareConditions = SearchEurostarQuery['searchEurostar']['results']['multi'][number]['results'][number]['outboundFlights'][number]['fareConditions'];\n  export type ___Cancellation = SearchEurostarQuery['searchEurostar']['results']['multi'][number]['results'][number]['outboundFlights'][number]['fareConditions']['cancellation'][number];\n  export type ___Change = SearchEurostarQuery['searchEurostar']['results']['multi'][number]['results'][number]['outboundFlights'][number]['fareConditions']['change'][number];\n  export type ___NoShow = SearchEurostarQuery['searchEurostar']['results']['multi'][number]['results'][number]['outboundFlights'][number]['fareConditions']['noShow'][number];\n  export type ___Upgrade = SearchEurostarQuery['searchEurostar']['results']['multi'][number]['results'][number]['outboundFlights'][number]['fareConditions']['upgrade'][number];\n  export type ___Other = SearchEurostarQuery['searchEurostar']['results']['multi'][number]['results'][number]['outboundFlights'][number]['fareConditions']['other'][number];\n  export type _InboundFlights = SearchEurostarQuery['searchEurostar']['results']['multi'][number]['results'][number]['inboundFlights'][number];\n  export type ___FareInfo = SearchEurostarQuery['searchEurostar']['results']['multi'][number]['results'][number]['inboundFlights'][number]['fareInfo'];\n  export type ___OriginAirportDetail = SearchEurostarQuery['searchEurostar']['results']['multi'][number]['results'][number]['inboundFlights'][number]['originAirportDetail'];\n  export type ___DestinationAirportDetail = SearchEurostarQuery['searchEurostar']['results']['multi'][number]['results'][number]['inboundFlights'][number]['destinationAirportDetail'];\n  export type ___MarketingCarrierDetail = SearchEurostarQuery['searchEurostar']['results']['multi'][number]['results'][number]['inboundFlights'][number]['marketingCarrierDetail'];\n  export type ___OperatingCarrierDetail = SearchEurostarQuery['searchEurostar']['results']['multi'][number]['results'][number]['inboundFlights'][number]['operatingCarrierDetail'];\n  export type ____FareConditions = SearchEurostarQuery['searchEurostar']['results']['multi'][number]['results'][number]['inboundFlights'][number]['fareConditions'];\n  export type ____Cancellation = SearchEurostarQuery['searchEurostar']['results']['multi'][number]['results'][number]['inboundFlights'][number]['fareConditions']['cancellation'][number];\n  export type ____Change = SearchEurostarQuery['searchEurostar']['results']['multi'][number]['results'][number]['inboundFlights'][number]['fareConditions']['change'][number];\n  export type ____NoShow = SearchEurostarQuery['searchEurostar']['results']['multi'][number]['results'][number]['inboundFlights'][number]['fareConditions']['noShow'][number];\n  export type ____Upgrade = SearchEurostarQuery['searchEurostar']['results']['multi'][number]['results'][number]['inboundFlights'][number]['fareConditions']['upgrade'][number];\n  export type ____Other = SearchEurostarQuery['searchEurostar']['results']['multi'][number]['results'][number]['inboundFlights'][number]['fareConditions']['other'][number];\n  export type _OutboundCarbonEmissions = SearchEurostarQuery['searchEurostar']['results']['multi'][number]['results'][number]['outboundCarbonEmissions'];\n  export type _InboundCarbonEmissions = SearchEurostarQuery['searchEurostar']['results']['multi'][number]['results'][number]['inboundCarbonEmissions'];\n  export type _Taxes = SearchEurostarQuery['searchEurostar']['results']['multi'][number]['results'][number]['taxes'][number];\n  export type _Discounts = SearchEurostarQuery['searchEurostar']['results']['multi'][number]['results'][number]['discounts'][number];\n  export type _Total = SearchEurostarQuery['searchEurostar']['results']['multi'][number]['results'][number]['total'];\n  export type _____FareConditions = SearchEurostarQuery['searchEurostar']['results']['multi'][number]['results'][number]['fareConditions'];\n  export type _____Cancellation = SearchEurostarQuery['searchEurostar']['results']['multi'][number]['results'][number]['fareConditions']['cancellation'][number];\n  export type _____Change = SearchEurostarQuery['searchEurostar']['results']['multi'][number]['results'][number]['fareConditions']['change'][number];\n  export type _____NoShow = SearchEurostarQuery['searchEurostar']['results']['multi'][number]['results'][number]['fareConditions']['noShow'][number];\n  export type _____Upgrade = SearchEurostarQuery['searchEurostar']['results']['multi'][number]['results'][number]['fareConditions']['upgrade'][number];\n  export type _____Other = SearchEurostarQuery['searchEurostar']['results']['multi'][number]['results'][number]['fareConditions']['other'][number];\n  export type _BaggageAllowance = SearchEurostarQuery['searchEurostar']['results']['multi'][number]['results'][number]['baggageAllowance'][number];\n  export type Grouped = SearchEurostarQuery['searchEurostar']['results']['grouped'][number];\n  export type Flights = SearchEurostarQuery['searchEurostar']['results']['grouped'][number]['flights'];\n  export type Errors = SearchEurostarQuery['searchEurostar']['errors'][number];\n}\n\nexport namespace SearchHotelChains {\n  export type Variables = SearchHotelChainsQueryVariables;\n  export type Query = SearchHotelChainsQuery;\n}\n\nexport namespace SearchIrl {\n  export type Variables = SearchIrlQueryVariables;\n  export type Query = SearchIrlQuery;\n  export type SearchIrl = SearchIrlQuery['searchIRL'];\n  export type Results = SearchIrlQuery['searchIRL']['results'][number];\n  export type Outbound = SearchIrlQuery['searchIRL']['results'][number]['outbound'][number];\n  export type Identifiers = SearchIrlQuery['searchIRL']['results'][number]['outbound'][number]['identifiers'];\n  export type Travellers = SearchIrlQuery['searchIRL']['results'][number]['outbound'][number]['travellers'][number];\n  export type Segments = SearchIrlQuery['searchIRL']['results'][number]['outbound'][number]['segments'][number];\n  export type SeatPreferenceTypes = SearchIrlQuery['searchIRL']['results'][number]['outbound'][number]['segments'][number]['seatPreferenceTypes'][number];\n  export type Seats = SearchIrlQuery['searchIRL']['results'][number]['outbound'][number]['segments'][number]['seats'][number];\n  export type Providers = SearchIrlQuery['searchIRL']['results'][number]['outbound'][number]['providers'][number];\n  export type CheapestTicket = SearchIrlQuery['searchIRL']['results'][number]['outbound'][number]['providers'][number]['cheapestTicket'];\n  export type _Identifiers = SearchIrlQuery['searchIRL']['results'][number]['outbound'][number]['providers'][number]['cheapestTicket']['identifiers'];\n  export type Tickets = SearchIrlQuery['searchIRL']['results'][number]['outbound'][number]['providers'][number]['cheapestTicket']['tickets'][number];\n  export type _Segments = SearchIrlQuery['searchIRL']['results'][number]['outbound'][number]['providers'][number]['cheapestTicket']['tickets'][number]['segments'][number];\n  export type _SeatPreferenceTypes = SearchIrlQuery['searchIRL']['results'][number]['outbound'][number]['providers'][number]['cheapestTicket']['tickets'][number]['segments'][number]['seatPreferenceTypes'][number];\n  export type _Seats = SearchIrlQuery['searchIRL']['results'][number]['outbound'][number]['providers'][number]['cheapestTicket']['tickets'][number]['segments'][number]['seats'][number];\n  export type TicketOptions = SearchIrlQuery['searchIRL']['results'][number]['outbound'][number]['providers'][number]['ticketOptions'][number];\n  export type __Identifiers = SearchIrlQuery['searchIRL']['results'][number]['outbound'][number]['providers'][number]['ticketOptions'][number]['identifiers'];\n  export type _Tickets = SearchIrlQuery['searchIRL']['results'][number]['outbound'][number]['providers'][number]['ticketOptions'][number]['tickets'][number];\n  export type __Segments = SearchIrlQuery['searchIRL']['results'][number]['outbound'][number]['providers'][number]['ticketOptions'][number]['tickets'][number]['segments'][number];\n  export type __SeatPreferenceTypes = SearchIrlQuery['searchIRL']['results'][number]['outbound'][number]['providers'][number]['ticketOptions'][number]['tickets'][number]['segments'][number]['seatPreferenceTypes'][number];\n  export type __Seats = SearchIrlQuery['searchIRL']['results'][number]['outbound'][number]['providers'][number]['ticketOptions'][number]['tickets'][number]['segments'][number]['seats'][number];\n  export type BookedTicket = SearchIrlQuery['searchIRL']['results'][number]['outbound'][number]['providers'][number]['bookedTicket'];\n  export type ___Identifiers = SearchIrlQuery['searchIRL']['results'][number]['outbound'][number]['providers'][number]['bookedTicket']['identifiers'];\n  export type __Tickets = SearchIrlQuery['searchIRL']['results'][number]['outbound'][number]['providers'][number]['bookedTicket']['tickets'][number];\n  export type ___Segments = SearchIrlQuery['searchIRL']['results'][number]['outbound'][number]['providers'][number]['bookedTicket']['tickets'][number]['segments'][number];\n  export type ___SeatPreferenceTypes = SearchIrlQuery['searchIRL']['results'][number]['outbound'][number]['providers'][number]['bookedTicket']['tickets'][number]['segments'][number]['seatPreferenceTypes'][number];\n  export type ___Seats = SearchIrlQuery['searchIRL']['results'][number]['outbound'][number]['providers'][number]['bookedTicket']['tickets'][number]['segments'][number]['seats'][number];\n  export type TicketExtras = SearchIrlQuery['searchIRL']['results'][number]['outbound'][number]['ticketExtras'][number];\n  export type ____Identifiers = SearchIrlQuery['searchIRL']['results'][number]['outbound'][number]['ticketExtras'][number]['identifiers'];\n  export type PlusBus = SearchIrlQuery['searchIRL']['results'][number]['outbound'][number]['plusBus'];\n  export type Return = SearchIrlQuery['searchIRL']['results'][number]['return'][number];\n  export type _____Identifiers = SearchIrlQuery['searchIRL']['results'][number]['return'][number]['identifiers'];\n  export type _Travellers = SearchIrlQuery['searchIRL']['results'][number]['return'][number]['travellers'][number];\n  export type ____Segments = SearchIrlQuery['searchIRL']['results'][number]['return'][number]['segments'][number];\n  export type ____SeatPreferenceTypes = SearchIrlQuery['searchIRL']['results'][number]['return'][number]['segments'][number]['seatPreferenceTypes'][number];\n  export type ____Seats = SearchIrlQuery['searchIRL']['results'][number]['return'][number]['segments'][number]['seats'][number];\n  export type _Providers = SearchIrlQuery['searchIRL']['results'][number]['return'][number]['providers'][number];\n  export type _CheapestTicket = SearchIrlQuery['searchIRL']['results'][number]['return'][number]['providers'][number]['cheapestTicket'];\n  export type ______Identifiers = SearchIrlQuery['searchIRL']['results'][number]['return'][number]['providers'][number]['cheapestTicket']['identifiers'];\n  export type ___Tickets = SearchIrlQuery['searchIRL']['results'][number]['return'][number]['providers'][number]['cheapestTicket']['tickets'][number];\n  export type _____Segments = SearchIrlQuery['searchIRL']['results'][number]['return'][number]['providers'][number]['cheapestTicket']['tickets'][number]['segments'][number];\n  export type _____SeatPreferenceTypes = SearchIrlQuery['searchIRL']['results'][number]['return'][number]['providers'][number]['cheapestTicket']['tickets'][number]['segments'][number]['seatPreferenceTypes'][number];\n  export type _____Seats = SearchIrlQuery['searchIRL']['results'][number]['return'][number]['providers'][number]['cheapestTicket']['tickets'][number]['segments'][number]['seats'][number];\n  export type _TicketOptions = SearchIrlQuery['searchIRL']['results'][number]['return'][number]['providers'][number]['ticketOptions'][number];\n  export type _______Identifiers = SearchIrlQuery['searchIRL']['results'][number]['return'][number]['providers'][number]['ticketOptions'][number]['identifiers'];\n  export type ____Tickets = SearchIrlQuery['searchIRL']['results'][number]['return'][number]['providers'][number]['ticketOptions'][number]['tickets'][number];\n  export type ______Segments = SearchIrlQuery['searchIRL']['results'][number]['return'][number]['providers'][number]['ticketOptions'][number]['tickets'][number]['segments'][number];\n  export type ______SeatPreferenceTypes = SearchIrlQuery['searchIRL']['results'][number]['return'][number]['providers'][number]['ticketOptions'][number]['tickets'][number]['segments'][number]['seatPreferenceTypes'][number];\n  export type ______Seats = SearchIrlQuery['searchIRL']['results'][number]['return'][number]['providers'][number]['ticketOptions'][number]['tickets'][number]['segments'][number]['seats'][number];\n  export type _BookedTicket = SearchIrlQuery['searchIRL']['results'][number]['return'][number]['providers'][number]['bookedTicket'];\n  export type ________Identifiers = SearchIrlQuery['searchIRL']['results'][number]['return'][number]['providers'][number]['bookedTicket']['identifiers'];\n  export type _____Tickets = SearchIrlQuery['searchIRL']['results'][number]['return'][number]['providers'][number]['bookedTicket']['tickets'][number];\n  export type _______Segments = SearchIrlQuery['searchIRL']['results'][number]['return'][number]['providers'][number]['bookedTicket']['tickets'][number]['segments'][number];\n  export type _______SeatPreferenceTypes = SearchIrlQuery['searchIRL']['results'][number]['return'][number]['providers'][number]['bookedTicket']['tickets'][number]['segments'][number]['seatPreferenceTypes'][number];\n  export type _______Seats = SearchIrlQuery['searchIRL']['results'][number]['return'][number]['providers'][number]['bookedTicket']['tickets'][number]['segments'][number]['seats'][number];\n  export type _TicketExtras = SearchIrlQuery['searchIRL']['results'][number]['return'][number]['ticketExtras'][number];\n  export type _________Identifiers = SearchIrlQuery['searchIRL']['results'][number]['return'][number]['ticketExtras'][number]['identifiers'];\n  export type _PlusBus = SearchIrlQuery['searchIRL']['results'][number]['return'][number]['plusBus'];\n  export type Errors = SearchIrlQuery['searchIRL']['errors'][number];\n}\n\nexport namespace SearchIrlSupplierStations {\n  export type Variables = SearchIrlSupplierStationsQueryVariables;\n  export type Query = SearchIrlSupplierStationsQuery;\n  export type SearchIrlSupplierStations = SearchIrlSupplierStationsQuery['searchIRLSupplierStations'][number];\n  export type LocationDetails = SearchIrlSupplierStationsQuery['searchIRLSupplierStations'][number]['locationDetails'];\n  export type Coordinates = SearchIrlSupplierStationsQuery['searchIRLSupplierStations'][number]['locationDetails']['coordinates'];\n}\n\nexport namespace SearchPostcodes {\n  export type Variables = SearchPostcodesQueryVariables;\n  export type Query = SearchPostcodesQuery;\n  export type GetPostcodeDetails = SearchPostcodesQuery['getPostcodeDetails'];\n}\n\nexport namespace SearchRailStations {\n  export type Variables = SearchRailStationsQueryVariables;\n  export type Query = SearchRailStationsQuery;\n  export type SearchRailStations = SearchRailStationsQuery['searchRailStations'][number];\n  export type LocationDetails = SearchRailStationsQuery['searchRailStations'][number]['locationDetails'];\n  export type Coordinates = SearchRailStationsQuery['searchRailStations'][number]['locationDetails']['coordinates'];\n}\n\nexport namespace SearchUserAddress {\n  export type Variables = SearchUserAddressQueryVariables;\n  export type Query = SearchUserAddressQuery;\n  export type GetUserAddresses = SearchUserAddressQuery['getUserAddresses'][number];\n}\n\nexport namespace SetBasketItemMiGroup {\n  export type Variables = SetBasketItemMiGroupMutationVariables;\n  export type Mutation = SetBasketItemMiGroupMutation;\n  export type SetBasketItemMiGroup = SetBasketItemMiGroupMutation['setBasketItemMIGroup'];\n}\n\nexport namespace SetBasketItemLeadPassenger {\n  export type Variables = SetBasketItemLeadPassengerMutationVariables;\n  export type Mutation = SetBasketItemLeadPassengerMutation;\n  export type SetBasketItemLeadPassenger = SetBasketItemLeadPassengerMutation['setBasketItemLeadPassenger'];\n}\n\nexport namespace SetBasketItemMiValue {\n  export type Variables = SetBasketItemMiValueMutationVariables;\n  export type Mutation = SetBasketItemMiValueMutation;\n  export type SetBasketItemMiValue = SetBasketItemMiValueMutation['setBasketItemMIValue'];\n}\n\nexport namespace SetBasketItemPaymentMethod {\n  export type Variables = SetBasketItemPaymentMethodMutationVariables;\n  export type Mutation = SetBasketItemPaymentMethodMutation;\n  export type SetBasketItemPaymentMethod = SetBasketItemPaymentMethodMutation['setBasketItemPaymentMethod'];\n}\n\nexport namespace UpdateBasketNotes {\n  export type Variables = UpdateBasketNotesMutationVariables;\n  export type Mutation = UpdateBasketNotesMutation;\n  export type UpdateBasketNotes = UpdateBasketNotesMutation['updateBasketNotes'];\n}\n\nexport namespace UpdateBasketTitle {\n  export type Variables = UpdateBasketTitleMutationVariables;\n  export type Mutation = UpdateBasketTitleMutation;\n  export type UpdateBasketTitle = UpdateBasketTitleMutation['updateBasketTitle'];\n}\n\nexport namespace UserFields {\n  export type Fragment = UserFieldsFragment;\n  export type SelectedLanguage = UserFieldsFragment['selectedLanguage'];\n  export type AvailableLanguages = UserFieldsFragment['availableLanguages'][number];\n  export type Passports = UserFieldsFragment['passports'][number];\n  export type Addresses = UserFieldsFragment['addresses'][number];\n  export type PhoneNumbers = UserFieldsFragment['phoneNumbers'][number];\n}\n\nexport namespace GetUserServices {\n  export type Variables = GetUserServicesQueryVariables;\n  export type Query = GetUserServicesQuery;\n  export type GetUserServices = GetUserServicesQuery['getUserServices'][number];\n}\n\nexport namespace GetUserUiConfigs {\n  export type Variables = GetUserUiConfigsQueryVariables;\n  export type Query = GetUserUiConfigsQuery;\n  export type GetUserUiConfigs = GetUserUiConfigsQuery['getUserUIConfigs'];\n  export type All = GetUserUiConfigsQuery['getUserUIConfigs']['all'][number];\n}\n\nexport namespace GetUserMessages {\n  export type Variables = GetUserMessagesQueryVariables;\n  export type Query = GetUserMessagesQuery;\n  export type GetUserMessages = GetUserMessagesQuery['getUserMessages'][number];\n}\n\nexport namespace GetUserPhoneNumbers {\n  export type Variables = GetUserPhoneNumbersQueryVariables;\n  export type Query = GetUserPhoneNumbersQuery;\n  export type GetUserPhoneNumbers = GetUserPhoneNumbersQuery['getUserPhoneNumbers'][number];\n}\n\nexport namespace SetUserLanguage {\n  export type Variables = SetUserLanguageMutationVariables;\n  export type Mutation = SetUserLanguageMutation;\n  export type SetUserLanguage = SetUserLanguageMutation['setUserLanguage'];\n  export type SelectedLanguage = SetUserLanguageMutation['setUserLanguage']['selectedLanguage'];\n}\n\nexport namespace GetUser {\n  export type Variables = GetUserQueryVariables;\n  export type Query = GetUserQuery;\n  export type GetUser = GetUserQuery['getUser'];\n}\n\nexport namespace SearchUserCanBookFor {\n  export type Variables = SearchUserCanBookForQueryVariables;\n  export type Query = SearchUserCanBookForQuery;\n  export type SearchUserCanBookFor = SearchUserCanBookForQuery['searchUserCanBookFor'][number];\n}\n\nexport namespace ValidateUserMiFreeValue {\n  export type Variables = ValidateUserMiFreeValueQueryVariables;\n  export type Query = ValidateUserMiFreeValueQuery;\n}\n\nexport const OwnerFieldsFragmentDoc = gql`\n    fragment OwnerFields on User {\n  id\n  title\n  forename\n  surname\n  email\n}\n    `;\nexport const TravellerFieldsFragmentDoc = gql`\n    fragment TravellerFields on User {\n  id\n  title\n  forename\n  surname\n  email\n  username\n  employeeId\n}\n    `;\nexport const BasketFieldsFragmentDoc = gql`\n    fragment BasketFields on Basket {\n  id\n  owner {\n    ...OwnerFields\n  }\n  reference\n  title\n  notes\n  createdAt\n  updatedAt\n  bookedAt\n  basketItems {\n    id\n    adults\n    children\n    infants\n    detail\n    detailHash\n    createdAt\n    updatedAt\n    expiry\n    expired\n    searchQuery\n    price\n    currency\n    miGroupsAvailable\n    miGroupSelected\n    validated\n    latestValidation\n    latestValidationPrice\n    latestValidationPriceDifference\n    latestValidationAvailable\n    bookingThirdPartyReference\n    pnrLocator\n    status\n    availablePaymentMethods {\n      id\n      name\n      description\n    }\n    selectedPaymentMethod {\n      id\n      name\n      description\n    }\n    perItemSupplementaryBookingInfoSchema @include(if: $withSupplemental)\n    perPassengerSupplementaryBookingInfoSchema @include(if: $withSupplemental)\n    perItemAddress @include(if: $withSupplemental)\n    perItemPhoneNumber @include(if: $withSupplemental)\n    perPassengerAddress @include(if: $withSupplemental)\n    perPassengerPhoneNumber @include(if: $withSupplemental)\n    cancellable\n    amendable\n    co2PerItem\n    co2PerPassenger\n    outboundDate\n    inboundDate\n    service {\n      id\n      type\n    }\n    users {\n      ...TravellerFields\n    }\n    userPassengerTypes {\n      id\n      passengerType\n    }\n    leadPassenger {\n      ...TravellerFields\n    }\n    managementInfo {\n      id\n      dbId\n      name\n      description\n      handoff\n      valueMask\n      uiPresentation\n      mandatory\n      perPassenger\n      perBooking\n      agentOnly\n      createdAt\n      updatedAt\n      fixed\n      fixedValue {\n        id\n        label\n        value\n        default\n        fixed\n        agentOnly\n      }\n      defaultValue {\n        id\n        label\n        value\n        default\n        fixed\n        agentOnly\n      }\n      values {\n        id\n        label\n        value\n        default\n        fixed\n        agentOnly\n      }\n      group\n      selectedValues {\n        value {\n          id\n          label\n          value\n          default\n          fixed\n          agentOnly\n        }\n        freeValue\n        basketLevelValue\n        userLevelValue\n        user {\n          id\n          title\n          forename\n          surname\n          email\n          username\n          employeeId\n          createdAt\n          updatedAt\n          dob\n          admin\n          companyAdmin\n          bookerType\n          authMethods\n          active\n          passwordLastUpdated\n        }\n      }\n    }\n  }\n  status\n  companyGroup {\n    id\n    name\n    description\n    createdAt\n    updatedAt\n  }\n  validated\n}\n    ${OwnerFieldsFragmentDoc}\n${TravellerFieldsFragmentDoc}`;\nexport const ErrorsFragmentDoc = gql`\n    fragment Errors on SearchError {\n  service {\n    id\n    type\n    name\n    description\n  }\n  errorMessage\n  errorCode\n}\n    `;\nexport const GroupedFieldsFragmentDoc = gql`\n    fragment GroupedFields on GroupFlights {\n  referenceID\n  flightID\n  boundIndicator\n  minPrice\n  maxPrice\n  flights {\n    EconomyRestricted\n    EconomyNoBags\n    EconomyFlexi\n    PremiumEconomy\n    Business\n    First\n  }\n}\n    `;\nexport const Location_DetailFragmentDoc = gql`\n    fragment LOCATION_DETAIL on LocationDetail {\n  continent\n  country\n  countryCode\n  state\n  city\n  coordinates {\n    latitude\n    longitude\n    altitude\n  }\n  postcode\n  road\n  gridReference\n  northing\n  easting\n}\n    `;\nexport const UserFieldsFragmentDoc = gql`\n    fragment UserFields on User {\n  id\n  title\n  forename\n  surname\n  email\n  username\n  employeeId\n  createdAt\n  updatedAt\n  dob\n  admin\n  tmcAdmin\n  companyAdmin\n  bookerType\n  authMethods\n  active\n  passwordLastUpdated\n  selectedLanguage {\n    id\n    name\n    isoCode\n  }\n  availableLanguages {\n    id\n    name\n    isoCode\n  }\n  passports {\n    id\n    number\n    codeOfIssuingState\n    nationality\n    sex\n    dob\n    surname\n    givenNames\n    dateOfIssue\n    createdAt\n    updatedAt\n  }\n  addresses {\n    id\n    description\n    numberOrName\n    street\n    town\n    county\n    postcode\n    countryCode\n    userPrimary\n    officePrimary\n  }\n  phoneNumbers {\n    id\n    description\n    countryCode\n    areaCode\n    number\n    extension\n    type\n    officePrimary\n    userPrimary\n  }\n}\n    `;\nexport const AcceptNewPriceDocument = gql`\n    mutation acceptNewPrice($id: ID!, $withSupplemental: Boolean = false) {\n  acceptNewPrice(id: $id) {\n    ...BasketFields\n  }\n}\n    ${BasketFieldsFragmentDoc}`;\n\n  @Injectable({\n    providedIn: 'root'\n  })\n  export class AcceptNewPriceGQL extends Apollo.Mutation<AcceptNewPriceMutation, AcceptNewPriceMutationVariables> {\n    document = AcceptNewPriceDocument;\n    \n    constructor(apollo: Apollo.Apollo) {\n      super(apollo);\n    }\n  }\nexport const AddUsersToBasketItemDocument = gql`\n    mutation addUsersToBasketItem($basketItem: ID!, $users: [UserPassengerTypeInput!]!, $withSupplemental: Boolean!) {\n  addUsersToBasketItem(basketItem: $basketItem, users: $users) {\n    ...BasketFields\n  }\n}\n    ${BasketFieldsFragmentDoc}`;\n\n  @Injectable({\n    providedIn: 'root'\n  })\n  export class AddUsersToBasketItemGQL extends Apollo.Mutation<AddUsersToBasketItemMutation, AddUsersToBasketItemMutationVariables> {\n    document = AddUsersToBasketItemDocument;\n    \n    constructor(apollo: Apollo.Apollo) {\n      super(apollo);\n    }\n  }\nexport const GetUserBasketsDocument = gql`\n    query getUserBaskets($user: ID, $traveller: ID, $basketStatus: BasketStatus, $createdAfter: DateTime, $createdBefore: DateTime, $bookedAfter: DateTime, $bookedBefore: DateTime, $dateOfTravelBefore: DateTime, $dateOfTravelAfter: DateTime, $basketItemBookingReference: String, $basketReference: String, $basketTitle: String, $withSupplemental: Boolean = false) {\n  getUserBaskets(user: $user, traveller: $traveller, basketStatus: $basketStatus, createdAfter: $createdAfter, createdBefore: $createdBefore, bookedAfter: $bookedAfter, bookedBefore: $bookedBefore, dateOfTravelBefore: $dateOfTravelBefore, dateOfTravelAfter: $dateOfTravelAfter, basketItemBookingReference: $basketItemBookingReference, basketReference: $basketReference, basketTitle: $basketTitle) {\n    ...BasketFields\n  }\n}\n    ${BasketFieldsFragmentDoc}`;\n\n  @Injectable({\n    providedIn: 'root'\n  })\n  export class GetUserBasketsGQL extends Apollo.Query<GetUserBasketsQuery, GetUserBasketsQueryVariables> {\n    document = GetUserBasketsDocument;\n    \n    constructor(apollo: Apollo.Apollo) {\n      super(apollo);\n    }\n  }\nexport const DeleteBasketDocument = gql`\n    mutation deleteBasket($id: ID, $reference: String) {\n  deleteBasket(id: $id, reference: $reference)\n}\n    `;\n\n  @Injectable({\n    providedIn: 'root'\n  })\n  export class DeleteBasketGQL extends Apollo.Mutation<DeleteBasketMutation, DeleteBasketMutationVariables> {\n    document = DeleteBasketDocument;\n    \n    constructor(apollo: Apollo.Apollo) {\n      super(apollo);\n    }\n  }\nexport const CreateBasketDocument = gql`\n    mutation createBasket($title: String, $withSupplemental: Boolean = false) {\n  createBasket(title: $title) {\n    ...BasketFields\n  }\n}\n    ${BasketFieldsFragmentDoc}`;\n\n  @Injectable({\n    providedIn: 'root'\n  })\n  export class CreateBasketGQL extends Apollo.Mutation<CreateBasketMutation, CreateBasketMutationVariables> {\n    document = CreateBasketDocument;\n    \n    constructor(apollo: Apollo.Apollo) {\n      super(apollo);\n    }\n  }\nexport const RemoveItemFromBasketDocument = gql`\n    mutation removeItemFromBasket($basketItem: ID!, $withSupplemental: Boolean = false) {\n  removeItemFromBasket(basketItem: $basketItem) {\n    ...BasketFields\n  }\n}\n    ${BasketFieldsFragmentDoc}`;\n\n  @Injectable({\n    providedIn: 'root'\n  })\n  export class RemoveItemFromBasketGQL extends Apollo.Mutation<RemoveItemFromBasketMutation, RemoveItemFromBasketMutationVariables> {\n    document = RemoveItemFromBasketDocument;\n    \n    constructor(apollo: Apollo.Apollo) {\n      super(apollo);\n    }\n  }\nexport const SendBasketForApprovalDocument = gql`\n    mutation sendBasketForApproval($basket: ID!, $withSupplemental: Boolean = true) {\n  sendBasketForApproval(basket: $basket) {\n    ...BasketFields\n  }\n}\n    ${BasketFieldsFragmentDoc}`;\n\n  @Injectable({\n    providedIn: 'root'\n  })\n  export class SendBasketForApprovalGQL extends Apollo.Mutation<SendBasketForApprovalMutation, SendBasketForApprovalMutationVariables> {\n    document = SendBasketForApprovalDocument;\n    \n    constructor(apollo: Apollo.Apollo) {\n      super(apollo);\n    }\n  }\nexport const AddItemToBasketDocument = gql`\n    mutation addItemToBasket($basket: ID, $service: ID!, $detail: JSON!, $adults: Int!, $children: Int, $infants: Int, $price: Float!, $currency: CurrencyCode!, $searchQuery: JSON!, $quickAdd: Boolean, $users: [UserPassengerTypeInput], $leadPassenger: ID, $co2PerItem: Float, $co2PerPassenger: Float, $outboundDate: DateTime!, $inboundDate: DateTime, $withSupplemental: Boolean = false) {\n  addItemToBasket(basket: $basket, service: $service, detail: $detail, adults: $adults, children: $children, infants: $infants, price: $price, currency: $currency, searchQuery: $searchQuery, quickAdd: $quickAdd, users: $users, leadPassenger: $leadPassenger, co2PerItem: $co2PerItem, co2PerPassenger: $co2PerPassenger, outboundDate: $outboundDate, inboundDate: $inboundDate) {\n    ...BasketFields\n  }\n}\n    ${BasketFieldsFragmentDoc}`;\n\n  @Injectable({\n    providedIn: 'root'\n  })\n  export class AddItemToBasketGQL extends Apollo.Mutation<AddItemToBasketMutation, AddItemToBasketMutationVariables> {\n    document = AddItemToBasketDocument;\n    \n    constructor(apollo: Apollo.Apollo) {\n      super(apollo);\n    }\n  }\nexport const GetUserBasketDocument = gql`\n    query getUserBasket($id: ID!, $withSupplemental: Boolean = false) {\n  getUserBasket(id: $id) {\n    ...BasketFields\n  }\n}\n    ${BasketFieldsFragmentDoc}`;\n\n  @Injectable({\n    providedIn: 'root'\n  })\n  export class GetUserBasketGQL extends Apollo.Query<GetUserBasketQuery, GetUserBasketQueryVariables> {\n    document = GetUserBasketDocument;\n    \n    constructor(apollo: Apollo.Apollo) {\n      super(apollo);\n    }\n  }\nexport const RevalidateBasketDocument = gql`\n    mutation revalidateBasket($id: ID!, $withSupplemental: Boolean = false) {\n  revalidateBasket(id: $id) {\n    ...BasketFields\n  }\n}\n    ${BasketFieldsFragmentDoc}`;\n\n  @Injectable({\n    providedIn: 'root'\n  })\n  export class RevalidateBasketGQL extends Apollo.Mutation<RevalidateBasketMutation, RevalidateBasketMutationVariables> {\n    document = RevalidateBasketDocument;\n    \n    constructor(apollo: Apollo.Apollo) {\n      super(apollo);\n    }\n  }\nexport const BookBasketDocument = gql`\n    mutation bookBasket($id: ID!, $supplementaryInfo: [SupplementaryBookingInfo!]!, $withSupplemental: Boolean = false) {\n  bookBasket(id: $id, supplementaryInfo: $supplementaryInfo) {\n    ...BasketFields\n  }\n}\n    ${BasketFieldsFragmentDoc}`;\n\n  @Injectable({\n    providedIn: 'root'\n  })\n  export class BookBasketGQL extends Apollo.Mutation<BookBasketMutation, BookBasketMutationVariables> {\n    document = BookBasketDocument;\n    \n    constructor(apollo: Apollo.Apollo) {\n      super(apollo);\n    }\n  }\nexport const SearchCabHireDocument = gql`\n    query searchCabHire($departs: DateTime!, $fromLocation: CabHireLocationInput!, $toLocation: CabHireLocationInput!, $adults: Int!, $children: Int, $infants: Int, $vias: [CabHireLocationInput], $vehicleType: CabHireVehicleType) {\n  searchCabHire(departs: $departs, fromLocation: $fromLocation, toLocation: $toLocation, adults: $adults, children: $children, infants: $infants, vias: $vias, vehicleType: $vehicleType) {\n    results {\n      id\n      source\n      sourceId\n      supplierName\n      estimatedCO2\n      co2PerItem\n      co2PerPassenger\n      price\n      currency\n      vehicleType\n      tripDistanceMetres\n      tripDurationSeconds\n      departs\n      tmcPreferred\n      companyPreferred\n      officePreferred\n      tmcPreferredMessage\n      companyPreferredMessage\n      officePreferredMessage\n      unavailable\n      unavailableMessage\n      fromLocation {\n        address\n        postcode\n        latitude\n        longitude\n      }\n      toLocation {\n        address\n        postcode\n        latitude\n        longitude\n      }\n      vias {\n        address\n        postcode\n        latitude\n        longitude\n      }\n    }\n    errors {\n      ...Errors\n    }\n  }\n}\n    ${ErrorsFragmentDoc}`;\n\n  @Injectable({\n    providedIn: 'root'\n  })\n  export class SearchCabHireGQL extends Apollo.Query<SearchCabHireQuery, SearchCabHireQueryVariables> {\n    document = SearchCabHireDocument;\n    \n    constructor(apollo: Apollo.Apollo) {\n      super(apollo);\n    }\n  }\nexport const CarHireAvailabilityDetailRequestDocument = gql`\n    query carHireAvailabilityDetailRequest($locationDetails: CarHireInputIdentifiers!) {\n  carHireAvailabilityDetailRequest(locationDetails: $locationDetails) {\n    identifiers {\n      locator\n      rph\n      status\n      vehType\n      locationCode\n      extendedLocationCode\n      locationName\n      dropOffLocation\n      pickupDateTime\n      dropoffDateTime\n      vendor\n    }\n    vendor {\n      name\n      logo\n    }\n    address {\n      name\n      topLine\n      city\n      region\n      postCode\n      country\n      countryCode\n      stateCode\n      latitude\n      longitude\n    }\n    additionalInfo {\n      name\n      text\n      json\n      custom {\n        name\n        text\n      }\n    }\n  }\n}\n    `;\n\n  @Injectable({\n    providedIn: 'root'\n  })\n  export class CarHireAvailabilityDetailRequestGQL extends Apollo.Query<CarHireAvailabilityDetailRequestQuery, CarHireAvailabilityDetailRequestQueryVariables> {\n    document = CarHireAvailabilityDetailRequestDocument;\n    \n    constructor(apollo: Apollo.Apollo) {\n      super(apollo);\n    }\n  }\nexport const SearchCarHireDocument = gql`\n    query searchCarHire($airport: CarHireAirportInput, $city: CarHireCityInput, $location: CarHireLocationInput, $depot: InputCarHireDepot, $pickupDateTime: DateTime!, $dropoffDateTime: DateTime!, $vendor: String, $class: CarHireClass, $type: CarHireType, $transmission: CarHireTransmission, $aircon: Boolean, $estimatedDailyDistance: Float, $estimatedDailyDistanceUnits: DistanceTypes) {\n  searchCarHire(airport: $airport, city: $city, location: $location, depot: $depot, pickupDateTime: $pickupDateTime, dropoffDateTime: $dropoffDateTime, vendor: $vendor, class: $class, type: $type, transmission: $transmission, aircon: $aircon, estimatedDailyDistance: $estimatedDailyDistance, estimatedDailyDistanceUnits: $estimatedDailyDistanceUnits) {\n    results {\n      source\n      sourceId\n      identifiers {\n        locator\n        rph\n        status\n        vehType\n        locationCode\n        extendedLocationCode\n        locationName\n        dropOffLocation\n        pickupDateTime\n        dropoffDateTime\n        vendor\n      }\n      displayRecord {\n        status\n        pickup\n        dropoff\n        vendor {\n          name\n          logo\n        }\n        vehicle {\n          class\n          type\n          transmission\n          aircon\n          description\n          images\n        }\n        charges {\n          label\n          amount\n          currencyCode\n        }\n        pickupLocation {\n          name\n          topLine\n          city\n          region\n          postCode\n          country\n          countryCode\n          stateCode\n          latitude\n          longitude\n        }\n        returnLocation {\n          name\n          topLine\n          city\n          region\n          postCode\n          country\n          countryCode\n          stateCode\n          latitude\n          longitude\n        }\n        additionalInfo {\n          name\n          text\n          json\n          custom {\n            name\n            text\n          }\n        }\n      }\n      tmcPreferred\n      companyPreferred\n      officePreferred\n      tmcPreferredMessage\n      companyPreferredMessage\n      officePreferredMessage\n      unavailable\n      unavailableMessage\n      co2PerPassenger\n      co2PerItem\n    }\n    errors {\n      ...Errors\n    }\n  }\n}\n    ${ErrorsFragmentDoc}`;\n\n  @Injectable({\n    providedIn: 'root'\n  })\n  export class SearchCarHireGQL extends Apollo.Query<SearchCarHireQuery, SearchCarHireQueryVariables> {\n    document = SearchCarHireDocument;\n    \n    constructor(apollo: Apollo.Apollo) {\n      super(apollo);\n    }\n  }\nexport const DeleteRecentSearchDocument = gql`\n    mutation deleteRecentSearch($id: ID!) {\n  deleteRecentSearch(id: $id)\n}\n    `;\n\n  @Injectable({\n    providedIn: 'root'\n  })\n  export class DeleteRecentSearchGQL extends Apollo.Mutation<DeleteRecentSearchMutation, DeleteRecentSearchMutationVariables> {\n    document = DeleteRecentSearchDocument;\n    \n    constructor(apollo: Apollo.Apollo) {\n      super(apollo);\n    }\n  }\nexport const DeleteUserAddressDocument = gql`\n    mutation deleteUserAddress($id: ID!) {\n  deleteUserAddress(id: $id)\n}\n    `;\n\n  @Injectable({\n    providedIn: 'root'\n  })\n  export class DeleteUserAddressGQL extends Apollo.Mutation<DeleteUserAddressMutation, DeleteUserAddressMutationVariables> {\n    document = DeleteUserAddressDocument;\n    \n    constructor(apollo: Apollo.Apollo) {\n      super(apollo);\n    }\n  }\nexport const SearchFlightsV2Document = gql`\n    query searchFlightsV2($passengers: [FlightPassengerObject!]!, $originAirport: String, $destinationAirport: String, $multiDestination: [DestinationEntry], $outboundDate: Date, $outboundDepartureTimeWindow: String, $outboundArrivalTimeWindow: String, $outboundCabinClass: [FlightCabinClass], $returnTrip: Boolean!, $returnDate: Date, $returnDepartureTimeWindow: String, $returnArrivalTimeWindow: String, $returnCabinClass: [FlightCabinClass], $fareType: FareType!, $requireFreeBag: Boolean, $maxConnections: Int, $preferredCarriers: [String], $includeNearbyAirports: Boolean, $asSingles: Boolean, $withGrouped: Boolean!) {\n  searchFlightsV2(passengers: $passengers, originAirport: $originAirport, destinationAirport: $destinationAirport, multiDestination: $multiDestination, outboundDate: $outboundDate, outboundDepartureTimeWindow: $outboundDepartureTimeWindow, outboundArrivalTimeWindow: $outboundArrivalTimeWindow, outboundCabinClass: $outboundCabinClass, returnTrip: $returnTrip, returnDate: $returnDate, returnDepartureTimeWindow: $returnDepartureTimeWindow, returnArrivalTimeWindow: $returnArrivalTimeWindow, returnCabinClass: $returnCabinClass, fareType: $fareType, requireFreeBag: $requireFreeBag, maxConnections: $maxConnections, preferredCarriers: $preferredCarriers, includeNearbyAirports: $includeNearbyAirports, asSingles: $asSingles) {\n    results {\n      journeys {\n        uid\n        passengerCount\n        outboundFlights {\n          originAirport\n          originTerminal\n          originAirportName\n          originAirportDetail {\n            iata\n            icao\n            latitude\n            longitude\n            altitude\n            state\n            city\n            road\n            popularity\n            area\n            location\n            offset\n            airportName\n            countryName\n            countryCode\n            postcode\n          }\n          destinationAirport\n          destinationTerminal\n          destinationAirportName\n          destinationAirportDetail {\n            iata\n            icao\n            latitude\n            longitude\n            altitude\n            state\n            city\n            road\n            popularity\n            area\n            location\n            offset\n            airportName\n            countryName\n            countryCode\n            postcode\n          }\n          dateTimeDeparting\n          dateTimeDepartingUTC\n          dateTimeArriving\n          dateTimeArrivingUTC\n          marketingCarrier\n          marketingCarrierName\n          marketingCarrierDetail {\n            name\n            alias\n            callsign\n            iata\n            icao\n            logo\n            banner\n            popularity\n          }\n          marketingFlightNumber\n          operatingCarrier\n          operatingCarrierName\n          operatingCarrierDetail {\n            name\n            alias\n            callsign\n            iata\n            icao\n            logo\n            banner\n            popularity\n          }\n          operatingFlightNumber\n          equipmentCode\n          equipmentName\n          totalDuration\n          cabinClass\n          marketingNames\n          fareConditions {\n            cancellation {\n              name\n              type\n              currency\n              amount\n              remark\n              changeFeeInd\n              cancelFeeInd\n              refundableInd\n            }\n            change {\n              name\n              type\n              currency\n              amount\n              remark\n              changeFeeInd\n              cancelFeeInd\n              refundableInd\n            }\n            noShow {\n              name\n              type\n              currency\n              amount\n              remark\n              changeFeeInd\n              cancelFeeInd\n              refundableInd\n            }\n            upgrade {\n              name\n              type\n              currency\n              amount\n              remark\n              changeFeeInd\n              cancelFeeInd\n              refundableInd\n            }\n            other {\n              name\n              type\n              currency\n              amount\n              remark\n              changeFeeInd\n              cancelFeeInd\n              refundableInd\n            }\n          }\n          vendorCode\n          stops\n          bookingCode\n          marriageGroup\n          fareBasisCode\n          additional\n        }\n        inboundFlights {\n          originAirport\n          originTerminal\n          originAirportName\n          originAirportDetail {\n            iata\n            icao\n            latitude\n            longitude\n            altitude\n            state\n            city\n            road\n            popularity\n            area\n            location\n            offset\n            airportName\n            countryName\n            countryCode\n            postcode\n          }\n          destinationAirport\n          destinationTerminal\n          destinationAirportName\n          destinationAirportDetail {\n            iata\n            icao\n            latitude\n            longitude\n            altitude\n            state\n            city\n            road\n            popularity\n            area\n            location\n            offset\n            airportName\n            countryName\n            countryCode\n            postcode\n          }\n          dateTimeDeparting\n          dateTimeDepartingUTC\n          dateTimeArriving\n          dateTimeArrivingUTC\n          marketingCarrier\n          marketingCarrierName\n          marketingCarrierDetail {\n            name\n            alias\n            callsign\n            iata\n            icao\n            logo\n            banner\n            popularity\n          }\n          marketingFlightNumber\n          operatingCarrier\n          operatingCarrierName\n          operatingCarrierDetail {\n            name\n            alias\n            callsign\n            iata\n            icao\n            logo\n            banner\n            popularity\n          }\n          operatingFlightNumber\n          equipmentCode\n          equipmentName\n          totalDuration\n          cabinClass\n          marketingNames\n          fareConditions {\n            cancellation {\n              name\n              type\n              currency\n              amount\n              remark\n              changeFeeInd\n              cancelFeeInd\n              refundableInd\n            }\n            change {\n              name\n              type\n              currency\n              amount\n              remark\n              changeFeeInd\n              cancelFeeInd\n              refundableInd\n            }\n            noShow {\n              name\n              type\n              currency\n              amount\n              remark\n              changeFeeInd\n              cancelFeeInd\n              refundableInd\n            }\n            upgrade {\n              name\n              type\n              currency\n              amount\n              remark\n              changeFeeInd\n              cancelFeeInd\n              refundableInd\n            }\n            other {\n              name\n              type\n              currency\n              amount\n              remark\n              changeFeeInd\n              cancelFeeInd\n              refundableInd\n            }\n          }\n          vendorCode\n          stops\n          bookingCode\n          marriageGroup\n          fareBasisCode\n          additional\n        }\n        outboundTotalDuration\n        outboundCarbonEmissions {\n          amount\n          unit\n        }\n        inboundTotalDuration\n        inboundCarbonEmissions {\n          amount\n          unit\n        }\n        taxes {\n          description\n          amount\n          currency\n        }\n        discounts {\n          description\n          amount\n          currency\n        }\n        total {\n          price\n          tax\n          discount\n          currency\n        }\n        fareConditions {\n          cancellation {\n            name\n            type\n            currency\n            amount\n            remark\n            changeFeeInd\n            cancelFeeInd\n            refundableInd\n          }\n          change {\n            name\n            type\n            currency\n            amount\n            remark\n            changeFeeInd\n            cancelFeeInd\n            refundableInd\n          }\n          noShow {\n            name\n            type\n            currency\n            amount\n            remark\n            changeFeeInd\n            cancelFeeInd\n            refundableInd\n          }\n          upgrade {\n            name\n            type\n            currency\n            amount\n            remark\n            changeFeeInd\n            cancelFeeInd\n            refundableInd\n          }\n          other {\n            name\n            type\n            currency\n            amount\n            remark\n            changeFeeInd\n            cancelFeeInd\n            refundableInd\n          }\n        }\n        baggageAllowance {\n          type\n          qty\n          maxKG\n          maxLBS\n        }\n        additional\n        source\n        sourceId\n        version\n        tmcPreferred\n        companyPreferred\n        officePreferred\n        tmcPreferredMessage\n        companyPreferredMessage\n        officePreferredMessage\n        unavailable\n        unavailableMessage\n        co2PerItem\n        co2PerPassenger\n      }\n      multi {\n        order\n        origin\n        destination\n        results {\n          uid\n          passengerCount\n          outboundFlights {\n            originAirport\n            originTerminal\n            originAirportName\n            originAirportDetail {\n              iata\n              icao\n              latitude\n              longitude\n              altitude\n              state\n              city\n              road\n              popularity\n              area\n              location\n              offset\n              airportName\n              countryName\n              countryCode\n              postcode\n            }\n            destinationAirport\n            destinationTerminal\n            destinationAirportName\n            destinationAirportDetail {\n              iata\n              icao\n              latitude\n              longitude\n              altitude\n              state\n              city\n              road\n              popularity\n              area\n              location\n              offset\n              airportName\n              countryName\n              countryCode\n              postcode\n            }\n            dateTimeDeparting\n            dateTimeDepartingUTC\n            dateTimeArriving\n            dateTimeArrivingUTC\n            marketingCarrier\n            marketingCarrierName\n            marketingCarrierDetail {\n              name\n              alias\n              callsign\n              iata\n              icao\n              logo\n              banner\n              popularity\n            }\n            marketingFlightNumber\n            operatingCarrier\n            operatingCarrierName\n            operatingCarrierDetail {\n              name\n              alias\n              callsign\n              iata\n              icao\n              logo\n              banner\n              popularity\n            }\n            operatingFlightNumber\n            equipmentCode\n            equipmentName\n            totalDuration\n            cabinClass\n            marketingNames\n            fareConditions {\n              cancellation {\n                name\n                type\n                currency\n                amount\n                remark\n                changeFeeInd\n                cancelFeeInd\n                refundableInd\n              }\n              change {\n                name\n                type\n                currency\n                amount\n                remark\n                changeFeeInd\n                cancelFeeInd\n                refundableInd\n              }\n              noShow {\n                name\n                type\n                currency\n                amount\n                remark\n                changeFeeInd\n                cancelFeeInd\n                refundableInd\n              }\n              upgrade {\n                name\n                type\n                currency\n                amount\n                remark\n                changeFeeInd\n                cancelFeeInd\n                refundableInd\n              }\n              other {\n                name\n                type\n                currency\n                amount\n                remark\n                changeFeeInd\n                cancelFeeInd\n                refundableInd\n              }\n            }\n            vendorCode\n            stops\n            bookingCode\n            marriageGroup\n            fareBasisCode\n            additional\n          }\n          inboundFlights {\n            originAirport\n            originTerminal\n            originAirportName\n            originAirportDetail {\n              iata\n              icao\n              latitude\n              longitude\n              altitude\n              state\n              city\n              road\n              popularity\n              area\n              location\n              offset\n              airportName\n              countryName\n              countryCode\n              postcode\n            }\n            destinationAirport\n            destinationTerminal\n            destinationAirportName\n            destinationAirportDetail {\n              iata\n              icao\n              latitude\n              longitude\n              altitude\n              state\n              city\n              road\n              popularity\n              area\n              location\n              offset\n              airportName\n              countryName\n              countryCode\n              postcode\n            }\n            dateTimeDeparting\n            dateTimeDepartingUTC\n            dateTimeArriving\n            dateTimeArrivingUTC\n            marketingCarrier\n            marketingCarrierName\n            marketingCarrierDetail {\n              name\n              alias\n              callsign\n              iata\n              icao\n              logo\n              banner\n              popularity\n            }\n            marketingFlightNumber\n            operatingCarrier\n            operatingCarrierName\n            operatingCarrierDetail {\n              name\n              alias\n              callsign\n              iata\n              icao\n              logo\n              banner\n              popularity\n            }\n            operatingFlightNumber\n            equipmentCode\n            equipmentName\n            totalDuration\n            cabinClass\n            marketingNames\n            fareConditions {\n              cancellation {\n                name\n                type\n                currency\n                amount\n                remark\n                changeFeeInd\n                cancelFeeInd\n                refundableInd\n              }\n              change {\n                name\n                type\n                currency\n                amount\n                remark\n                changeFeeInd\n                cancelFeeInd\n                refundableInd\n              }\n              noShow {\n                name\n                type\n                currency\n                amount\n                remark\n                changeFeeInd\n                cancelFeeInd\n                refundableInd\n              }\n              upgrade {\n                name\n                type\n                currency\n                amount\n                remark\n                changeFeeInd\n                cancelFeeInd\n                refundableInd\n              }\n              other {\n                name\n                type\n                currency\n                amount\n                remark\n                changeFeeInd\n                cancelFeeInd\n                refundableInd\n              }\n            }\n            vendorCode\n            stops\n            bookingCode\n            marriageGroup\n            fareBasisCode\n            additional\n          }\n          outboundTotalDuration\n          outboundCarbonEmissions {\n            amount\n            unit\n          }\n          inboundTotalDuration\n          inboundCarbonEmissions {\n            amount\n            unit\n          }\n          taxes {\n            description\n            amount\n            currency\n          }\n          discounts {\n            description\n            amount\n            currency\n          }\n          total {\n            price\n            tax\n            discount\n            currency\n          }\n          fareConditions {\n            cancellation {\n              name\n              type\n              currency\n              amount\n              remark\n              changeFeeInd\n              cancelFeeInd\n              refundableInd\n            }\n            change {\n              name\n              type\n              currency\n              amount\n              remark\n              changeFeeInd\n              cancelFeeInd\n              refundableInd\n            }\n            noShow {\n              name\n              type\n              currency\n              amount\n              remark\n              changeFeeInd\n              cancelFeeInd\n              refundableInd\n            }\n            upgrade {\n              name\n              type\n              currency\n              amount\n              remark\n              changeFeeInd\n              cancelFeeInd\n              refundableInd\n            }\n            other {\n              name\n              type\n              currency\n              amount\n              remark\n              changeFeeInd\n              cancelFeeInd\n              refundableInd\n            }\n          }\n          baggageAllowance {\n            type\n            qty\n            maxKG\n            maxLBS\n          }\n          additional\n          source\n          sourceId\n          version\n          tmcPreferred\n          companyPreferred\n          officePreferred\n          tmcPreferredMessage\n          companyPreferredMessage\n          officePreferredMessage\n          unavailable\n          unavailableMessage\n          co2PerItem\n          co2PerPassenger\n        }\n        minPrice\n        maxPrice\n      }\n      grouped {\n        ...GroupedFields @include(if: $withGrouped)\n      }\n    }\n    errors {\n      ...Errors\n    }\n  }\n}\n    ${GroupedFieldsFragmentDoc}\n${ErrorsFragmentDoc}`;\n\n  @Injectable({\n    providedIn: 'root'\n  })\n  export class SearchFlightsV2GQL extends Apollo.Query<SearchFlightsV2Query, SearchFlightsV2QueryVariables> {\n    document = SearchFlightsV2Document;\n    \n    constructor(apollo: Apollo.Apollo) {\n      super(apollo);\n    }\n  }\nexport const GetCarHireDepotsDocument = gql`\n    query getCarHireDepots($latitude: Float!, $longitude: Float!, $vendorCode: String) {\n  getCarHireDepots(latitude: $latitude, longitude: $longitude, vendorCode: $vendorCode) {\n    countryCode\n    locationCode\n    extendedLocationCode\n    vendorCode\n    latitude\n    longitude\n    vendor\n    addressLines\n    cityName\n  }\n}\n    `;\n\n  @Injectable({\n    providedIn: 'root'\n  })\n  export class GetCarHireDepotsGQL extends Apollo.Query<GetCarHireDepotsQuery, GetCarHireDepotsQueryVariables> {\n    document = GetCarHireDepotsDocument;\n    \n    constructor(apollo: Apollo.Apollo) {\n      super(apollo);\n    }\n  }\nexport const GetConfermaOfficeDocument = gql`\n    query getConfermaOffice($officeId: Int!) {\n  getConfermaOffice(officeId: $officeId) {\n    results {\n      id\n      name\n      address {\n        addressName\n        addressLine1\n        addressLine2\n        addressLine3\n        postalCode\n        city\n        countryCode\n        countryName\n        telephoneNumber\n        facsimileNumber\n        emailAddress\n        stateProvince\n        mobileNumber\n      }\n      closestAirport\n      closestTrainStation\n      longitude\n      latitude\n      closestHotels {\n        hotelId\n        hotelName\n        isPreferred\n      }\n    }\n    errors {\n      service {\n        id\n        type\n        name\n        description\n        supplierUrl\n        active\n        apiEndpointUrl\n        basketItemTtl\n        cancellable\n        amendable\n        detailSchema\n        searchQuerySchema\n      }\n      errorMessage\n      errorCode\n    }\n  }\n}\n    `;\n\n  @Injectable({\n    providedIn: 'root'\n  })\n  export class GetConfermaOfficeGQL extends Apollo.Query<GetConfermaOfficeQuery, GetConfermaOfficeQueryVariables> {\n    document = GetConfermaOfficeDocument;\n    \n    constructor(apollo: Apollo.Apollo) {\n      super(apollo);\n    }\n  }\nexport const GetConfermaOfficeNamesDocument = gql`\n    query getConfermaOfficeNames {\n  getConfermaOfficeNames {\n    results {\n      id\n      name\n    }\n    errors {\n      ...Errors\n    }\n  }\n}\n    ${ErrorsFragmentDoc}`;\n\n  @Injectable({\n    providedIn: 'root'\n  })\n  export class GetConfermaOfficeNamesGQL extends Apollo.Query<GetConfermaOfficeNamesQuery, GetConfermaOfficeNamesQueryVariables> {\n    document = GetConfermaOfficeNamesDocument;\n    \n    constructor(apollo: Apollo.Apollo) {\n      super(apollo);\n    }\n  }\nexport const GetConfermaQuicklistDocument = gql`\n    query getConfermaQuicklist($countryCode: String!) {\n  getConfermaQuicklist(countryCode: $countryCode) {\n    results {\n      id\n      name\n      imageUrl\n      group\n      location {\n        distance\n        distanceType\n        longitude\n        latitude\n      }\n      address {\n        addressLine1\n        addressLine2\n        addressLine3\n        postOrZipCode\n        countryCode\n        telephone\n        facsimile\n      }\n      transports {\n        type\n        name\n        code\n        distance\n        distanceType\n        longitude\n        latitude\n      }\n      preferred {\n        client\n        consumer\n      }\n      tags {\n        name\n        display\n        type\n        icon\n      }\n      availableRates {\n        hotelId\n        imageUrl\n        rooms {\n          roomId\n          roomType\n          roomDescription\n          rateCode\n          rateDescription\n          total\n          currencyCode\n          currencyConversion {\n            rate\n            localCode\n            localTotal\n            convertedCode\n            convertedTotal\n          }\n          deposit {\n            amount\n            policy\n            required\n          }\n          nights {\n            night\n            rate\n            info\n            date\n          }\n          policies {\n            cancellation\n            deposit\n            disabledAccess\n            general\n            guarantee\n            refundAvailable\n          }\n          tax {\n            included\n            rate\n          }\n          acceptedCards {\n            id\n            name\n          }\n          paymentTypes {\n            type\n            name\n          }\n        }\n        prpn\n        currencyCode\n        isBusy\n        source\n        version\n      }\n      version\n      tmcPreferredMessage\n      companyPreferredMessage\n      officePreferredMessage\n      unavailableMessage\n    }\n    errors {\n      ...Errors\n    }\n  }\n}\n    ${ErrorsFragmentDoc}`;\n\n  @Injectable({\n    providedIn: 'root'\n  })\n  export class GetConfermaQuicklistGQL extends Apollo.Query<GetConfermaQuicklistQuery, GetConfermaQuicklistQueryVariables> {\n    document = GetConfermaQuicklistDocument;\n    \n    constructor(apollo: Apollo.Apollo) {\n      super(apollo);\n    }\n  }\nexport const GetIrlSupplierStationDocument = gql`\n    query getIRLSupplierStation($id: ID, $supplier: IRLSupplier, $code: String) {\n  getIRLSupplierStation(id: $id, supplier: $supplier, code: $code) {\n    id\n    name\n    supplier\n    stationCode\n    nlcCode\n    trainlineCode\n    trainlineUniqueCode\n    locationDetails {\n      continent\n      country\n      countryCode\n      state\n      city\n      coordinates {\n        latitude\n        longitude\n        altitude\n      }\n      postcode\n      road\n      gridReference\n      northing\n      easting\n    }\n  }\n}\n    `;\n\n  @Injectable({\n    providedIn: 'root'\n  })\n  export class GetIrlSupplierStationGQL extends Apollo.Query<GetIrlSupplierStationQuery, GetIrlSupplierStationQueryVariables> {\n    document = GetIrlSupplierStationDocument;\n    \n    constructor(apollo: Apollo.Apollo) {\n      super(apollo);\n    }\n  }\nexport const GetRailStationDocument = gql`\n    query getRailStation($id: ID, $code: String) {\n  getRailStation(id: $id, code: $code) {\n    id\n    name\n    stationCode\n    nlcCode\n    trainlineCode\n    trainlineUniqueCode\n    locationDetails {\n      continent\n      country\n      countryCode\n      state\n      city\n      coordinates {\n        latitude\n        longitude\n        altitude\n      }\n      postcode\n      road\n      gridReference\n      northing\n      easting\n    }\n  }\n}\n    `;\n\n  @Injectable({\n    providedIn: 'root'\n  })\n  export class GetRailStationGQL extends Apollo.Query<GetRailStationQuery, GetRailStationQueryVariables> {\n    document = GetRailStationDocument;\n    \n    constructor(apollo: Apollo.Apollo) {\n      super(apollo);\n    }\n  }\nexport const GetRailcardsDocument = gql`\n    query getRailcards {\n  getRailcards {\n    name\n    code\n  }\n}\n    `;\n\n  @Injectable({\n    providedIn: 'root'\n  })\n  export class GetRailcardsGQL extends Apollo.Query<GetRailcardsQuery, GetRailcardsQueryVariables> {\n    document = GetRailcardsDocument;\n    \n    constructor(apollo: Apollo.Apollo) {\n      super(apollo);\n    }\n  }\nexport const GetRiskAlertsDocument = gql`\n    query getRiskAlerts($minLevel: RiskLevel!, $maxLevel: RiskLevel!, $countryIsoCode: String, $airport: ID, $railStation: ID, $airportIata: String) {\n  getRiskAlerts(minLevel: $minLevel, maxLevel: $maxLevel, countryIsoCode: $countryIsoCode, airport: $airport, railStation: $railStation, airportIata: $airportIata) {\n    id\n    title\n    description\n    breaking\n    risk\n    category\n    country\n    location\n    latitude\n    longitude\n    startDate\n    endDate\n    receivedDate\n  }\n}\n    `;\n\n  @Injectable({\n    providedIn: 'root'\n  })\n  export class GetRiskAlertsGQL extends Apollo.Query<GetRiskAlertsQuery, GetRiskAlertsQueryVariables> {\n    document = GetRiskAlertsDocument;\n    \n    constructor(apollo: Apollo.Apollo) {\n      super(apollo);\n    }\n  }\nexport const GetUserAddressesDocument = gql`\n    query getUserAddresses {\n  getUserAddresses {\n    id\n    description\n    numberOrName\n    street\n    town\n    county\n    postcode\n    countryCode\n    userPrimary\n    officePrimary\n  }\n}\n    `;\n\n  @Injectable({\n    providedIn: 'root'\n  })\n  export class GetUserAddressesGQL extends Apollo.Query<GetUserAddressesQuery, GetUserAddressesQueryVariables> {\n    document = GetUserAddressesDocument;\n    \n    constructor(apollo: Apollo.Apollo) {\n      super(apollo);\n    }\n  }\nexport const GetUserCompanyOfficesDocument = gql`\n    query getUserCompanyOffices {\n  getUserCompanyOffices {\n    id\n    name\n    addresses {\n      id\n      description\n      numberOrName\n      street\n      town\n      county\n      postcode\n      countryCode\n      userPrimary\n      officePrimary\n    }\n  }\n}\n    `;\n\n  @Injectable({\n    providedIn: 'root'\n  })\n  export class GetUserCompanyOfficesGQL extends Apollo.Query<GetUserCompanyOfficesQuery, GetUserCompanyOfficesQueryVariables> {\n    document = GetUserCompanyOfficesDocument;\n    \n    constructor(apollo: Apollo.Apollo) {\n      super(apollo);\n    }\n  }\nexport const GetUserCurrentCarbonAllowanceDocument = gql`\n    query getUserCurrentCarbonAllowance($user: ID) {\n  getUserCurrentCarbonAllowance(user: $user) {\n    id\n    startOfPeriod\n    endOfPeriod\n    remainingCo2\n    totalCo2\n    carbonPolicySource\n    company {\n      id\n      name\n    }\n    office {\n      id\n      name\n    }\n    user {\n      id\n      forename\n      surname\n      email\n    }\n    periodConsumption {\n      id\n      consumed\n      datetime\n    }\n  }\n}\n    `;\n\n  @Injectable({\n    providedIn: 'root'\n  })\n  export class GetUserCurrentCarbonAllowanceGQL extends Apollo.Query<GetUserCurrentCarbonAllowanceQuery, GetUserCurrentCarbonAllowanceQueryVariables> {\n    document = GetUserCurrentCarbonAllowanceDocument;\n    \n    constructor(apollo: Apollo.Apollo) {\n      super(apollo);\n    }\n  }\nexport const GetUserMiAutoSuggestValuesDocument = gql`\n    query getUserMIAutoSuggestValues($mi: ID!, $partialLabel: String!) {\n  getUserMIAutoSuggestValues(mi: $mi, partialLabel: $partialLabel) {\n    id\n    label\n    value\n    default\n    fixed\n    agentOnly\n  }\n}\n    `;\n\n  @Injectable({\n    providedIn: 'root'\n  })\n  export class GetUserMiAutoSuggestValuesGQL extends Apollo.Query<GetUserMiAutoSuggestValuesQuery, GetUserMiAutoSuggestValuesQueryVariables> {\n    document = GetUserMiAutoSuggestValuesDocument;\n    \n    constructor(apollo: Apollo.Apollo) {\n      super(apollo);\n    }\n  }\nexport const GetUserPhoneDocument = gql`\n    query getUserPhone {\n  getUserPhoneNumbers {\n    id\n    description\n    countryCode\n    areaCode\n    number\n    extension\n    type\n    officePrimary\n    userPrimary\n  }\n}\n    `;\n\n  @Injectable({\n    providedIn: 'root'\n  })\n  export class GetUserPhoneGQL extends Apollo.Query<GetUserPhoneQuery, GetUserPhoneQueryVariables> {\n    document = GetUserPhoneDocument;\n    \n    constructor(apollo: Apollo.Apollo) {\n      super(apollo);\n    }\n  }\nexport const GetUserRecentSearchesDocument = gql`\n    query getUserRecentSearches($serviceType: ServiceType) {\n  getUserRecentSearches(serviceType: $serviceType) {\n    id\n    name\n    serviceType\n    searchArgs\n    createdAt\n    updatedAt\n    travelDate\n    travellers {\n      id\n      title\n      forename\n      surname\n      email\n      username\n      dob\n    }\n  }\n}\n    `;\n\n  @Injectable({\n    providedIn: 'root'\n  })\n  export class GetUserRecentSearchesGQL extends Apollo.Query<GetUserRecentSearchesQuery, GetUserRecentSearchesQueryVariables> {\n    document = GetUserRecentSearchesDocument;\n    \n    constructor(apollo: Apollo.Apollo) {\n      super(apollo);\n    }\n  }\nexport const SearchHotelsDocument = gql`\n    query searchHotels($startDate: Date!, $endDate: Date!, $cityName: String, $postOrZipCode: String, $countryCode: String, $latitude: Float, $longitude: Float, $trainStationCode: String, $iata: String, $officeId: Int, $rooms: Int!, $adults: Int!, $children: Int, $currency: String!, $distanceType: DistanceTypes!, $distance: Int!, $maxResults: Int, $hotelName: String, $groupName: String) {\n  searchHotels(startDate: $startDate, endDate: $endDate, cityName: $cityName, postOrZipCode: $postOrZipCode, countryCode: $countryCode, latitude: $latitude, longitude: $longitude, trainStationCode: $trainStationCode, iata: $iata, officeId: $officeId, rooms: $rooms, adults: $adults, children: $children, currency: $currency, distanceType: $distanceType, distance: $distance, maxResults: $maxResults, hotelName: $hotelName, groupName: $groupName) {\n    results {\n      id\n      name\n      imageUrl\n      group\n      location {\n        distance\n        distanceType\n        longitude\n        latitude\n      }\n      address {\n        addressLine1\n        addressLine2\n        addressLine3\n        postOrZipCode\n        countryCode\n        telephone\n        facsimile\n      }\n      transports {\n        type\n        name\n        code\n        distance\n        distanceType\n        longitude\n        latitude\n      }\n      preferred {\n        client\n        consumer\n      }\n      tags {\n        name\n        display\n        type\n        icon\n      }\n      availableRates {\n        hotelId\n        imageUrl\n        rooms {\n          roomId\n          roomType\n          roomDescription\n          rateCode\n          rateDescription\n          total\n          currencyCode\n          currencyConversion {\n            rate\n            localCode\n            localTotal\n            convertedCode\n            convertedTotal\n          }\n          deposit {\n            amount\n            policy\n            required\n          }\n          nights {\n            night\n            rate\n            info\n            date\n          }\n          policies {\n            cancellation\n            deposit\n            disabledAccess\n            general\n            guarantee\n            refundAvailable\n          }\n          tax {\n            included\n            rate\n          }\n          acceptedCards {\n            id\n            name\n          }\n          paymentTypes {\n            type\n            name\n          }\n        }\n        prpn\n        currencyCode\n        isBusy\n        source\n        version\n      }\n      co2PerPassenger\n      co2PerItem\n      source\n      sourceId\n      version\n      tmcPreferred\n      companyPreferred\n      officePreferred\n      tmcPreferredMessage\n      companyPreferredMessage\n      officePreferredMessage\n      unavailable\n      unavailableMessage\n    }\n    errors {\n      service {\n        id\n        type\n        name\n        description\n        detailSchema\n        searchQuerySchema\n      }\n      errorMessage\n      errorCode\n    }\n  }\n}\n    `;\n\n  @Injectable({\n    providedIn: 'root'\n  })\n  export class SearchHotelsGQL extends Apollo.Query<SearchHotelsQuery, SearchHotelsQueryVariables> {\n    document = SearchHotelsDocument;\n    \n    constructor(apollo: Apollo.Apollo) {\n      super(apollo);\n    }\n  }\nexport const GetMultipleHotelsAvailabilityDocument = gql`\n    query getMultipleHotelsAvailability($hotel: [String!]!, $startDate: Date!, $endDate: Date!, $currency: String!, $occupants: Int!, $rooms: Int) {\n  getMultipleHotelsAvailability(hotel: $hotel, startDate: $startDate, endDate: $endDate, currency: $currency, occupants: $occupants, rooms: $rooms) {\n    results {\n      hotelId\n      rooms {\n        roomId\n        roomType\n        roomDescription\n        rateCode\n        rateDescription\n        total\n        currencyCode\n        currencyConversion {\n          rate\n          localCode\n          localTotal\n          convertedCode\n          convertedTotal\n        }\n        deposit {\n          amount\n          policy\n          required\n        }\n        nights {\n          night\n          rate\n          info\n          date\n        }\n        policies {\n          cancellation\n          deposit\n          disabledAccess\n          general\n          guarantee\n          refundAvailable\n        }\n        tax {\n          included\n          rate\n        }\n        acceptedCards {\n          id\n          name\n        }\n        paymentTypes {\n          type\n          name\n        }\n      }\n      prpn\n      currencyCode\n      isBusy\n      source\n      version\n    }\n    errors {\n      ...Errors\n    }\n  }\n}\n    ${ErrorsFragmentDoc}`;\n\n  @Injectable({\n    providedIn: 'root'\n  })\n  export class GetMultipleHotelsAvailabilityGQL extends Apollo.Query<GetMultipleHotelsAvailabilityQuery, GetMultipleHotelsAvailabilityQueryVariables> {\n    document = GetMultipleHotelsAvailabilityDocument;\n    \n    constructor(apollo: Apollo.Apollo) {\n      super(apollo);\n    }\n  }\nexport const IsPostcodeValidDocument = gql`\n    query isPostcodeValid($postcode: String!) {\n  isPostcodeValid(postcode: $postcode)\n}\n    `;\n\n  @Injectable({\n    providedIn: 'root'\n  })\n  export class IsPostcodeValidGQL extends Apollo.Query<IsPostcodeValidQuery, IsPostcodeValidQueryVariables> {\n    document = IsPostcodeValidDocument;\n    \n    constructor(apollo: Apollo.Apollo) {\n      super(apollo);\n    }\n  }\nexport const SearchAirportsDocument = gql`\n    query searchAirports($query: String!, $countryCode: String, $hasLounge: Boolean, $hasParking: Boolean, $hasFastTrack: Boolean) {\n  searchAirports(query: $query, countryCode: $countryCode, hasLounge: $hasLounge, hasParking: $hasParking, hasFastTrack: $hasFastTrack) {\n    iataMatch {\n      id\n      name\n      iata\n      icao\n      terminals\n      locationDetails {\n        ...LOCATION_DETAIL\n      }\n    }\n    generalMatches {\n      id\n      name\n      iata\n      icao\n      terminals\n      locationDetails {\n        ...LOCATION_DETAIL\n      }\n    }\n  }\n}\n    ${Location_DetailFragmentDoc}`;\n\n  @Injectable({\n    providedIn: 'root'\n  })\n  export class SearchAirportsGQL extends Apollo.Query<SearchAirportsQuery, SearchAirportsQueryVariables> {\n    document = SearchAirportsDocument;\n    \n    constructor(apollo: Apollo.Apollo) {\n      super(apollo);\n    }\n  }\nexport const SearchLoungesDocument = gql`\n    query searchLounges($locationCode: String!, $arrivalDatetime: DateTime!, $adults: Int!, $children: Int, $infants: Int, $terminal: String) {\n  searchLounges(locationCode: $locationCode, arrivalDatetime: $arrivalDatetime, adults: $adults, children: $children, infants: $infants, terminal: $terminal) {\n    results {\n      source\n      sourceId\n      name\n      code\n      price\n      currency\n      lounge {\n        code\n        name\n        airport\n        terminal\n        address\n        telephone\n        fax\n        directions\n        introduction\n        logo\n        mobileImage\n        furtherImages\n        adultAge\n        childAge\n        infantAge\n        landside\n        airside\n        facilities\n        openTime\n        closeTime\n        wifi\n        tv\n        snacks\n        phone\n        internet\n        childrenAllowed\n        disabledAccess\n        drinks\n        freeDrinks\n        freeFood\n        smokingPermitted\n        magazines\n        includedDrinks\n        menuFood\n        menuDrinks\n        menuExtras\n        whatsIncludedDrinks\n        whatsIncludedExtras\n        whatsIncludedFood\n        groupInfo\n        checkInInfo\n        dressCode\n        facilitiesInfo\n        foodAndBeverage\n        cancellationInfo\n        amendmentsInfo\n        misc\n      }\n      tmcPreferred\n      companyPreferred\n      officePreferred\n      tmcPreferredMessage\n      companyPreferredMessage\n      officePreferredMessage\n      unavailable\n      unavailableMessage\n      co2PerPassenger\n      co2PerItem\n    }\n    errors {\n      ...Errors\n    }\n  }\n}\n    ${ErrorsFragmentDoc}`;\n\n  @Injectable({\n    providedIn: 'root'\n  })\n  export class SearchLoungesGQL extends Apollo.Query<SearchLoungesQuery, SearchLoungesQueryVariables> {\n    document = SearchLoungesDocument;\n    \n    constructor(apollo: Apollo.Apollo) {\n      super(apollo);\n    }\n  }\nexport const MoveItemToADifferentBasketDocument = gql`\n    mutation moveItemToADifferentBasket($basketItem: ID!, $newBasket: ID!, $withSupplemental: Boolean = false) {\n  moveItemToADifferentBasket(basketItem: $basketItem, newBasket: $newBasket) {\n    ...BasketFields\n  }\n}\n    ${BasketFieldsFragmentDoc}`;\n\n  @Injectable({\n    providedIn: 'root'\n  })\n  export class MoveItemToADifferentBasketGQL extends Apollo.Mutation<MoveItemToADifferentBasketMutation, MoveItemToADifferentBasketMutationVariables> {\n    document = MoveItemToADifferentBasketDocument;\n    \n    constructor(apollo: Apollo.Apollo) {\n      super(apollo);\n    }\n  }\nexport const SearchParkingDocument = gql`\n    query searchParking($arrivalDatetime: DateTime!, $departDatetime: DateTime!, $locationCode: String!, $outFlightNumber: String, $recommended: Boolean, $onAirport: Boolean, $meetAndGreet: Boolean, $parkAndRide: Boolean, $parkAndStroll: Boolean, $carParkedForYou: Boolean, $terminal: String) {\n  searchParking(arrivalDatetime: $arrivalDatetime, departDatetime: $departDatetime, locationCode: $locationCode, outFlightNumber: $outFlightNumber, recommended: $recommended, onAirport: $onAirport, meetAndGreet: $meetAndGreet, parkAndRide: $parkAndRide, parkAndStroll: $parkAndStroll, carParkedForYou: $carParkedForYou, terminal: $terminal) {\n    results {\n      source\n      sourceId\n      carPark {\n        code\n        name\n        airport\n        terminal\n        latitude\n        longitude\n        address\n        distanceToAirport\n        onAirport\n        carParkedForYou\n        meetAndGreet\n        telephone\n        fax\n        directions\n        arrivalProcedure\n        departureProcedure\n        maximumCarSize\n        introduction\n        information\n        transferInformation\n        transferOperatingTimes\n        transferTime\n        logo\n        defaultImage\n        brandImage\n        mobileImage\n        furtherImages\n        misc\n      }\n      requiredInfo\n      price\n      currency\n      misc\n      tmcPreferred\n      companyPreferred\n      officePreferred\n      tmcPreferredMessage\n      companyPreferredMessage\n      officePreferredMessage\n      unavailable\n      unavailableMessage\n      co2PerPassenger\n      co2PerItem\n    }\n    errors {\n      ...Errors\n    }\n  }\n}\n    ${ErrorsFragmentDoc}`;\n\n  @Injectable({\n    providedIn: 'root'\n  })\n  export class SearchParkingGQL extends Apollo.Query<SearchParkingQuery, SearchParkingQueryVariables> {\n    document = SearchParkingDocument;\n    \n    constructor(apollo: Apollo.Apollo) {\n      super(apollo);\n    }\n  }\nexport const SearchRailDocument = gql`\n    query searchRail($countryCode: String!, $journeyType: RailJourneyType!, $class: RailClass, $outboundArrivalDateTime: DateTime, $outboundDepartureDateTime: DateTime, $departureLocationId: ID!, $arrivalLocationId: ID!, $adults: Int!, $children: Int, $returnArrivalDateTime: DateTime, $returnDepartureDateTime: DateTime, $railCardQualifiers: [String!], $viaLocationId: ID, $extraTimeToChange: Boolean, $plusBusOut: RailPlusBusAvail, $plusBusReturn: RailPlusBusAvail) {\n  searchRail(countryCode: $countryCode, journeyType: $journeyType, class: $class, outboundArrivalDateTime: $outboundArrivalDateTime, outboundDepartureDateTime: $outboundDepartureDateTime, departureLocationId: $departureLocationId, arrivalLocationId: $arrivalLocationId, adults: $adults, children: $children, returnArrivalDateTime: $returnArrivalDateTime, returnDepartureDateTime: $returnDepartureDateTime, railCardQualifiers: $railCardQualifiers, viaLocationId: $viaLocationId, extraTimeToChange: $extraTimeToChange, plusBusOut: $plusBusOut, plusBusReturn: $plusBusReturn) {\n    results {\n      source\n      sourceId\n      outbound {\n        identifiers {\n          transactionIdentifier\n          journeyIdentifier\n          provider\n          fareIdentifier\n          direction\n          singleOrReturn\n          bookingRef\n        }\n        travellers {\n          status\n          id\n          dob\n          railcard\n          givenName\n          surname\n          nameTitle\n          contactInfo\n          deliveryEmailAddress\n          fare\n        }\n        co2PerItem\n        from\n        fromCode\n        to\n        toCode\n        co2PerPassenger\n        departDateTime\n        arriveDateTime\n        changes\n        segments {\n          id\n          operator\n          depart\n          departDateTime\n          arrive\n          arriveDateTime\n          reservableStatus\n          seatPreferenceTypes {\n            name\n            allowedValues\n          }\n          seatPreferenceGroup\n          seats {\n            location\n            coach\n            number\n            direction\n            position\n            deck\n            seatType\n            seatSelection\n            facilities\n            note\n          }\n          callingPoints {\n            stationName\n            stationCode\n            arrivalDateTime\n            departureDateTime\n            scheduledPlatform\n            stationClassification\n            stoppingPattern\n          }\n        }\n        providers {\n          providerId\n          name\n          cheapestTicket {\n            identifiers {\n              transactionIdentifier\n              journeyIdentifier\n              provider\n              fareIdentifier\n              direction\n              singleOrReturn\n              bookingRef\n            }\n            type\n            terms {\n              error\n              ticketTypeCode\n              trainOperatingCompanyCode\n              ticketTypeName\n              ticketTypeAltName\n              ticketTypeClass\n              reservationRule\n              journeyType\n              preBookingRequirement\n              generalValidity\n              validOutRule\n              validReturnRule\n              generalDiscount\n              childDiscount\n              railcardDiscount\n              refundCancellationRule\n              changeRule\n              ticketTypeConditionsDescription\n              journeyBreakRule\n              availabilityRule\n              todAvailable\n              kioskAvailable\n              startDate\n              endDate\n              dynamicConditions {\n                name\n                description\n              }\n            }\n            class\n            singleOrReturn\n            price\n            reservableStatus\n            currency\n            route\n            routeCode\n            tickets {\n              price\n              type\n              route\n              segments {\n                id\n                operator\n                depart\n                departDateTime\n                arrive\n                arriveDateTime\n                reservableStatus\n                seatPreferenceGroup\n              }\n              numChildren\n              numAdults\n            }\n            availableSeats\n            ticketQueueList {\n              id\n              name\n              type\n            }\n            accountsList {\n              id\n              reference\n              description\n              isDefault\n              type\n            }\n          }\n          ticketOptions {\n            identifiers {\n              transactionIdentifier\n              journeyIdentifier\n              provider\n              fareIdentifier\n              direction\n              singleOrReturn\n              bookingRef\n              allowedWith {\n                transactionIdentifier\n                journeyIdentifier\n                provider\n                fareIdentifier\n                direction\n                singleOrReturn\n                bookingRef\n              }\n            }\n            type\n            terms {\n              error\n              ticketTypeCode\n              trainOperatingCompanyCode\n              ticketTypeName\n              ticketTypeAltName\n              ticketTypeClass\n              reservationRule\n              journeyType\n              preBookingRequirement\n              generalValidity\n              validOutRule\n              validReturnRule\n              generalDiscount\n              childDiscount\n              railcardDiscount\n              refundCancellationRule\n              changeRule\n              ticketTypeConditionsDescription\n              journeyBreakRule\n              availabilityRule\n              todAvailable\n              kioskAvailable\n              startDate\n              endDate\n            }\n            class\n            singleOrReturn\n            price\n            reservableStatus\n            currency\n            route\n            routeCode\n            tickets {\n              price\n              type\n              route\n              numChildren\n              numAdults\n            }\n            availableSeats\n            ticketQueueList {\n              id\n              name\n              type\n            }\n            accountsList {\n              id\n              reference\n              description\n              isDefault\n              type\n            }\n          }\n          bookedTicket {\n            identifiers {\n              transactionIdentifier\n              journeyIdentifier\n              provider\n              fareIdentifier\n              direction\n              singleOrReturn\n              bookingRef\n            }\n            type\n            terms {\n              error\n              ticketTypeCode\n              trainOperatingCompanyCode\n              ticketTypeName\n              ticketTypeAltName\n              ticketTypeClass\n              reservationRule\n              journeyType\n              preBookingRequirement\n              generalValidity\n              validOutRule\n              validReturnRule\n              generalDiscount\n              childDiscount\n              railcardDiscount\n              refundCancellationRule\n              changeRule\n              ticketTypeConditionsDescription\n              journeyBreakRule\n              availabilityRule\n              todAvailable\n              kioskAvailable\n              startDate\n              endDate\n            }\n            class\n            singleOrReturn\n            price\n            reservableStatus\n            currency\n            route\n            routeCode\n            tickets {\n              price\n              type\n              route\n              numChildren\n              numAdults\n            }\n            ticketQueueList {\n              id\n              name\n              type\n            }\n            accountsList {\n              id\n              reference\n              description\n              isDefault\n              type\n            }\n          }\n        }\n        unsellable\n        ticketExtras {\n          identifiers {\n            type\n            location\n            date\n            journeyId\n            isOrigin\n          }\n          type\n          location\n          date\n          description\n          amount\n          adultAmount\n          childAmount\n          currency\n        }\n        plusBus {\n          originPlusBusNLC\n          originStationNLC\n          destinationPlusBusNLC\n          destinationStationNLC\n        }\n      }\n      return {\n        identifiers {\n          transactionIdentifier\n          journeyIdentifier\n          provider\n          fareIdentifier\n          direction\n          singleOrReturn\n          bookingRef\n        }\n        travellers {\n          status\n          id\n          dob\n          railcard\n          givenName\n          surname\n          nameTitle\n          contactInfo\n          deliveryEmailAddress\n          fare\n        }\n        co2PerItem\n        from\n        fromCode\n        to\n        toCode\n        departDateTime\n        arriveDateTime\n        changes\n        segments {\n          id\n          operator\n          depart\n          departDateTime\n          arrive\n          arriveDateTime\n          reservableStatus\n          seatPreferenceGroup\n          callingPoints {\n            stationName\n            stationCode\n            arrivalDateTime\n            departureDateTime\n            scheduledPlatform\n            stationClassification\n            stoppingPattern\n          }\n        }\n        providers {\n          providerId\n          name\n          cheapestTicket {\n            identifiers {\n              transactionIdentifier\n              journeyIdentifier\n              provider\n              fareIdentifier\n              direction\n              singleOrReturn\n              bookingRef\n            }\n            type\n            terms {\n              error\n              ticketTypeCode\n              trainOperatingCompanyCode\n              ticketTypeName\n              ticketTypeAltName\n              ticketTypeClass\n              reservationRule\n              journeyType\n              preBookingRequirement\n              generalValidity\n              validOutRule\n              validReturnRule\n              generalDiscount\n              childDiscount\n              railcardDiscount\n              refundCancellationRule\n              changeRule\n              ticketTypeConditionsDescription\n              journeyBreakRule\n              availabilityRule\n              todAvailable\n              kioskAvailable\n              startDate\n              endDate\n              dynamicConditions {\n                name\n                description\n              }\n            }\n            class\n            singleOrReturn\n            price\n            reservableStatus\n            currency\n            route\n            routeCode\n            tickets {\n              price\n              type\n              route\n              segments {\n                id\n                operator\n                depart\n                departDateTime\n                arrive\n                arriveDateTime\n                reservableStatus\n                seatPreferenceGroup\n              }\n              numChildren\n              numAdults\n            }\n            availableSeats\n            ticketQueueList {\n              id\n              name\n              type\n            }\n            accountsList {\n              id\n              reference\n              description\n              isDefault\n              type\n            }\n          }\n          ticketOptions {\n            identifiers {\n              transactionIdentifier\n              journeyIdentifier\n              provider\n              fareIdentifier\n              direction\n              singleOrReturn\n              bookingRef\n              allowedWith {\n                transactionIdentifier\n                journeyIdentifier\n                provider\n                fareIdentifier\n                direction\n                singleOrReturn\n                bookingRef\n              }\n            }\n            type\n            terms {\n              error\n              ticketTypeCode\n              trainOperatingCompanyCode\n              ticketTypeName\n              ticketTypeAltName\n              ticketTypeClass\n              reservationRule\n              journeyType\n              preBookingRequirement\n              generalValidity\n              validOutRule\n              validReturnRule\n              generalDiscount\n              childDiscount\n              railcardDiscount\n              refundCancellationRule\n              changeRule\n              ticketTypeConditionsDescription\n              journeyBreakRule\n              availabilityRule\n              todAvailable\n              kioskAvailable\n              startDate\n              endDate\n            }\n            class\n            singleOrReturn\n            price\n            reservableStatus\n            currency\n            route\n            routeCode\n            tickets {\n              price\n              type\n              route\n              numChildren\n              numAdults\n            }\n            availableSeats\n            ticketQueueList {\n              id\n              name\n              type\n            }\n            accountsList {\n              id\n              reference\n              description\n              isDefault\n              type\n            }\n          }\n          bookedTicket {\n            identifiers {\n              transactionIdentifier\n              journeyIdentifier\n              provider\n              fareIdentifier\n              direction\n              singleOrReturn\n              bookingRef\n            }\n            type\n            terms {\n              error\n              ticketTypeCode\n              trainOperatingCompanyCode\n              ticketTypeName\n              ticketTypeAltName\n              ticketTypeClass\n              reservationRule\n              journeyType\n              preBookingRequirement\n              generalValidity\n              validOutRule\n              validReturnRule\n              generalDiscount\n              childDiscount\n              railcardDiscount\n              refundCancellationRule\n              changeRule\n              ticketTypeConditionsDescription\n              journeyBreakRule\n              availabilityRule\n              todAvailable\n              kioskAvailable\n              startDate\n              endDate\n            }\n            class\n            singleOrReturn\n            price\n            reservableStatus\n            currency\n            route\n            routeCode\n            tickets {\n              price\n              type\n              route\n              numChildren\n              numAdults\n            }\n            ticketQueueList {\n              id\n              name\n              type\n            }\n            accountsList {\n              id\n              reference\n              description\n              isDefault\n              type\n            }\n          }\n        }\n        unsellable\n        ticketExtras {\n          type\n          location\n          date\n          description\n          amount\n          adultAmount\n          childAmount\n          currency\n        }\n        plusBus {\n          originPlusBusNLC\n          originStationNLC\n          destinationPlusBusNLC\n          destinationStationNLC\n        }\n      }\n    }\n    errors {\n      ...Errors\n    }\n  }\n}\n    ${ErrorsFragmentDoc}`;\n\n  @Injectable({\n    providedIn: 'root'\n  })\n  export class SearchRailGQL extends Apollo.Query<SearchRailQuery, SearchRailQueryVariables> {\n    document = SearchRailDocument;\n    \n    constructor(apollo: Apollo.Apollo) {\n      super(apollo);\n    }\n  }\nexport const SaveRecentSearchDocument = gql`\n    mutation saveRecentSearch($serviceType: ServiceType!, $searchArgs: JSON!, $travelDate: DateTime!, $travellers: [ID]) {\n  saveRecentSearch(serviceType: $serviceType, searchArgs: $searchArgs, travelDate: $travelDate, travellers: $travellers) {\n    id\n  }\n}\n    `;\n\n  @Injectable({\n    providedIn: 'root'\n  })\n  export class SaveRecentSearchGQL extends Apollo.Mutation<SaveRecentSearchMutation, SaveRecentSearchMutationVariables> {\n    document = SaveRecentSearchDocument;\n    \n    constructor(apollo: Apollo.Apollo) {\n      super(apollo);\n    }\n  }\nexport const SaveUserAddressDocument = gql`\n    mutation saveUserAddress($description: String!, $numberOrName: String, $street: String, $town: String, $county: String, $postcode: String, $countryCode: String, $userPrimary: Boolean) {\n  saveUserAddress(description: $description, numberOrName: $numberOrName, street: $street, town: $town, county: $county, postcode: $postcode, countryCode: $countryCode, userPrimary: $userPrimary) {\n    id\n    description\n    numberOrName\n    street\n    town\n    county\n    postcode\n    countryCode\n    userPrimary\n    officePrimary\n  }\n}\n    `;\n\n  @Injectable({\n    providedIn: 'root'\n  })\n  export class SaveUserAddressGQL extends Apollo.Mutation<SaveUserAddressMutation, SaveUserAddressMutationVariables> {\n    document = SaveUserAddressDocument;\n    \n    constructor(apollo: Apollo.Apollo) {\n      super(apollo);\n    }\n  }\nexport const SearchAirlinesDocument = gql`\n    query searchAirlines($query: String!) {\n  searchAirlines(query: $query) {\n    iataMatch {\n      id\n      name\n      iata\n      icao\n      alias\n      callsign\n      active\n      continent\n      country\n      countryCode\n      bannerImage\n      logoImage\n    }\n    generalMatches {\n      id\n      name\n      iata\n      icao\n      alias\n      callsign\n      active\n      continent\n      country\n      countryCode\n      bannerImage\n      logoImage\n    }\n  }\n}\n    `;\n\n  @Injectable({\n    providedIn: 'root'\n  })\n  export class SearchAirlinesGQL extends Apollo.Query<SearchAirlinesQuery, SearchAirlinesQueryVariables> {\n    document = SearchAirlinesDocument;\n    \n    constructor(apollo: Apollo.Apollo) {\n      super(apollo);\n    }\n  }\nexport const SearchCitiesDocument = gql`\n    query searchCities($query: String!, $countryCode: String) {\n  searchCities(query: $query, countryCode: $countryCode) {\n    id\n    name\n    country\n    countryCode\n    coordinates {\n      latitude\n      longitude\n      altitude\n    }\n    continentName\n  }\n}\n    `;\n\n  @Injectable({\n    providedIn: 'root'\n  })\n  export class SearchCitiesGQL extends Apollo.Query<SearchCitiesQuery, SearchCitiesQueryVariables> {\n    document = SearchCitiesDocument;\n    \n    constructor(apollo: Apollo.Apollo) {\n      super(apollo);\n    }\n  }\nexport const SearchConfermaCitiesDocument = gql`\n    query searchConfermaCities($cityName: String!, $countryCode: String!) {\n  searchConfermaCities(cityName: $cityName, countryCode: $countryCode) {\n    foundExact\n    suggestions {\n      name\n      countryCode\n      latitude\n      longitude\n    }\n  }\n}\n    `;\n\n  @Injectable({\n    providedIn: 'root'\n  })\n  export class SearchConfermaCitiesGQL extends Apollo.Query<SearchConfermaCitiesQuery, SearchConfermaCitiesQueryVariables> {\n    document = SearchConfermaCitiesDocument;\n    \n    constructor(apollo: Apollo.Apollo) {\n      super(apollo);\n    }\n  }\nexport const SearchEurostarDocument = gql`\n    query searchEurostar($passengers: [FlightPassengerObject!]!, $originAirport: String, $destinationAirport: String, $multiDestination: [DestinationEntry], $outboundDate: Date, $outboundDepartureTimeWindow: String, $outboundArrivalTimeWindow: String, $outboundCabinClass: [FlightCabinClass], $returnTrip: Boolean!, $returnDate: Date, $returnDepartureTimeWindow: String, $returnArrivalTimeWindow: String, $returnCabinClass: [FlightCabinClass], $fareType: FareType!, $requireFreeBag: Boolean, $maxConnections: Int, $preferredCarriers: [String], $includeNearbyAirports: Boolean, $asSingles: Boolean) {\n  searchEurostar(passengers: $passengers, originAirport: $originAirport, destinationAirport: $destinationAirport, multiDestination: $multiDestination, outboundDate: $outboundDate, outboundDepartureTimeWindow: $outboundDepartureTimeWindow, outboundArrivalTimeWindow: $outboundArrivalTimeWindow, outboundCabinClass: $outboundCabinClass, returnTrip: $returnTrip, returnDate: $returnDate, returnDepartureTimeWindow: $returnDepartureTimeWindow, returnArrivalTimeWindow: $returnArrivalTimeWindow, returnCabinClass: $returnCabinClass, fareType: $fareType, requireFreeBag: $requireFreeBag, maxConnections: $maxConnections, preferredCarriers: $preferredCarriers, includeNearbyAirports: $includeNearbyAirports, asSingles: $asSingles) {\n    results {\n      journeys {\n        uid\n        passengerCount\n        outboundFlights {\n          fareInfo {\n            title\n            type\n            code\n            supplierCode\n          }\n          originAirport\n          originTerminal\n          originAirportName\n          originAirportDetail {\n            iata\n            icao\n            latitude\n            longitude\n            altitude\n            state\n            city\n            road\n            popularity\n            area\n            location\n            offset\n            airportName\n            countryName\n            countryCode\n            postcode\n          }\n          destinationAirport\n          destinationTerminal\n          destinationAirportName\n          destinationAirportDetail {\n            iata\n            icao\n            latitude\n            longitude\n            altitude\n            state\n            city\n            road\n            popularity\n            area\n            location\n            offset\n            airportName\n            countryName\n            countryCode\n            postcode\n          }\n          dateTimeDeparting\n          dateTimeDepartingUTC\n          dateTimeArriving\n          dateTimeArrivingUTC\n          marketingCarrier\n          marketingCarrierName\n          marketingCarrierDetail {\n            name\n            alias\n            callsign\n            iata\n            icao\n            logo\n            banner\n            popularity\n          }\n          marketingFlightNumber\n          operatingCarrier\n          operatingCarrierName\n          operatingCarrierDetail {\n            name\n            alias\n            callsign\n            iata\n            icao\n            logo\n            banner\n            popularity\n          }\n          operatingFlightNumber\n          equipmentCode\n          equipmentName\n          totalDuration\n          cabinClass\n          marketingNames\n          fareConditions {\n            cancellation {\n              name\n              type\n              currency\n              amount\n              remark\n              changeFeeInd\n              cancelFeeInd\n              refundableInd\n            }\n            change {\n              name\n              type\n              currency\n              amount\n              remark\n              changeFeeInd\n              cancelFeeInd\n              refundableInd\n            }\n            noShow {\n              name\n              type\n              currency\n              amount\n              remark\n              changeFeeInd\n              cancelFeeInd\n              refundableInd\n            }\n            upgrade {\n              name\n              type\n              currency\n              amount\n              remark\n              changeFeeInd\n              cancelFeeInd\n              refundableInd\n            }\n            other {\n              name\n              type\n              currency\n              amount\n              remark\n              changeFeeInd\n              cancelFeeInd\n              refundableInd\n            }\n          }\n          vendorCode\n          stops\n          bookingCode\n          marriageGroup\n          fareBasisCode\n          additional\n        }\n        inboundFlights {\n          fareInfo {\n            title\n            type\n            code\n            supplierCode\n          }\n          originAirport\n          originTerminal\n          originAirportName\n          originAirportDetail {\n            iata\n            icao\n            latitude\n            longitude\n            altitude\n            state\n            city\n            road\n            popularity\n            area\n            location\n            offset\n            airportName\n            countryName\n            countryCode\n            postcode\n          }\n          destinationAirport\n          destinationTerminal\n          destinationAirportName\n          destinationAirportDetail {\n            iata\n            icao\n            latitude\n            longitude\n            altitude\n            state\n            city\n            road\n            popularity\n            area\n            location\n            offset\n            airportName\n            countryName\n            countryCode\n            postcode\n          }\n          dateTimeDeparting\n          dateTimeDepartingUTC\n          dateTimeArriving\n          dateTimeArrivingUTC\n          marketingCarrier\n          marketingCarrierName\n          marketingCarrierDetail {\n            name\n            alias\n            callsign\n            iata\n            icao\n            logo\n            banner\n            popularity\n          }\n          marketingFlightNumber\n          operatingCarrier\n          operatingCarrierName\n          operatingCarrierDetail {\n            name\n            alias\n            callsign\n            iata\n            icao\n            logo\n            banner\n            popularity\n          }\n          operatingFlightNumber\n          equipmentCode\n          equipmentName\n          totalDuration\n          cabinClass\n          marketingNames\n          fareConditions {\n            cancellation {\n              name\n              type\n              currency\n              amount\n              remark\n              changeFeeInd\n              cancelFeeInd\n              refundableInd\n            }\n            change {\n              name\n              type\n              currency\n              amount\n              remark\n              changeFeeInd\n              cancelFeeInd\n              refundableInd\n            }\n            noShow {\n              name\n              type\n              currency\n              amount\n              remark\n              changeFeeInd\n              cancelFeeInd\n              refundableInd\n            }\n            upgrade {\n              name\n              type\n              currency\n              amount\n              remark\n              changeFeeInd\n              cancelFeeInd\n              refundableInd\n            }\n            other {\n              name\n              type\n              currency\n              amount\n              remark\n              changeFeeInd\n              cancelFeeInd\n              refundableInd\n            }\n          }\n          vendorCode\n          stops\n          bookingCode\n          marriageGroup\n          fareBasisCode\n          additional\n        }\n        outboundTotalDuration\n        outboundCarbonEmissions {\n          amount\n          unit\n        }\n        inboundTotalDuration\n        inboundCarbonEmissions {\n          amount\n          unit\n        }\n        taxes {\n          description\n          amount\n          currency\n        }\n        discounts {\n          description\n          amount\n          currency\n        }\n        total {\n          price\n          tax\n          discount\n          currency\n        }\n        fareConditions {\n          cancellation {\n            name\n            type\n            currency\n            amount\n            remark\n            changeFeeInd\n            cancelFeeInd\n            refundableInd\n          }\n          change {\n            name\n            type\n            currency\n            amount\n            remark\n            changeFeeInd\n            cancelFeeInd\n            refundableInd\n          }\n          noShow {\n            name\n            type\n            currency\n            amount\n            remark\n            changeFeeInd\n            cancelFeeInd\n            refundableInd\n          }\n          upgrade {\n            name\n            type\n            currency\n            amount\n            remark\n            changeFeeInd\n            cancelFeeInd\n            refundableInd\n          }\n          other {\n            name\n            type\n            currency\n            amount\n            remark\n            changeFeeInd\n            cancelFeeInd\n            refundableInd\n          }\n        }\n        baggageAllowance {\n          type\n          qty\n          maxKG\n          maxLBS\n        }\n        additional\n        source\n        sourceId\n        version\n        tmcPreferred\n        companyPreferred\n        officePreferred\n        tmcPreferredMessage\n        companyPreferredMessage\n        officePreferredMessage\n        unavailable\n        unavailableMessage\n        co2PerItem\n        co2PerPassenger\n      }\n      multi {\n        order\n        origin\n        destination\n        results {\n          uid\n          passengerCount\n          outboundFlights {\n            fareInfo {\n              title\n              type\n              code\n              supplierCode\n            }\n            originAirport\n            originTerminal\n            originAirportName\n            originAirportDetail {\n              iata\n              icao\n              latitude\n              longitude\n              altitude\n              state\n              city\n              road\n              popularity\n              area\n              location\n              offset\n              airportName\n              countryName\n              countryCode\n              postcode\n            }\n            destinationAirport\n            destinationTerminal\n            destinationAirportName\n            destinationAirportDetail {\n              iata\n              icao\n              latitude\n              longitude\n              altitude\n              state\n              city\n              road\n              popularity\n              area\n              location\n              offset\n              airportName\n              countryName\n              countryCode\n              postcode\n            }\n            dateTimeDeparting\n            dateTimeDepartingUTC\n            dateTimeArriving\n            dateTimeArrivingUTC\n            marketingCarrier\n            marketingCarrierName\n            marketingCarrierDetail {\n              name\n              alias\n              callsign\n              iata\n              icao\n              logo\n              banner\n              popularity\n            }\n            marketingFlightNumber\n            operatingCarrier\n            operatingCarrierName\n            operatingCarrierDetail {\n              name\n              alias\n              callsign\n              iata\n              icao\n              logo\n              banner\n              popularity\n            }\n            operatingFlightNumber\n            equipmentCode\n            equipmentName\n            totalDuration\n            cabinClass\n            marketingNames\n            fareConditions {\n              cancellation {\n                name\n                type\n                currency\n                amount\n                remark\n                changeFeeInd\n                cancelFeeInd\n                refundableInd\n              }\n              change {\n                name\n                type\n                currency\n                amount\n                remark\n                changeFeeInd\n                cancelFeeInd\n                refundableInd\n              }\n              noShow {\n                name\n                type\n                currency\n                amount\n                remark\n                changeFeeInd\n                cancelFeeInd\n                refundableInd\n              }\n              upgrade {\n                name\n                type\n                currency\n                amount\n                remark\n                changeFeeInd\n                cancelFeeInd\n                refundableInd\n              }\n              other {\n                name\n                type\n                currency\n                amount\n                remark\n                changeFeeInd\n                cancelFeeInd\n                refundableInd\n              }\n            }\n            vendorCode\n            stops\n            bookingCode\n            marriageGroup\n            fareBasisCode\n            additional\n          }\n          inboundFlights {\n            fareInfo {\n              title\n              type\n              code\n              supplierCode\n            }\n            originAirport\n            originTerminal\n            originAirportName\n            originAirportDetail {\n              iata\n              icao\n              latitude\n              longitude\n              altitude\n              state\n              city\n              road\n              popularity\n              area\n              location\n              offset\n              airportName\n              countryName\n              countryCode\n              postcode\n            }\n            destinationAirport\n            destinationTerminal\n            destinationAirportName\n            destinationAirportDetail {\n              iata\n              icao\n              latitude\n              longitude\n              altitude\n              state\n              city\n              road\n              popularity\n              area\n              location\n              offset\n              airportName\n              countryName\n              countryCode\n              postcode\n            }\n            dateTimeDeparting\n            dateTimeDepartingUTC\n            dateTimeArriving\n            dateTimeArrivingUTC\n            marketingCarrier\n            marketingCarrierName\n            marketingCarrierDetail {\n              name\n              alias\n              callsign\n              iata\n              icao\n              logo\n              banner\n              popularity\n            }\n            marketingFlightNumber\n            operatingCarrier\n            operatingCarrierName\n            operatingCarrierDetail {\n              name\n              alias\n              callsign\n              iata\n              icao\n              logo\n              banner\n              popularity\n            }\n            operatingFlightNumber\n            equipmentCode\n            equipmentName\n            totalDuration\n            cabinClass\n            marketingNames\n            fareConditions {\n              cancellation {\n                name\n                type\n                currency\n                amount\n                remark\n                changeFeeInd\n                cancelFeeInd\n                refundableInd\n              }\n              change {\n                name\n                type\n                currency\n                amount\n                remark\n                changeFeeInd\n                cancelFeeInd\n                refundableInd\n              }\n              noShow {\n                name\n                type\n                currency\n                amount\n                remark\n                changeFeeInd\n                cancelFeeInd\n                refundableInd\n              }\n              upgrade {\n                name\n                type\n                currency\n                amount\n                remark\n                changeFeeInd\n                cancelFeeInd\n                refundableInd\n              }\n              other {\n                name\n                type\n                currency\n                amount\n                remark\n                changeFeeInd\n                cancelFeeInd\n                refundableInd\n              }\n            }\n            vendorCode\n            stops\n            bookingCode\n            marriageGroup\n            fareBasisCode\n            additional\n          }\n          outboundTotalDuration\n          outboundCarbonEmissions {\n            amount\n            unit\n          }\n          inboundTotalDuration\n          inboundCarbonEmissions {\n            amount\n            unit\n          }\n          taxes {\n            description\n            amount\n            currency\n          }\n          discounts {\n            description\n            amount\n            currency\n          }\n          total {\n            price\n            tax\n            discount\n            currency\n          }\n          fareConditions {\n            cancellation {\n              name\n              type\n              currency\n              amount\n              remark\n              changeFeeInd\n              cancelFeeInd\n              refundableInd\n            }\n            change {\n              name\n              type\n              currency\n              amount\n              remark\n              changeFeeInd\n              cancelFeeInd\n              refundableInd\n            }\n            noShow {\n              name\n              type\n              currency\n              amount\n              remark\n              changeFeeInd\n              cancelFeeInd\n              refundableInd\n            }\n            upgrade {\n              name\n              type\n              currency\n              amount\n              remark\n              changeFeeInd\n              cancelFeeInd\n              refundableInd\n            }\n            other {\n              name\n              type\n              currency\n              amount\n              remark\n              changeFeeInd\n              cancelFeeInd\n              refundableInd\n            }\n          }\n          baggageAllowance {\n            type\n            qty\n            maxKG\n            maxLBS\n          }\n          additional\n          source\n          sourceId\n          version\n          tmcPreferred\n          companyPreferred\n          officePreferred\n          tmcPreferredMessage\n          companyPreferredMessage\n          officePreferredMessage\n          unavailable\n          unavailableMessage\n          co2PerItem\n          co2PerPassenger\n        }\n        minPrice\n        maxPrice\n      }\n      grouped {\n        referenceID\n        flightID\n        boundIndicator\n        minPrice\n        maxPrice\n        flights {\n          LiteEconomy\n          EconomyRestricted\n          EconomyNoBags\n          Economy\n          PremiumEconomy\n          Business\n          PremiumBusiness\n          First\n          PremiumFirst\n        }\n      }\n    }\n    errors {\n      ...Errors\n    }\n  }\n}\n    ${ErrorsFragmentDoc}`;\n\n  @Injectable({\n    providedIn: 'root'\n  })\n  export class SearchEurostarGQL extends Apollo.Query<SearchEurostarQuery, SearchEurostarQueryVariables> {\n    document = SearchEurostarDocument;\n    \n    constructor(apollo: Apollo.Apollo) {\n      super(apollo);\n    }\n  }\nexport const SearchHotelChainsDocument = gql`\n    query searchHotelChains($query: String!) {\n  searchHotelChains(query: $query)\n}\n    `;\n\n  @Injectable({\n    providedIn: 'root'\n  })\n  export class SearchHotelChainsGQL extends Apollo.Query<SearchHotelChainsQuery, SearchHotelChainsQueryVariables> {\n    document = SearchHotelChainsDocument;\n    \n    constructor(apollo: Apollo.Apollo) {\n      super(apollo);\n    }\n  }\nexport const SearchIrlDocument = gql`\n    query searchIRL($supplier: IRLSupplier!, $countryCode: String!, $journeyType: IRLJourneyType!, $class: IRLClass, $outboundDepartureDateTime: DateTime!, $departureLocationId: ID!, $arrivalLocationId: ID!, $adults: Int!, $children: Int, $returnDepartureDateTime: DateTime) {\n  searchIRL(supplier: $supplier, countryCode: $countryCode, journeyType: $journeyType, class: $class, outboundDepartureDateTime: $outboundDepartureDateTime, departureLocationId: $departureLocationId, arrivalLocationId: $arrivalLocationId, adults: $adults, children: $children, returnDepartureDateTime: $returnDepartureDateTime) {\n    results {\n      source\n      sourceId\n      outbound {\n        identifiers {\n          transactionIdentifier\n          signature\n          journeyIdentifier\n          provider\n          fareIdentifier\n          direction\n          singleOrReturn\n          bookingRef\n        }\n        travellers {\n          status\n          id\n          dob\n          railcard\n          givenName\n          surname\n          nameTitle\n          contactInfo\n          deliveryEmailAddress\n          fare\n        }\n        from\n        fromCode\n        to\n        toCode\n        departDateTime\n        arriveDateTime\n        changes\n        segments {\n          id\n          operator\n          depart\n          departDateTime\n          arrive\n          arriveDateTime\n          reservableStatus\n          seatPreferenceTypes {\n            name\n            allowedValues\n          }\n          seatPreferenceGroup\n          seats {\n            location\n            coach\n            number\n            direction\n            position\n            deck\n            seatType\n            seatSelection\n            facilities\n            note\n          }\n        }\n        providers {\n          providerId\n          name\n          cheapestTicket {\n            identifiers {\n              transactionIdentifier\n              signature\n              journeyIdentifier\n              provider\n              fareIdentifier\n              direction\n              singleOrReturn\n              bookingRef\n            }\n            type\n            class\n            singleOrReturn\n            price\n            reservableStatus\n            currency\n            route\n            routeCode\n            tickets {\n              price\n              type\n              route\n              segments {\n                id\n                operator\n                depart\n                departDateTime\n                arrive\n                arriveDateTime\n                reservableStatus\n                seatPreferenceTypes {\n                  name\n                  allowedValues\n                }\n                seatPreferenceGroup\n                seats {\n                  location\n                  coach\n                  number\n                  direction\n                  position\n                  deck\n                  seatType\n                  seatSelection\n                  facilities\n                  note\n                }\n              }\n              numChildren\n              numAdults\n            }\n          }\n          ticketOptions {\n            identifiers {\n              transactionIdentifier\n              signature\n              journeyIdentifier\n              provider\n              fareIdentifier\n              direction\n              singleOrReturn\n              bookingRef\n            }\n            type\n            class\n            singleOrReturn\n            price\n            reservableStatus\n            currency\n            route\n            routeCode\n            tickets {\n              price\n              type\n              route\n              segments {\n                id\n                operator\n                depart\n                departDateTime\n                arrive\n                arriveDateTime\n                reservableStatus\n                seatPreferenceTypes {\n                  name\n                  allowedValues\n                }\n                seatPreferenceGroup\n                seats {\n                  location\n                  coach\n                  number\n                  direction\n                  position\n                  deck\n                  seatType\n                  seatSelection\n                  facilities\n                  note\n                }\n              }\n              numChildren\n              numAdults\n            }\n          }\n          bookedTicket {\n            identifiers {\n              transactionIdentifier\n              signature\n              journeyIdentifier\n              provider\n              fareIdentifier\n              direction\n              singleOrReturn\n              bookingRef\n            }\n            type\n            class\n            singleOrReturn\n            price\n            reservableStatus\n            currency\n            route\n            routeCode\n            tickets {\n              price\n              type\n              route\n              segments {\n                id\n                operator\n                depart\n                departDateTime\n                arrive\n                arriveDateTime\n                reservableStatus\n                seatPreferenceTypes {\n                  name\n                  allowedValues\n                }\n                seatPreferenceGroup\n                seats {\n                  location\n                  coach\n                  number\n                  direction\n                  position\n                  deck\n                  seatType\n                  seatSelection\n                  facilities\n                  note\n                }\n              }\n              numChildren\n              numAdults\n            }\n          }\n        }\n        unsellable\n        ticketExtras {\n          identifiers {\n            type\n            location\n            date\n            journeyId\n            isOrigin\n          }\n          type\n          location\n          date\n          description\n          amount\n          adultAmount\n          childAmount\n          currency\n        }\n        plusBus {\n          originPlusBusNLC\n          originStationNLC\n          destinationPlusBusNLC\n          destinationStationNLC\n        }\n      }\n      return {\n        identifiers {\n          transactionIdentifier\n          signature\n          journeyIdentifier\n          provider\n          fareIdentifier\n          direction\n          singleOrReturn\n          bookingRef\n        }\n        travellers {\n          status\n          id\n          dob\n          railcard\n          givenName\n          surname\n          nameTitle\n          contactInfo\n          deliveryEmailAddress\n          fare\n        }\n        from\n        fromCode\n        to\n        toCode\n        departDateTime\n        arriveDateTime\n        changes\n        segments {\n          id\n          operator\n          depart\n          departDateTime\n          arrive\n          arriveDateTime\n          reservableStatus\n          seatPreferenceTypes {\n            name\n            allowedValues\n          }\n          seatPreferenceGroup\n          seats {\n            location\n            coach\n            number\n            direction\n            position\n            deck\n            seatType\n            seatSelection\n            facilities\n            note\n          }\n        }\n        providers {\n          providerId\n          name\n          cheapestTicket {\n            identifiers {\n              transactionIdentifier\n              signature\n              journeyIdentifier\n              provider\n              fareIdentifier\n              direction\n              singleOrReturn\n              bookingRef\n            }\n            type\n            class\n            singleOrReturn\n            price\n            reservableStatus\n            currency\n            route\n            routeCode\n            tickets {\n              price\n              type\n              route\n              segments {\n                id\n                operator\n                depart\n                departDateTime\n                arrive\n                arriveDateTime\n                reservableStatus\n                seatPreferenceTypes {\n                  name\n                  allowedValues\n                }\n                seatPreferenceGroup\n                seats {\n                  location\n                  coach\n                  number\n                  direction\n                  position\n                  deck\n                  seatType\n                  seatSelection\n                  facilities\n                  note\n                }\n              }\n              numChildren\n              numAdults\n            }\n          }\n          ticketOptions {\n            identifiers {\n              transactionIdentifier\n              signature\n              journeyIdentifier\n              provider\n              fareIdentifier\n              direction\n              singleOrReturn\n              bookingRef\n            }\n            type\n            class\n            singleOrReturn\n            price\n            reservableStatus\n            currency\n            route\n            routeCode\n            tickets {\n              price\n              type\n              route\n              segments {\n                id\n                operator\n                depart\n                departDateTime\n                arrive\n                arriveDateTime\n                reservableStatus\n                seatPreferenceTypes {\n                  name\n                  allowedValues\n                }\n                seatPreferenceGroup\n                seats {\n                  location\n                  coach\n                  number\n                  direction\n                  position\n                  deck\n                  seatType\n                  seatSelection\n                  facilities\n                  note\n                }\n              }\n              numChildren\n              numAdults\n            }\n          }\n          bookedTicket {\n            identifiers {\n              transactionIdentifier\n              signature\n              journeyIdentifier\n              provider\n              fareIdentifier\n              direction\n              singleOrReturn\n              bookingRef\n            }\n            type\n            class\n            singleOrReturn\n            price\n            reservableStatus\n            currency\n            route\n            routeCode\n            tickets {\n              price\n              type\n              route\n              segments {\n                id\n                operator\n                depart\n                departDateTime\n                arrive\n                arriveDateTime\n                reservableStatus\n                seatPreferenceTypes {\n                  name\n                  allowedValues\n                }\n                seatPreferenceGroup\n                seats {\n                  location\n                  coach\n                  number\n                  direction\n                  position\n                  deck\n                  seatType\n                  seatSelection\n                  facilities\n                  note\n                }\n              }\n              numChildren\n              numAdults\n            }\n          }\n        }\n        unsellable\n        ticketExtras {\n          identifiers {\n            type\n            location\n            date\n            journeyId\n            isOrigin\n          }\n          type\n          location\n          date\n          description\n          amount\n          adultAmount\n          childAmount\n          currency\n        }\n        plusBus {\n          originPlusBusNLC\n          originStationNLC\n          destinationPlusBusNLC\n          destinationStationNLC\n        }\n      }\n    }\n    errors {\n      ...Errors\n    }\n  }\n}\n    ${ErrorsFragmentDoc}`;\n\n  @Injectable({\n    providedIn: 'root'\n  })\n  export class SearchIrlGQL extends Apollo.Query<SearchIrlQuery, SearchIrlQueryVariables> {\n    document = SearchIrlDocument;\n    \n    constructor(apollo: Apollo.Apollo) {\n      super(apollo);\n    }\n  }\nexport const SearchIrlSupplierStationsDocument = gql`\n    query searchIRLSupplierStations($query: String!, $supplier: IRLSupplier) {\n  searchIRLSupplierStations(query: $query, supplier: $supplier) {\n    id\n    name\n    supplier\n    stationCode\n    nlcCode\n    trainlineCode\n    trainlineUniqueCode\n    locationDetails {\n      continent\n      country\n      countryCode\n      state\n      city\n      coordinates {\n        latitude\n        longitude\n        altitude\n      }\n      postcode\n      road\n      gridReference\n      northing\n      easting\n    }\n  }\n}\n    `;\n\n  @Injectable({\n    providedIn: 'root'\n  })\n  export class SearchIrlSupplierStationsGQL extends Apollo.Query<SearchIrlSupplierStationsQuery, SearchIrlSupplierStationsQueryVariables> {\n    document = SearchIrlSupplierStationsDocument;\n    \n    constructor(apollo: Apollo.Apollo) {\n      super(apollo);\n    }\n  }\nexport const SearchPostcodesDocument = gql`\n    query searchPostcodes($postcode: String!) {\n  getPostcodeDetails(postcode: $postcode) {\n    postcode\n    latitude\n    longitude\n  }\n}\n    `;\n\n  @Injectable({\n    providedIn: 'root'\n  })\n  export class SearchPostcodesGQL extends Apollo.Query<SearchPostcodesQuery, SearchPostcodesQueryVariables> {\n    document = SearchPostcodesDocument;\n    \n    constructor(apollo: Apollo.Apollo) {\n      super(apollo);\n    }\n  }\nexport const SearchRailStationsDocument = gql`\n    query searchRailStations($query: String!, $countryCode: String) {\n  searchRailStations(query: $query, countryCode: $countryCode) {\n    id\n    name\n    stationCode\n    nlcCode\n    trainlineCode\n    trainlineUniqueCode\n    locationDetails {\n      continent\n      country\n      countryCode\n      state\n      city\n      coordinates {\n        latitude\n        longitude\n        altitude\n      }\n      postcode\n      road\n      gridReference\n      northing\n      easting\n    }\n  }\n}\n    `;\n\n  @Injectable({\n    providedIn: 'root'\n  })\n  export class SearchRailStationsGQL extends Apollo.Query<SearchRailStationsQuery, SearchRailStationsQueryVariables> {\n    document = SearchRailStationsDocument;\n    \n    constructor(apollo: Apollo.Apollo) {\n      super(apollo);\n    }\n  }\nexport const SearchUserAddressDocument = gql`\n    query searchUserAddress {\n  getUserAddresses {\n    id\n    description\n    numberOrName\n    street\n    town\n    county\n    postcode\n    countryCode\n    userPrimary\n    officePrimary\n  }\n}\n    `;\n\n  @Injectable({\n    providedIn: 'root'\n  })\n  export class SearchUserAddressGQL extends Apollo.Query<SearchUserAddressQuery, SearchUserAddressQueryVariables> {\n    document = SearchUserAddressDocument;\n    \n    constructor(apollo: Apollo.Apollo) {\n      super(apollo);\n    }\n  }\nexport const SetBasketItemMiGroupDocument = gql`\n    mutation setBasketItemMIGroup($basketItem: ID!, $group: String, $withSupplemental: Boolean = false) {\n  setBasketItemMIGroup(basketItem: $basketItem, group: $group) {\n    ...BasketFields\n  }\n}\n    ${BasketFieldsFragmentDoc}`;\n\n  @Injectable({\n    providedIn: 'root'\n  })\n  export class SetBasketItemMiGroupGQL extends Apollo.Mutation<SetBasketItemMiGroupMutation, SetBasketItemMiGroupMutationVariables> {\n    document = SetBasketItemMiGroupDocument;\n    \n    constructor(apollo: Apollo.Apollo) {\n      super(apollo);\n    }\n  }\nexport const SetBasketItemLeadPassengerDocument = gql`\n    mutation setBasketItemLeadPassenger($id: ID!, $user: ID!, $withSupplemental: Boolean!) {\n  setBasketItemLeadPassenger(id: $id, user: $user) {\n    ...BasketFields\n  }\n}\n    ${BasketFieldsFragmentDoc}`;\n\n  @Injectable({\n    providedIn: 'root'\n  })\n  export class SetBasketItemLeadPassengerGQL extends Apollo.Mutation<SetBasketItemLeadPassengerMutation, SetBasketItemLeadPassengerMutationVariables> {\n    document = SetBasketItemLeadPassengerDocument;\n    \n    constructor(apollo: Apollo.Apollo) {\n      super(apollo);\n    }\n  }\nexport const SetBasketItemMiValueDocument = gql`\n    mutation setBasketItemMIValue($mi: ID!, $miValue: ID, $miFreeValue: String, $user: ID, $withSupplemental: Boolean = false) {\n  setBasketItemMIValue(mi: $mi, miValue: $miValue, miFreeValue: $miFreeValue, user: $user) {\n    ...BasketFields\n  }\n}\n    ${BasketFieldsFragmentDoc}`;\n\n  @Injectable({\n    providedIn: 'root'\n  })\n  export class SetBasketItemMiValueGQL extends Apollo.Mutation<SetBasketItemMiValueMutation, SetBasketItemMiValueMutationVariables> {\n    document = SetBasketItemMiValueDocument;\n    \n    constructor(apollo: Apollo.Apollo) {\n      super(apollo);\n    }\n  }\nexport const SetBasketItemPaymentMethodDocument = gql`\n    mutation setBasketItemPaymentMethod($basketItem: ID!, $paymentMethod: ID!, $withSupplemental: Boolean = false) {\n  setBasketItemPaymentMethod(basketItem: $basketItem, paymentMethod: $paymentMethod) {\n    ...BasketFields\n  }\n}\n    ${BasketFieldsFragmentDoc}`;\n\n  @Injectable({\n    providedIn: 'root'\n  })\n  export class SetBasketItemPaymentMethodGQL extends Apollo.Mutation<SetBasketItemPaymentMethodMutation, SetBasketItemPaymentMethodMutationVariables> {\n    document = SetBasketItemPaymentMethodDocument;\n    \n    constructor(apollo: Apollo.Apollo) {\n      super(apollo);\n    }\n  }\nexport const UpdateBasketNotesDocument = gql`\n    mutation updateBasketNotes($id: ID, $reference: String, $notes: String!, $withSupplemental: Boolean = false) {\n  updateBasketNotes(id: $id, reference: $reference, notes: $notes) {\n    ...BasketFields\n  }\n}\n    ${BasketFieldsFragmentDoc}`;\n\n  @Injectable({\n    providedIn: 'root'\n  })\n  export class UpdateBasketNotesGQL extends Apollo.Mutation<UpdateBasketNotesMutation, UpdateBasketNotesMutationVariables> {\n    document = UpdateBasketNotesDocument;\n    \n    constructor(apollo: Apollo.Apollo) {\n      super(apollo);\n    }\n  }\nexport const UpdateBasketTitleDocument = gql`\n    mutation updateBasketTitle($id: ID, $reference: String, $newTitle: String!, $withSupplemental: Boolean = false) {\n  updateBasketTitle(id: $id, reference: $reference, newTitle: $newTitle) {\n    ...BasketFields\n  }\n}\n    ${BasketFieldsFragmentDoc}`;\n\n  @Injectable({\n    providedIn: 'root'\n  })\n  export class UpdateBasketTitleGQL extends Apollo.Mutation<UpdateBasketTitleMutation, UpdateBasketTitleMutationVariables> {\n    document = UpdateBasketTitleDocument;\n    \n    constructor(apollo: Apollo.Apollo) {\n      super(apollo);\n    }\n  }\nexport const GetUserServicesDocument = gql`\n    query getUserServices {\n  getUserServices {\n    id\n    cancellable\n    amendable\n    type\n    name\n    description\n    detailSchema\n    searchQuerySchema\n  }\n}\n    `;\n\n  @Injectable({\n    providedIn: 'root'\n  })\n  export class GetUserServicesGQL extends Apollo.Query<GetUserServicesQuery, GetUserServicesQueryVariables> {\n    document = GetUserServicesDocument;\n    \n    constructor(apollo: Apollo.Apollo) {\n      super(apollo);\n    }\n  }\nexport const GetUserUiConfigsDocument = gql`\n    query getUserUIConfigs {\n  getUserUIConfigs {\n    all {\n      id\n      config\n      key\n    }\n  }\n}\n    `;\n\n  @Injectable({\n    providedIn: 'root'\n  })\n  export class GetUserUiConfigsGQL extends Apollo.Query<GetUserUiConfigsQuery, GetUserUiConfigsQueryVariables> {\n    document = GetUserUiConfigsDocument;\n    \n    constructor(apollo: Apollo.Apollo) {\n      super(apollo);\n    }\n  }\nexport const GetUserMessagesDocument = gql`\n    query getUserMessages {\n  getUserMessages {\n    id\n    name\n    description\n    config\n    target\n    key\n  }\n}\n    `;\n\n  @Injectable({\n    providedIn: 'root'\n  })\n  export class GetUserMessagesGQL extends Apollo.Query<GetUserMessagesQuery, GetUserMessagesQueryVariables> {\n    document = GetUserMessagesDocument;\n    \n    constructor(apollo: Apollo.Apollo) {\n      super(apollo);\n    }\n  }\nexport const GetUserPhoneNumbersDocument = gql`\n    query getUserPhoneNumbers {\n  getUserPhoneNumbers {\n    id\n    description\n    countryCode\n    areaCode\n    number\n    extension\n    type\n    officePrimary\n    userPrimary\n  }\n}\n    `;\n\n  @Injectable({\n    providedIn: 'root'\n  })\n  export class GetUserPhoneNumbersGQL extends Apollo.Query<GetUserPhoneNumbersQuery, GetUserPhoneNumbersQueryVariables> {\n    document = GetUserPhoneNumbersDocument;\n    \n    constructor(apollo: Apollo.Apollo) {\n      super(apollo);\n    }\n  }\nexport const SetUserLanguageDocument = gql`\n    mutation setUserLanguage($language: ID) {\n  setUserLanguage(language: $language) {\n    id\n    selectedLanguage {\n      id\n      name\n    }\n  }\n}\n    `;\n\n  @Injectable({\n    providedIn: 'root'\n  })\n  export class SetUserLanguageGQL extends Apollo.Mutation<SetUserLanguageMutation, SetUserLanguageMutationVariables> {\n    document = SetUserLanguageDocument;\n    \n    constructor(apollo: Apollo.Apollo) {\n      super(apollo);\n    }\n  }\nexport const GetUserDocument = gql`\n    query getUser($id: ID) {\n  getUser(id: $id) {\n    ...UserFields\n  }\n}\n    ${UserFieldsFragmentDoc}`;\n\n  @Injectable({\n    providedIn: 'root'\n  })\n  export class GetUserGQL extends Apollo.Query<GetUserQuery, GetUserQueryVariables> {\n    document = GetUserDocument;\n    \n    constructor(apollo: Apollo.Apollo) {\n      super(apollo);\n    }\n  }\nexport const SearchUserCanBookForDocument = gql`\n    query searchUserCanBookFor($email: String, $userName: String, $employeeId: String) {\n  searchUserCanBookFor(email: $email, userName: $userName, employeeId: $employeeId) {\n    id\n    forename\n    surname\n    email\n  }\n}\n    `;\n\n  @Injectable({\n    providedIn: 'root'\n  })\n  export class SearchUserCanBookForGQL extends Apollo.Query<SearchUserCanBookForQuery, SearchUserCanBookForQueryVariables> {\n    document = SearchUserCanBookForDocument;\n    \n    constructor(apollo: Apollo.Apollo) {\n      super(apollo);\n    }\n  }\nexport const ValidateUserMiFreeValueDocument = gql`\n    query validateUserMIFreeValue($mi: ID!, $freeValue: String!) {\n  validateUserMIFreeValue(mi: $mi, freeValue: $freeValue)\n}\n    `;\n\n  @Injectable({\n    providedIn: 'root'\n  })\n  export class ValidateUserMiFreeValueGQL extends Apollo.Query<ValidateUserMiFreeValueQuery, ValidateUserMiFreeValueQueryVariables> {\n    document = ValidateUserMiFreeValueDocument;\n    \n    constructor(apollo: Apollo.Apollo) {\n      super(apollo);\n    }\n  }"]}