rsl-api-106 106.34.0

package/lib/types/index.d.ts

@@ -0,0 +1,2882 @@
+export type Maybe<T> = T | null;
+export type InputMaybe<T> = Maybe<T>;
+export type Exact<T extends {
+    [key: string]: unknown;
+}> = {
+    [K in keyof T]: T[K];
+};
+export type MakeOptional<T, K extends keyof T> = Omit<T, K> & {
+    [SubKey in K]?: Maybe<T[SubKey]>;
+};
+export type MakeMaybe<T, K extends keyof T> = Omit<T, K> & {
+    [SubKey in K]: Maybe<T[SubKey]>;
+};
+/** All built-in and custom scalars, mapped to their actual values */
+export type Scalars = {
+    ID: string;
+    String: string;
+    Boolean: boolean;
+    Int: number;
+    Float: number;
+    BigDecimal: any;
+    Date: any;
+    FerryDate: any;
+    FerryTime: any;
+    LocalTime: any;
+    RslDate: any;
+    RslDateTime: any;
+};
+export type Accommodation = {
+    __typename?: "Accommodation";
+    code: Scalars["String"];
+    label?: Maybe<Scalars["String"]>;
+    occupancy?: Maybe<Scalars["Int"]>;
+    quantity?: Maybe<Scalars["Int"]>;
+    totalAmount?: Maybe<Amount>;
+    unitPrice?: Maybe<Amount>;
+};
+export type AccommodationInput = {
+    code?: InputMaybe<Scalars["String"]>;
+    quantity?: InputMaybe<Scalars["Int"]>;
+};
+export type AccommodationProductsInput = {
+    cartItemID?: InputMaybe<Scalars["Int"]>;
+    categoryCodes?: InputMaybe<Array<InputMaybe<Scalars["String"]>>>;
+    excludeMandatoryProduct?: InputMaybe<Scalars["Boolean"]>;
+    stayGuiid: Scalars["Int"];
+};
+export type AccommodationProductsOutput = {
+    __typename?: "AccommodationProductsOutput";
+    accommodationProducts?: Maybe<Array<Maybe<ProductByCategory>>>;
+};
+export type AccountInput = {
+    facebookID?: InputMaybe<Scalars["String"]>;
+    password?: InputMaybe<Scalars["String"]>;
+    password2?: InputMaybe<Scalars["String"]>;
+    userName?: InputMaybe<Scalars["String"]>;
+};
+export type AddBabyInput = {
+    cartItemID?: InputMaybe<Scalars["Int"]>;
+    stayGuiid: Scalars["Int"];
+};
+export type AddBabyOutput = {
+    __typename?: "AddBabyOutput";
+    cart?: Maybe<Cart>;
+};
+export type AddOccupantInput = {
+    cartItemID?: InputMaybe<Scalars["Int"]>;
+    occupantType?: InputMaybe<OccupantTypeEnum>;
+    stayGuiid: Scalars["Int"];
+};
+export type AddOccupantOutput = {
+    __typename?: "AddOccupantOutput";
+    cart?: Maybe<Cart>;
+};
+export type AddPartnerCustomerAccountInput = {
+    address: CustomerAddressInput;
+    birthDate: Scalars["Date"];
+    civility?: InputMaybe<Scalars["String"]>;
+    firstName: Scalars["String"];
+    lastName: Scalars["String"];
+    relationshipId?: InputMaybe<Scalars["Int"]>;
+};
+export type AddonCategory = {
+    __typename?: "AddonCategory";
+    code: Scalars["String"];
+    label?: Maybe<Scalars["String"]>;
+    size?: Maybe<Scalars["String"]>;
+    type?: Maybe<Scalars["String"]>;
+};
+export type Address = {
+    __typename?: "Address";
+    addressComplementary1?: Maybe<Scalars["String"]>;
+    addressComplementary2?: Maybe<Scalars["String"]>;
+    addressCountry?: Maybe<Country>;
+    city?: Maybe<Scalars["String"]>;
+    /** @deprecated Use 'addressCountry'. */
+    country?: Maybe<Option>;
+    fax?: Maybe<Scalars["String"]>;
+    latitude?: Maybe<Scalars["String"]>;
+    longitude?: Maybe<Scalars["String"]>;
+    mail?: Maybe<Scalars["String"]>;
+    phone1?: Maybe<Scalars["String"]>;
+    phone2?: Maybe<Scalars["String"]>;
+    postalLocality?: Maybe<Scalars["String"]>;
+    streetName?: Maybe<Scalars["String"]>;
+    zipCode?: Maybe<Scalars["String"]>;
+};
+export type AllOccupantProductsAllAgeRangesInput = {
+    cartItemID?: InputMaybe<Scalars["Int"]>;
+    categoryCodes?: InputMaybe<Array<InputMaybe<Scalars["String"]>>>;
+    stayGuiid: Scalars["Int"];
+};
+export type AllOccupantProductsAllAgeRangesOutput = {
+    __typename?: "AllOccupantProductsAllAgeRangesOutput";
+    occupantProducts?: Maybe<Array<Maybe<ProductByCategory>>>;
+};
+export type AlternativeProposalRule = {
+    __typename?: "AlternativeProposalRule";
+    dstProperties?: Maybe<Array<Maybe<Property>>>;
+    id: Scalars["Int"];
+    label?: Maybe<Scalars["String"]>;
+    priority?: Maybe<Scalars["Int"]>;
+    roomFeatures?: Maybe<Array<Maybe<CriteriaValue>>>;
+    srcProperty?: Maybe<Property>;
+};
+export type AlternativeProposalRulesForContractFolderInput = {
+    contractFolderId: Scalars["Int"];
+};
+export type AlternativeProposalRulesForContractFolderOutput = {
+    __typename?: "AlternativeProposalRulesForContractFolderOutput";
+    alternativeProposalRules?: Maybe<Array<Maybe<AlternativeProposalRule>>>;
+};
+export type Amount = {
+    __typename?: "Amount";
+    amount?: Maybe<Scalars["BigDecimal"]>;
+    currencyCode?: Maybe<Scalars["String"]>;
+};
+export type AmountInput = {
+    amount?: InputMaybe<Scalars["BigDecimal"]>;
+    currencyCode?: InputMaybe<Scalars["String"]>;
+};
+export type ApiAliveOutput = {
+    __typename?: "ApiAliveOutput";
+    alive?: Maybe<Scalars["Boolean"]>;
+};
+export type AuthenticationInput = {
+    password: Scalars["String"];
+    username: Scalars["String"];
+};
+export type AvailForRoomTypesInput = {
+    baseProductCode?: InputMaybe<Scalars["String"]>;
+    campaignCode: Scalars["String"];
+    childrenBirthdate?: InputMaybe<Array<InputMaybe<Scalars["Date"]>>>;
+    endDate?: InputMaybe<Scalars["Date"]>;
+    nbAdults: Scalars["Int"];
+    nbBabies?: InputMaybe<Scalars["Int"]>;
+    nbChildren1?: InputMaybe<Scalars["Int"]>;
+    nbChildren2?: InputMaybe<Scalars["Int"]>;
+    nbDays?: InputMaybe<Scalars["Int"]>;
+    propertyId: Scalars["Int"];
+    roomTypeCodes?: InputMaybe<Array<InputMaybe<Scalars["String"]>>>;
+    startDate: Scalars["Date"];
+};
+export type AvailForRoomTypesOutput = {
+    __typename?: "AvailForRoomTypesOutput";
+    availabilityRoomTypes?: Maybe<Array<Maybe<AvailabilityRoomType>>>;
+};
+export type AvailabilityRoomType = {
+    __typename?: "AvailabilityRoomType";
+    availability?: Maybe<Scalars["Int"]>;
+    bookable?: Maybe<Scalars["Boolean"]>;
+    minAdults?: Maybe<Scalars["Int"]>;
+    property?: Maybe<Property>;
+    proposal?: Maybe<Proposal>;
+    roomType?: Maybe<RoomType>;
+};
+export type AvailableRoomFeaturesInput = {
+    propertyIds?: InputMaybe<Array<InputMaybe<Scalars["Int"]>>>;
+    roomFeatureCodes?: InputMaybe<Array<InputMaybe<Scalars["String"]>>>;
+};
+export type AvailableRoomFeaturesOutput = {
+    __typename?: "AvailableRoomFeaturesOutput";
+    roomFeatures?: Maybe<Array<Maybe<RoomFeature>>>;
+};
+export type BookingDocumentsInput = {
+    bookingId: Scalars["Int"];
+};
+export type BookingDocumentsOutput = {
+    __typename?: "BookingDocumentsOutput";
+    documents?: Maybe<Array<Maybe<File>>>;
+};
+export type BookingProductsInput = {
+    cartItemID?: InputMaybe<Scalars["Int"]>;
+    categoryCodes?: InputMaybe<Array<InputMaybe<Scalars["String"]>>>;
+    excludeMandatoryInput?: InputMaybe<Scalars["Boolean"]>;
+};
+export type BookingProductsOutput = {
+    __typename?: "BookingProductsOutput";
+    bookingProducts?: Maybe<Array<Maybe<ProductByCategory>>>;
+};
+export type BookingRecordCriteriasOutput = {
+    __typename?: "BookingRecordCriteriasOutput";
+    criterias?: Maybe<Array<Maybe<Criteria>>>;
+};
+export declare enum BookingStatus {
+    Estimate = "ESTIMATE",
+    Guaranteed = "GUARANTEED",
+    Option = "OPTION"
+}
+export type Brochure = {
+    __typename?: "Brochure";
+    code?: Maybe<Scalars["String"]>;
+    label?: Maybe<Scalars["String"]>;
+};
+export type BrochureInput = {
+    brochureIds?: InputMaybe<Array<InputMaybe<Scalars["String"]>>>;
+};
+export type BrochureOutput = {
+    __typename?: "BrochureOutput";
+    requested?: Maybe<Scalars["Boolean"]>;
+};
+export type BrochuresOutput = {
+    __typename?: "BrochuresOutput";
+    brochureList?: Maybe<Array<Maybe<Brochure>>>;
+    /** @deprecated Use 'brochureList'. */
+    brochures?: Maybe<Array<Maybe<Option>>>;
+};
+export type Calfwidth = {
+    __typename?: "Calfwidth";
+    id?: Maybe<Scalars["Int"]>;
+    value?: Maybe<Scalars["String"]>;
+};
+export type Campaign = {
+    __typename?: "Campaign";
+    code?: Maybe<Scalars["String"]>;
+    endDate?: Maybe<Scalars["RslDate"]>;
+    label?: Maybe<Scalars["String"]>;
+    startDate?: Maybe<Scalars["RslDate"]>;
+};
+export type CampaignsOutput = {
+    __typename?: "CampaignsOutput";
+    campaignList?: Maybe<Array<Maybe<Campaign>>>;
+    /** @deprecated Use 'campaignList'. */
+    campaigns?: Maybe<Array<Maybe<Option>>>;
+};
+export type CancelFerryBookingInput = {
+    cartItemID?: InputMaybe<Scalars["Int"]>;
+    lineItemGuiid: Scalars["Int"];
+};
+export type CancelFerryBookingOutput = {
+    __typename?: "CancelFerryBookingOutput";
+    cart?: Maybe<Cart>;
+};
+export type Car = {
+    __typename?: "Car";
+    make?: Maybe<Scalars["String"]>;
+    model?: Maybe<Scalars["String"]>;
+    vehicleCategoryCode?: Maybe<Scalars["String"]>;
+};
+export type Cart = {
+    __typename?: "Cart";
+    fromFastCheckinCheckout?: Maybe<Scalars["Boolean"]>;
+    id?: Maybe<Scalars["Int"]>;
+    reservations?: Maybe<Array<Maybe<CustomerBooking>>>;
+};
+export type CartOutput = {
+    __typename?: "CartOutput";
+    cart?: Maybe<Cart>;
+};
+export type CartPaymentMethodInput = {
+    automaticPayment?: InputMaybe<Scalars["Boolean"]>;
+    bookingStatus: BookingStatus;
+    ccardType?: InputMaybe<Scalars["Int"]>;
+    chequeNumber?: InputMaybe<Scalars["String"]>;
+    forceSaveGuaranteedStatus?: InputMaybe<Scalars["Boolean"]>;
+    manualPaymentOptions?: InputMaybe<Scalars["String"]>;
+    paymentAmount?: InputMaybe<Scalars["String"]>;
+    paymentMode?: InputMaybe<Scalars["String"]>;
+    paymentModeSetOnlyFirst?: InputMaybe<Scalars["Boolean"]>;
+    paymentOptions?: InputMaybe<Scalars["String"]>;
+    url?: InputMaybe<PspUrl>;
+};
+export type CartPaymentMethodOutput = {
+    __typename?: "CartPaymentMethodOutput";
+    cart?: Maybe<Cart>;
+};
+export type CartPaymentPlansInput = {
+    partnerPaymentPlan?: InputMaybe<Scalars["String"]>;
+    paymentPlan?: InputMaybe<Scalars["String"]>;
+};
+export type CartPaymentPlansOutput = {
+    __typename?: "CartPaymentPlansOutput";
+    cart?: Maybe<Cart>;
+};
+export type ChangePasswordInput = {
+    confirmPassword: Scalars["String"];
+    password: Scalars["String"];
+    token: Scalars["String"];
+};
+export type ChangePasswordOutput = {
+    __typename?: "ChangePasswordOutput";
+    message: Scalars["String"];
+};
+export type ChooseFerryProposalInput = {
+    proposalId?: InputMaybe<Scalars["Int"]>;
+};
+export type ChooseFerryProposalOutput = {
+    __typename?: "ChooseFerryProposalOutput";
+    ferryBooking?: Maybe<FerryBooking>;
+};
+export type ChooseProposalFromKeysInput = {
+    cartItemID?: InputMaybe<Scalars["Int"]>;
+    notGroupStays?: InputMaybe<Scalars["Boolean"]>;
+    notPopulateOccupantFromService?: InputMaybe<Scalars["Boolean"]>;
+    occupantList?: InputMaybe<Array<InputMaybe<ChooseProposalFromKeysOccupantInput>>>;
+    proposalKeys: Array<Scalars["String"]>;
+};
+export type ChooseProposalFromKeysOccupantInput = {
+    birthDate?: InputMaybe<Scalars["Date"]>;
+    civilityCode?: InputMaybe<Scalars["String"]>;
+    firstName?: InputMaybe<Scalars["String"]>;
+    lastName?: InputMaybe<Scalars["String"]>;
+};
+export type ChooseProposalFromKeysOutput = {
+    __typename?: "ChooseProposalFromKeysOutput";
+    cart?: Maybe<Cart>;
+};
+export type ChooseRoundTripProposalsInput = {
+    outwardProposalId?: InputMaybe<Scalars["Int"]>;
+    returnProposalId?: InputMaybe<Scalars["Int"]>;
+};
+export type ChooseRoundTripProposalsOutput = {
+    __typename?: "ChooseRoundTripProposalsOutput";
+    ferryBooking?: Maybe<FerryBooking>;
+};
+export type CivilitiesOutput = {
+    __typename?: "CivilitiesOutput";
+    /** @deprecated Use 'civilitiyList'. */
+    civilities?: Maybe<Array<Maybe<Option>>>;
+    civilitiyList?: Maybe<Array<Maybe<Civility>>>;
+};
+export type Civility = {
+    __typename?: "Civility";
+    code?: Maybe<Scalars["String"]>;
+    label?: Maybe<Scalars["String"]>;
+};
+export type ClientType = {
+    __typename?: "ClientType";
+    id: Scalars["Int"];
+    label?: Maybe<Scalars["String"]>;
+};
+export type ConfirmFastCheckoutInput = {
+    cartItemID?: InputMaybe<Scalars["Int"]>;
+    confirmFastCheckout?: InputMaybe<Scalars["Boolean"]>;
+};
+export type ConfirmFastCheckoutOutput = {
+    __typename?: "ConfirmFastCheckoutOutput";
+    cart?: Maybe<Cart>;
+};
+export type Contact = {
+    __typename?: "Contact";
+    email?: Maybe<Scalars["String"]>;
+    phone?: Maybe<Scalars["String"]>;
+};
+export type ContactInfo = {
+    email?: InputMaybe<Scalars["String"]>;
+    phone?: InputMaybe<Scalars["String"]>;
+};
+export type ContractFolder = {
+    __typename?: "ContractFolder";
+    cmsCriterias?: Maybe<Array<Maybe<CriteriaValue>>>;
+    id: Scalars["Int"];
+    label?: Maybe<Scalars["String"]>;
+};
+export type CoreTrip = {
+    __typename?: "CoreTrip";
+    amount?: Maybe<Amount>;
+};
+export type CountriesOutput = {
+    __typename?: "CountriesOutput";
+    /** @deprecated Use 'countryList'. */
+    countries?: Maybe<Array<Maybe<Option>>>;
+    countryList?: Maybe<Array<Maybe<Country>>>;
+};
+export type Country = {
+    __typename?: "Country";
+    code?: Maybe<Scalars["String"]>;
+    label?: Maybe<Scalars["String"]>;
+};
+export type CreateCustomerAccountInput = {
+    account?: InputMaybe<AccountInput>;
+    address: CustomerAddressInput;
+    birthDate: Scalars["Date"];
+    cartItemID?: InputMaybe<Scalars["Int"]>;
+    civility?: InputMaybe<Scalars["String"]>;
+    criterias?: InputMaybe<Array<InputMaybe<CriteriaValueInput>>>;
+    firstName: Scalars["String"];
+    languageCode?: InputMaybe<Scalars["String"]>;
+    lastName: Scalars["String"];
+};
+export type CreateCustomerAccountOutput = {
+    __typename?: "CreateCustomerAccountOutput";
+    service?: Maybe<Service>;
+};
+export type CreateServiceCustomerAccountInput = {
+    birthDate: Scalars["Date"];
+    civility?: InputMaybe<Scalars["String"]>;
+    firstName?: InputMaybe<Scalars["String"]>;
+    lastName: Scalars["String"];
+    relaltionshipId?: InputMaybe<Scalars["Int"]>;
+};
+export type CreditCard = {
+    __typename?: "CreditCard";
+    cardholderName?: Maybe<Scalars["String"]>;
+    guiid?: Maybe<Scalars["Int"]>;
+    maskedPan?: Maybe<Scalars["String"]>;
+};
+export type Criteria = {
+    __typename?: "Criteria";
+    choiceList?: Maybe<Array<Maybe<CriteriaChoice>>>;
+    /** @deprecated Use 'choiceList'. */
+    choices?: Maybe<Array<Maybe<Option>>>;
+    code: Scalars["String"];
+    isChoice?: Maybe<Scalars["Boolean"]>;
+    isFile?: Maybe<Scalars["Boolean"]>;
+    isFree?: Maybe<Scalars["Boolean"]>;
+    label?: Maybe<Scalars["String"]>;
+    mandatory?: Maybe<Scalars["Boolean"]>;
+};
+export type CriteriaChoice = {
+    __typename?: "CriteriaChoice";
+    code?: Maybe<Scalars["String"]>;
+    label?: Maybe<Scalars["String"]>;
+};
+export type CriteriaInformationInput = {
+    code?: InputMaybe<Scalars["String"]>;
+    customerCriteria?: InputMaybe<Scalars["Boolean"]>;
+};
+export type CriteriaInformationOutput = {
+    __typename?: "CriteriaInformationOutput";
+    criteria?: Maybe<Criteria>;
+};
+export type CriteriaValue = {
+    __typename?: "CriteriaValue";
+    code: Scalars["String"];
+    fileName?: Maybe<Scalars["String"]>;
+    label?: Maybe<Scalars["String"]>;
+    servicesList?: Maybe<Array<Maybe<Service>>>;
+    startDate?: Maybe<Scalars["Date"]>;
+    type?: Maybe<Scalars["Int"]>;
+    value?: Maybe<Scalars["String"]>;
+};
+export type CriteriaValueInput = {
+    code: Scalars["String"];
+    fileName?: InputMaybe<Scalars["String"]>;
+    value: Scalars["String"];
+};
+export type Criterias = {
+    baseProductCode?: InputMaybe<Scalars["String"]>;
+    campaignCode?: InputMaybe<Scalars["String"]>;
+    childrenBirthdate?: InputMaybe<Array<InputMaybe<Scalars["Date"]>>>;
+    discountCode?: InputMaybe<Scalars["String"]>;
+    endDate?: InputMaybe<Scalars["Date"]>;
+    maxNbRooms?: InputMaybe<Scalars["Int"]>;
+    maxResults?: InputMaybe<Scalars["Int"]>;
+    nbAdults: Scalars["Int"];
+    nbBabies?: InputMaybe<Scalars["Int"]>;
+    nbChildren1?: InputMaybe<Scalars["Int"]>;
+    nbChildren2?: InputMaybe<Scalars["Int"]>;
+    nbDays?: InputMaybe<Scalars["Int"]>;
+    noCounterProposal?: InputMaybe<Scalars["Boolean"]>;
+    partnerPrivilegeCardID?: InputMaybe<Scalars["Int"]>;
+    privilegeCardID?: InputMaybe<Scalars["Int"]>;
+    propertyIds?: InputMaybe<Array<InputMaybe<Scalars["Int"]>>>;
+    roomCategories?: InputMaybe<Array<InputMaybe<Scalars["String"]>>>;
+    roomFeatureValues?: InputMaybe<Array<InputMaybe<RoomFeatureValue>>>;
+    roomType?: InputMaybe<Scalars["String"]>;
+    sortString?: InputMaybe<Scalars["String"]>;
+    startDate?: InputMaybe<Scalars["Date"]>;
+};
+export type CriteriasPort = {
+    arrivalPortName: Scalars["String"];
+    departurePortName: Scalars["String"];
+};
+export type CriteriasTrailer = {
+    height?: InputMaybe<Scalars["Float"]>;
+    length?: InputMaybe<Scalars["Float"]>;
+    mark?: InputMaybe<Scalars["String"]>;
+    model?: InputMaybe<Scalars["String"]>;
+    trailerCategory: Scalars["String"];
+};
+export type CriteriasTrip = {
+    departureDate?: InputMaybe<Scalars["FerryDate"]>;
+    departureTime?: InputMaybe<Scalars["FerryTime"]>;
+};
+export type CriteriasVehicle = {
+    additionalHeight?: InputMaybe<Scalars["Float"]>;
+    additionalLength?: InputMaybe<Scalars["Float"]>;
+    height?: InputMaybe<Scalars["Float"]>;
+    length?: InputMaybe<Scalars["Float"]>;
+    mark?: InputMaybe<Scalars["String"]>;
+    model?: InputMaybe<Scalars["String"]>;
+    vehicleCategory: Scalars["String"];
+};
+export type Crossing = {
+    __typename?: "Crossing";
+    arrivalPort: Port;
+    departurePort: Port;
+};
+export type CurrentCustomerAccountOutput = {
+    __typename?: "CurrentCustomerAccountOutput";
+    service?: Maybe<Service>;
+};
+export type CustomerAccountInput = {
+    account?: InputMaybe<AccountInput>;
+    address?: InputMaybe<CustomerAddressInput>;
+    birthDate: Scalars["Date"];
+    civility?: InputMaybe<Scalars["String"]>;
+    criterias?: InputMaybe<Array<InputMaybe<CriteriaValueInput>>>;
+    firstName: Scalars["String"];
+    languageCode?: InputMaybe<Scalars["String"]>;
+    lastName?: InputMaybe<Scalars["String"]>;
+};
+export type CustomerAccountOutput = {
+    __typename?: "CustomerAccountOutput";
+    service?: Maybe<Service>;
+};
+export type CustomerAddressInput = {
+    addressComplementary1?: InputMaybe<Scalars["String"]>;
+    addressComplementary2?: InputMaybe<Scalars["String"]>;
+    city?: InputMaybe<Scalars["String"]>;
+    country?: InputMaybe<Scalars["String"]>;
+    fax?: InputMaybe<Scalars["String"]>;
+    mail: Scalars["String"];
+    phone1?: InputMaybe<Scalars["String"]>;
+    phone2?: InputMaybe<Scalars["String"]>;
+    postalLocality?: InputMaybe<Scalars["String"]>;
+    streetName?: InputMaybe<Scalars["String"]>;
+    zipCode?: InputMaybe<Scalars["String"]>;
+};
+export type CustomerBooking = {
+    __typename?: "CustomerBooking";
+    campaign?: Maybe<Campaign>;
+    cartID?: Maybe<Scalars["Int"]>;
+    cartItemID?: Maybe<Scalars["Int"]>;
+    contractFolder?: Maybe<ContractFolder>;
+    creationDate?: Maybe<Scalars["Date"]>;
+    criterias?: Maybe<Array<Maybe<CriteriaValue>>>;
+    discountCode?: Maybe<Scalars["String"]>;
+    endDate?: Maybe<Scalars["Date"]>;
+    externalCode?: Maybe<Scalars["String"]>;
+    id?: Maybe<Scalars["Int"]>;
+    isCanceled?: Maybe<Scalars["Boolean"]>;
+    isEnableEditPrimaryOccupant?: Maybe<Scalars["Boolean"]>;
+    isEnableEditReservation?: Maybe<Scalars["Boolean"]>;
+    isEnableFastCheckin?: Maybe<Scalars["Boolean"]>;
+    isEnableFastCheckout?: Maybe<Scalars["Boolean"]>;
+    isEnableFerryBooking?: Maybe<Scalars["Boolean"]>;
+    isEstimate?: Maybe<Scalars["Boolean"]>;
+    isFCIdone?: Maybe<Scalars["Boolean"]>;
+    isOption?: Maybe<Scalars["Boolean"]>;
+    isPSPPayment?: Maybe<Scalars["Boolean"]>;
+    nbDays?: Maybe<Scalars["Int"]>;
+    observation?: Maybe<Scalars["String"]>;
+    optionDate?: Maybe<Scalars["Date"]>;
+    partner?: Maybe<Service>;
+    primaryOccupant?: Maybe<PrimaryOccupant>;
+    property?: Maybe<Property>;
+    salesperson?: Maybe<User>;
+    selectedPaymentCCType?: Maybe<Scalars["Int"]>;
+    selectedPaymentDue?: Maybe<Scalars["String"]>;
+    selectedPaymentMethod?: Maybe<Scalars["String"]>;
+    startDate?: Maybe<Scalars["Date"]>;
+    status?: Maybe<CustomerBookingStatus>;
+    stays?: Maybe<Array<Maybe<Stay>>>;
+    subStatus?: Maybe<CustomerBookingSubStatus>;
+    totalAmount?: Maybe<Amount>;
+};
+export type CustomerBookingInput = {
+    bookingId: Scalars["Int"];
+    fastCheckinCheckout?: InputMaybe<Scalars["Boolean"]>;
+};
+export type CustomerBookingOutput = {
+    __typename?: "CustomerBookingOutput";
+    cart?: Maybe<Cart>;
+};
+export type CustomerBookingStatus = {
+    __typename?: "CustomerBookingStatus";
+    code?: Maybe<Scalars["String"]>;
+    default?: Maybe<Scalars["Boolean"]>;
+    label?: Maybe<Scalars["String"]>;
+};
+export type CustomerBookingSubStatus = {
+    __typename?: "CustomerBookingSubStatus";
+    default?: Maybe<Scalars["Boolean"]>;
+    id?: Maybe<Scalars["Int"]>;
+    label?: Maybe<Scalars["String"]>;
+};
+export type CustomerBookingsInput = {
+    bookingIds?: InputMaybe<Array<InputMaybe<Scalars["Int"]>>>;
+    canceled?: InputMaybe<Scalars["Boolean"]>;
+    estimate?: InputMaybe<Scalars["Boolean"]>;
+    option?: InputMaybe<Scalars["Boolean"]>;
+};
+export type CustomerBookingsOutput = {
+    __typename?: "CustomerBookingsOutput";
+    customerBookings?: Maybe<Array<Maybe<CustomerBooking>>>;
+};
+export type CustomerCriteriasInput = {
+    criteriaCodes?: InputMaybe<Array<InputMaybe<Scalars["String"]>>>;
+};
+export type CustomerCriteriasOutput = {
+    __typename?: "CustomerCriteriasOutput";
+    criterias?: Maybe<Array<Maybe<Criteria>>>;
+};
+export type CustomerDepositAccount = {
+    __typename?: "CustomerDepositAccount";
+    balance?: Maybe<Amount>;
+    id?: Maybe<Scalars["Int"]>;
+    name?: Maybe<Scalars["String"]>;
+    propertyId: Scalars["Int"];
+    type?: Maybe<Scalars["Int"]>;
+};
+export type CustomerDepositAccountPaymentsInput = {
+    bookingId: Scalars["Int"];
+    currencyCode: Scalars["String"];
+    depositAccountPayments?: InputMaybe<Array<InputMaybe<DepositAccountPaymentInput>>>;
+};
+export type CustomerDepositAccountPaymentsOutput = {
+    __typename?: "CustomerDepositAccountPaymentsOutput";
+    reservation?: Maybe<CustomerBooking>;
+};
+export type CustomerDepositAccountsOutput = {
+    __typename?: "CustomerDepositAccountsOutput";
+    customerDepositAccounts?: Maybe<Array<Maybe<CustomerDepositAccount>>>;
+};
+export type CustomerGiftCodesOutput = {
+    __typename?: "CustomerGiftCodesOutput";
+    giftCodes?: Maybe<Array<Maybe<GiftCode>>>;
+};
+export type CustomerLoyaltyPointsOutput = {
+    __typename?: "CustomerLoyaltyPointsOutput";
+    points?: Maybe<Scalars["Int"]>;
+};
+export type CustomerPrivilegeCardsOutput = {
+    __typename?: "CustomerPrivilegeCardsOutput";
+    privilegeCards?: Maybe<Array<Maybe<PrivilegeCard>>>;
+};
+export type CustomerType = {
+    __typename?: "CustomerType";
+    code: Scalars["String"];
+    label?: Maybe<Scalars["String"]>;
+};
+export type DepositAccountPaymentInput = {
+    accountID: Scalars["Int"];
+    amount: AmountInput;
+};
+export type DisableEnablePartnerCustomerAccountInput = {
+    customerCode: Scalars["String"];
+    disabled: Scalars["Boolean"];
+};
+export type DisableServiceCustomerAccountInput = {
+    serviceId?: InputMaybe<Scalars["Int"]>;
+};
+export type Discount = {
+    __typename?: "Discount";
+    discountCode?: Maybe<Scalars["String"]>;
+    documentLabel?: Maybe<Scalars["String"]>;
+    fidelityPoints?: Maybe<Scalars["Int"]>;
+    label?: Maybe<Scalars["String"]>;
+    price?: Maybe<Amount>;
+    quantity?: Maybe<Scalars["Int"]>;
+    specificLabel?: Maybe<Scalars["String"]>;
+    voucherCode?: Maybe<Scalars["String"]>;
+};
+export type DiscountCodeInput = {
+    cartItemID?: InputMaybe<Scalars["Int"]>;
+    discountCode: Scalars["String"];
+};
+export type DiscountCodeOutput = {
+    __typename?: "DiscountCodeOutput";
+    cart?: Maybe<Cart>;
+};
+export type Distribution = {
+    __typename?: "Distribution";
+    roomNumbers?: Maybe<Array<Maybe<Scalars["String"]>>>;
+    roomTypes?: Maybe<Array<Maybe<RoomType>>>;
+};
+export type DoFastCheckinInput = {
+    bookingId?: InputMaybe<Scalars["Int"]>;
+    isDepositCashless?: InputMaybe<Scalars["Boolean"]>;
+};
+export type DoFastCheckinOutput = {
+    __typename?: "DoFastCheckinOutput";
+    reservation?: Maybe<CustomerBooking>;
+};
+export type DoFastCheckoutInput = {
+    bookingId?: InputMaybe<Scalars["Int"]>;
+};
+export type DoFastCheckoutOutput = {
+    __typename?: "DoFastCheckoutOutput";
+    reservation?: Maybe<CustomerBooking>;
+};
+export type ExpireSessionOutput = {
+    __typename?: "ExpireSessionOutput";
+    isExpired?: Maybe<Scalars["Boolean"]>;
+};
+export type FacebookLoginInput = {
+    facebookID: Scalars["String"];
+};
+export type FacebookLoginOutput = {
+    __typename?: "FacebookLoginOutput";
+    service?: Maybe<Service>;
+};
+export type FerryAddonCategoriesOutput = {
+    __typename?: "FerryAddonCategoriesOutput";
+    addonCategories?: Maybe<Array<Maybe<AddonCategory>>>;
+};
+export type FerryAvailableAccommodationsOutput = {
+    __typename?: "FerryAvailableAccommodationsOutput";
+    outwardAccommodations?: Maybe<Array<Maybe<Accommodation>>>;
+    returnAccommodations?: Maybe<Array<Maybe<Accommodation>>>;
+};
+export type FerryBooking = {
+    __typename?: "FerryBooking";
+    bookingRef?: Maybe<Scalars["String"]>;
+    contact?: Maybe<Contact>;
+    outwardTrip: Trip;
+    passengers: Array<Maybe<Passenger>>;
+    passportMandatory?: Maybe<Scalars["Boolean"]>;
+    resFerryId?: Maybe<Scalars["Int"]>;
+    returnTrip?: Maybe<Trip>;
+    sendStatus?: Maybe<Scalars["String"]>;
+    status?: Maybe<Scalars["String"]>;
+    supplier: Supplier;
+    totalAmount: Amount;
+    /** @deprecated Vehicle moved in Trip */
+    vehicle?: Maybe<Vehicle>;
+};
+export type FerryBookingCriterias = {
+    flexibleDates?: InputMaybe<Scalars["Boolean"]>;
+    nbAdults?: InputMaybe<Scalars["Int"]>;
+    nbChildren?: InputMaybe<Scalars["Int"]>;
+    outwardTrip?: InputMaybe<CriteriasTrip>;
+    port?: InputMaybe<CriteriasPort>;
+    returnTrip?: InputMaybe<CriteriasTrip>;
+    strictPorts?: InputMaybe<Scalars["Boolean"]>;
+    trailer?: InputMaybe<CriteriasTrailer>;
+    vehicle?: InputMaybe<CriteriasVehicle>;
+};
+export type FerryCarsOutput = {
+    __typename?: "FerryCarsOutput";
+    cars?: Maybe<Array<Maybe<Car>>>;
+};
+export type FerryCivilitiesOutput = {
+    __typename?: "FerryCivilitiesOutput";
+    civilities?: Maybe<Array<Maybe<Civility>>>;
+};
+export type FerryCrossingsInput = {
+    arrivalPortName?: InputMaybe<Scalars["String"]>;
+    departurePortName?: InputMaybe<Scalars["String"]>;
+};
+export type FerryCrossingsOutput = {
+    __typename?: "FerryCrossingsOutput";
+    crossings?: Maybe<Array<Maybe<Crossing>>>;
+};
+export type FerryNationalitiesOutput = {
+    __typename?: "FerryNationalitiesOutput";
+    nationalities?: Maybe<Array<Maybe<Nationality>>>;
+};
+export type FerryPortsOutput = {
+    __typename?: "FerryPortsOutput";
+    ports?: Maybe<Array<Maybe<Port>>>;
+};
+export type FerryProduct = {
+    __typename?: "FerryProduct";
+    code?: Maybe<Scalars["String"]>;
+    label?: Maybe<Scalars["String"]>;
+};
+export type FerryProductsOutput = {
+    __typename?: "FerryProductsOutput";
+    ferryProducts?: Maybe<Array<Maybe<FerryProduct>>>;
+};
+export type FerryProposal = {
+    __typename?: "FerryProposal";
+    id: Scalars["Int"];
+    isFlexibleFare?: Maybe<Scalars["Boolean"]>;
+    outwardTrip: Trip;
+    returnTrip?: Maybe<Trip>;
+    supplier: Supplier;
+    tariff?: Maybe<FerryProposalTariff>;
+    totalAmount: Amount;
+};
+export type FerryProposalTariff = {
+    __typename?: "FerryProposalTariff";
+    tariffBand?: Maybe<Scalars["String"]>;
+    tariffType?: Maybe<Scalars["String"]>;
+};
+export type FerryProposalsInput = {
+    cartItemID?: InputMaybe<Scalars["Int"]>;
+    criterias?: InputMaybe<FerryBookingCriterias>;
+};
+export type FerryProposalsOutput = {
+    __typename?: "FerryProposalsOutput";
+    canChooseRoundTripProposals?: Maybe<Scalars["Boolean"]>;
+    proposals?: Maybe<Array<Maybe<FerryProposal>>>;
+    warningList?: Maybe<Array<Maybe<Scalars["String"]>>>;
+};
+export type FerryTrailerCategoriesOutput = {
+    __typename?: "FerryTrailerCategoriesOutput";
+    trailerCategories?: Maybe<Array<Maybe<TrailerCategory>>>;
+};
+export type FerryVehicleCategoriesOutput = {
+    __typename?: "FerryVehicleCategoriesOutput";
+    vehicleCategories?: Maybe<Array<Maybe<VehicleCategory>>>;
+};
+export type FerryVehicleFuel = {
+    __typename?: "FerryVehicleFuel";
+    code: Scalars["String"];
+    label?: Maybe<Scalars["String"]>;
+};
+export type FerryVehicleFuelsOutput = {
+    __typename?: "FerryVehicleFuelsOutput";
+    vehicleFuels?: Maybe<Array<Maybe<FerryVehicleFuel>>>;
+};
+export type FidelityLog = {
+    __typename?: "FidelityLog";
+    date?: Maybe<Scalars["RslDateTime"]>;
+    fidelityPoints?: Maybe<Scalars["Int"]>;
+    label?: Maybe<Scalars["String"]>;
+    numResa?: Maybe<Scalars["Int"]>;
+};
+export type FidelityLogsOutput = {
+    __typename?: "FidelityLogsOutput";
+    fidelityLogs?: Maybe<Array<Maybe<FidelityLog>>>;
+};
+export type FidelityPointToCartOutput = {
+    __typename?: "FidelityPointToCartOutput";
+    cart?: Maybe<Cart>;
+};
+export type FidelityPointToProductInput = {
+    fidelityPoints: Scalars["Int"];
+    lineItemGuiid: Scalars["Int"];
+};
+export type FidelityRule = {
+    __typename?: "FidelityRule";
+    fidelityPoints?: Maybe<Scalars["Int"]>;
+    label?: Maybe<Scalars["String"]>;
+};
+export type FidelityRulesOutput = {
+    __typename?: "FidelityRulesOutput";
+    fidelityRules?: Maybe<Array<Maybe<FidelityRule>>>;
+};
+export type File = {
+    __typename?: "File";
+    date?: Maybe<Scalars["RslDateTime"]>;
+    sentByEmail?: Maybe<Scalars["Boolean"]>;
+    sentByPrint?: Maybe<Scalars["Boolean"]>;
+    type?: Maybe<Scalars["String"]>;
+    url?: Maybe<Scalars["String"]>;
+};
+export type Footwidth = {
+    __typename?: "Footwidth";
+    id?: Maybe<Scalars["Int"]>;
+    value?: Maybe<Scalars["String"]>;
+};
+export type GatewayDescription = {
+    __typename?: "GatewayDescription";
+    endPoint?: Maybe<Scalars["String"]>;
+    isTest?: Maybe<Scalars["Boolean"]>;
+    publicKey?: Maybe<Scalars["String"]>;
+    url?: Maybe<PspUrlOutput>;
+};
+export type GiftCode = {
+    __typename?: "GiftCode";
+    amount?: Maybe<Amount>;
+    bookingId?: Maybe<Scalars["Int"]>;
+    code?: Maybe<Scalars["String"]>;
+    label?: Maybe<Scalars["String"]>;
+    type?: Maybe<Scalars["String"]>;
+    useDate?: Maybe<Scalars["Date"]>;
+    used?: Maybe<Scalars["Boolean"]>;
+    valid?: Maybe<Scalars["Boolean"]>;
+    validityDate?: Maybe<Scalars["Date"]>;
+};
+export type GiftCodeInput = {
+    cartItemID?: InputMaybe<Scalars["Int"]>;
+    giftCode: Scalars["String"];
+};
+export type GiftCodeOutput = {
+    __typename?: "GiftCodeOutput";
+    cart?: Maybe<Cart>;
+};
+export type HasProductsForOccupantInput = {
+    cartItemID?: InputMaybe<Scalars["Int"]>;
+    excludeMandatoryProduct?: InputMaybe<Scalars["Boolean"]>;
+};
+export type Headsize = {
+    __typename?: "Headsize";
+    id?: Maybe<Scalars["Int"]>;
+    value?: Maybe<Scalars["String"]>;
+};
+export type Heights = {
+    __typename?: "Heights";
+    id?: Maybe<Scalars["Int"]>;
+    value?: Maybe<Scalars["String"]>;
+};
+export type Language = {
+    __typename?: "Language";
+    code?: Maybe<Scalars["String"]>;
+    /** @deprecated Use 'code'. */
+    codeLanguage?: Maybe<Scalars["String"]>;
+    label?: Maybe<Scalars["String"]>;
+    /** @deprecated Use 'label'. */
+    labelLanguage?: Maybe<Scalars["String"]>;
+    languageVars?: Maybe<Array<Maybe<Translation>>>;
+};
+export type LanguagesOutput = {
+    __typename?: "LanguagesOutput";
+    languages?: Maybe<Array<Maybe<Language>>>;
+};
+export type LatLng = {
+    __typename?: "LatLng";
+    lat: Scalars["Float"];
+    lng: Scalars["Float"];
+};
+export type Lineitem = {
+    __typename?: "Lineitem";
+    discounts?: Maybe<Array<Maybe<Discount>>>;
+    duration?: Maybe<Scalars["Int"]>;
+    ferryBooking?: Maybe<FerryBooking>;
+    guiid?: Maybe<Scalars["Int"]>;
+    id?: Maybe<Scalars["Int"]>;
+    isSkiset?: Maybe<Scalars["Boolean"]>;
+    label?: Maybe<Scalars["String"]>;
+    preReserved?: Maybe<Scalars["Boolean"]>;
+    product?: Maybe<Product>;
+    quantity?: Maybe<Scalars["Float"]>;
+    totalAmount?: Maybe<Amount>;
+    totalAmountWithoutDiscount?: Maybe<Amount>;
+};
+export type LoginAnyCustomerTypeInput = {
+    login: Scalars["String"];
+    password: Scalars["String"];
+};
+export type LoginAnyCustomerTypeOutput = {
+    __typename?: "LoginAnyCustomerTypeOutput";
+    service?: Maybe<Service>;
+};
+export type LoginEtoModeInput = {
+    bookingId: Scalars["String"];
+    startDate: Scalars["RslDate"];
+    value: Scalars["String"];
+};
+export type LoginEtoModeOutput = {
+    __typename?: "LoginETOModeOutput";
+    service?: Maybe<Service>;
+};
+export type LoginHash256Input = {
+    cartItemID?: InputMaybe<Scalars["Int"]>;
+    hash: Scalars["String"];
+    login: Scalars["String"];
+    password: Scalars["String"];
+};
+export type LoginHash256Output = {
+    __typename?: "LoginHash256Output";
+    service?: Maybe<Service>;
+};
+export type LoginInput = {
+    login: Scalars["String"];
+    password: Scalars["String"];
+};
+export type LoginOutput = {
+    __typename?: "LoginOutput";
+    service?: Maybe<Service>;
+};
+export type LoginPartnerInput = {
+    login: Scalars["String"];
+    password: Scalars["String"];
+};
+export type LoginPartnerOutput = {
+    __typename?: "LoginPartnerOutput";
+    service?: Maybe<Service>;
+};
+export type LogoutOutput = {
+    __typename?: "LogoutOutput";
+    logout?: Maybe<Scalars["Boolean"]>;
+};
+export type LyraFormTokenInput = {
+    amount: AmountInput;
+    customerAccountContext?: InputMaybe<Scalars["Boolean"]>;
+    globalPay?: InputMaybe<Scalars["Boolean"]>;
+    instalmentId: Scalars["Int"];
+    paymentLinkContext?: InputMaybe<Scalars["Boolean"]>;
+    url?: InputMaybe<PspUrl>;
+};
+export type LyraFormTokenOutput = {
+    __typename?: "LyraFormTokenOutput";
+    formToken?: Maybe<Scalars["String"]>;
+    gatewayDescription?: Maybe<GatewayDescription>;
+    orderId?: Maybe<Scalars["String"]>;
+};
+export declare enum LyraPaymentValidatationStatus {
+    Failure = "FAILURE",
+    Success = "SUCCESS"
+}
+export type LyraPaymentValidationInput = {
+    clientAnswer: Scalars["String"];
+    hashKey: Scalars["String"];
+    orderId?: InputMaybe<Scalars["String"]>;
+};
+export type LyraPaymentValidationOutput = {
+    __typename?: "LyraPaymentValidationOutput";
+    cart?: Maybe<Cart>;
+    lyraStatus?: Maybe<LyraPaymentValidatationStatus>;
+};
+export type MapSelectorData = {
+    __typename?: "MapSelectorData";
+    fileSystemName: Scalars["String"];
+    imageHeight?: Maybe<Scalars["Int"]>;
+    imageWidth?: Maybe<Scalars["Int"]>;
+    listUhDisabled?: Maybe<Array<Maybe<MapUh>>>;
+    listUhOnMap?: Maybe<Array<Maybe<MapUh>>>;
+    listUhSelected?: Maybe<Array<Maybe<MapUh>>>;
+    opacity?: Maybe<Scalars["Float"]>;
+    stayMapInfos?: Maybe<StayMapInfos>;
+    zoom?: Maybe<Scalars["Float"]>;
+};
+export type MapSelectorDataInput = {
+    cartItemID?: InputMaybe<Scalars["Int"]>;
+    stayGuiid: Scalars["Int"];
+};
+export type MapSelectorDataOutput = {
+    __typename?: "MapSelectorDataOutput";
+    mapSelectorData?: Maybe<MapSelectorData>;
+};
+export type MapUh = {
+    __typename?: "MapUH";
+    color: Scalars["String"];
+    coordinates: Array<Maybe<LatLng>>;
+    id: Scalars["String"];
+    label: Scalars["String"];
+    roomTypeCode: Scalars["String"];
+    shape: Scalars["String"];
+    stayGuiid?: Maybe<Scalars["Int"]>;
+    stayRoomIndex?: Maybe<Scalars["Int"]>;
+    strokeColor?: Maybe<Scalars["String"]>;
+    textColor?: Maybe<Scalars["String"]>;
+};
+export type Measurements = {
+    __typename?: "Measurements";
+    calfwidths?: Maybe<Array<Maybe<Calfwidth>>>;
+    footwidths?: Maybe<Array<Maybe<Footwidth>>>;
+    headsizes?: Maybe<Array<Maybe<Headsize>>>;
+    heights?: Maybe<Array<Maybe<Heights>>>;
+    shoesizes?: Maybe<Array<Maybe<Shoesize>>>;
+    unit?: Maybe<Scalars["String"]>;
+    weights?: Maybe<Array<Maybe<Weight>>>;
+};
+export type MeasurementsOutput = {
+    __typename?: "MeasurementsOutput";
+    measurements?: Maybe<Measurements>;
+};
+export type ModuleFacebookActivatedOutput = {
+    __typename?: "ModuleFacebookActivatedOutput";
+    activated?: Maybe<Scalars["Boolean"]>;
+};
+export type Mutation = {
+    __typename?: "Mutation";
+    addBaby?: Maybe<AddBabyOutput>;
+    addCustomerDepositAccountPayments?: Maybe<CustomerDepositAccountPaymentsOutput>;
+    addDiscountCode?: Maybe<DiscountCodeOutput>;
+    addFidelityPointToProduct?: Maybe<FidelityPointToCartOutput>;
+    addGiftCode?: Maybe<GiftCodeOutput>;
+    addObservation?: Maybe<ObservationOutput>;
+    addOccupant?: Maybe<AddOccupantOutput>;
+    addPartnerCustomerAccount?: Maybe<CustomerAccountOutput>;
+    /**
+     *  LANG_gql_partnerLogin
+     *
+     * ---
+     *
+     * ##  LANG_gql_resa
+     * ### LANG_gql_actions
+     */
+    addPartnerToCart?: Maybe<PartnerToCartOutput>;
+    addProductToBooking?: Maybe<ProductToBookingOutput>;
+    addProductToOccupant?: Maybe<ProductToOccupantOutput>;
+    cancelFerryBooking?: Maybe<CancelFerryBookingOutput>;
+    changePassword?: Maybe<ChangePasswordOutput>;
+    chooseFerryProposal?: Maybe<ChooseFerryProposalOutput>;
+    chooseProposalFromKeys?: Maybe<ChooseProposalFromKeysOutput>;
+    chooseRoundTripProposals?: Maybe<ChooseRoundTripProposalsOutput>;
+    confirmFastCheckout?: Maybe<ConfirmFastCheckoutOutput>;
+    createCustomerAccount?: Maybe<CreateCustomerAccountOutput>;
+    createServiceCustomerAccount?: Maybe<CustomerAccountOutput>;
+    disableEnablePartnerCustomerAccount?: Maybe<CustomerAccountOutput>;
+    disableServiceCustomerAccount?: Maybe<CustomerAccountOutput>;
+    doFastCheckin?: Maybe<DoFastCheckinOutput>;
+    doFastCheckout?: Maybe<DoFastCheckoutOutput>;
+    expireSession?: Maybe<ExpireSessionOutput>;
+    facebookLogin?: Maybe<FacebookLoginOutput>;
+    login?: Maybe<LoginOutput>;
+    loginAnyCustomerType?: Maybe<LoginAnyCustomerTypeOutput>;
+    loginETOMode?: Maybe<LoginEtoModeOutput>;
+    loginHash256?: Maybe<LoginHash256Output>;
+    loginPartner?: Maybe<LoginPartnerOutput>;
+    logout?: Maybe<LogoutOutput>;
+    payOnStoredCreditCard?: Maybe<PayOnStoredCreditCardOutput>;
+    redirectPaymentGatewayForAmount?: Maybe<PaymentGatewayForAmountOutput>;
+    redirectPaymentGatewayForCart?: Maybe<PaymentGatewayForCartOutput>;
+    redirectPaymentGatewayForInstalment?: Maybe<PaymentGatewayForInstalmentOutput>;
+    removeBookingFromCart?: Maybe<RemoveBookingFromCartOutput>;
+    removeCartPayments?: Maybe<RemoveCartPaymentsOutput>;
+    removeCustomerAccount?: Maybe<RemoveCustomerAccountOutput>;
+    removeDiscountCode?: Maybe<RemoveDiscountCodeOutput>;
+    removeGiftCode?: Maybe<RemoveGiftCodeOutput>;
+    removeOccupant?: Maybe<RemoveOccupantOutput>;
+    removeStay?: Maybe<RemoveStayOutput>;
+    resetCart?: Maybe<ResetCartOutput>;
+    resetPendingFerryBooking?: Maybe<ResetPendingFerryBookingOutput>;
+    saveCart?: Maybe<SaveCartOutput>;
+    saveFerryBooking?: Maybe<SaveFerryBookingOutput>;
+    setSessionLanguage?: Maybe<UserLanguageOutput>;
+    switchToPartnerConvention?: Maybe<SwitchToPartnerConventionOutput>;
+    unlockBooking?: Maybe<UnlockBookingOutput>;
+    updateBookingCriterias?: Maybe<UpdateBookingCriteriasOutput>;
+    updateCartPaymentMethod?: Maybe<CartPaymentMethodOutput>;
+    updateCartPaymentPlans?: Maybe<CartPaymentPlansOutput>;
+    updateCustomerAccount?: Maybe<CustomerAccountOutput>;
+    updateCustomerBooking?: Maybe<CustomerBookingOutput>;
+    updateFerryAccommodations?: Maybe<UpdateFerryAccommodationsOutput>;
+    updateFerryBooking?: Maybe<UpdateFerryBookingOutput>;
+    updateFerryTravelersInformation?: Maybe<UpdateFerryTravelersInformationOutput>;
+    updateOccupant?: Maybe<OccupantOutput>;
+    updateOccupantSkisetMeasurements?: Maybe<UpdateOccupantSkisetMeasurementsOutput>;
+    updatePartnerAccount?: Maybe<PartnerOutput>;
+    updatePartnerCustomerAccount?: Maybe<CustomerAccountOutput>;
+    updatePartnerPaymentPlans?: Maybe<PartnerPaymentPlansOutput>;
+    updatePayerPaymentPlans?: Maybe<PayerPaymentPlansOutput>;
+    updatePrimaryOccupant?: Maybe<PrimaryOccupantOutput>;
+    updateRoomFromMap?: Maybe<RoomFromMapOutput>;
+    updateServiceCustomerAccount?: Maybe<CustomerAccountOutput>;
+    updateStayTime?: Maybe<StayTimeOutput>;
+    updateTotalOccupants?: Maybe<TotalOccupantsOutput>;
+    validateLyraPayment?: Maybe<LyraPaymentValidationOutput>;
+};
+export type MutationAddBabyArgs = {
+    input: AddBabyInput;
+    session: Session;
+};
+export type MutationAddCustomerDepositAccountPaymentsArgs = {
+    input?: InputMaybe<CustomerDepositAccountPaymentsInput>;
+    session: Session;
+};
+export type MutationAddDiscountCodeArgs = {
+    input: DiscountCodeInput;
+    session: Session;
+};
+export type MutationAddFidelityPointToProductArgs = {
+    input: FidelityPointToProductInput;
+    session: Session;
+};
+export type MutationAddGiftCodeArgs = {
+    input?: InputMaybe<GiftCodeInput>;
+    session: Session;
+};
+export type MutationAddObservationArgs = {
+    input: ObservationInput;
+    session: Session;
+};
+export type MutationAddOccupantArgs = {
+    input: AddOccupantInput;
+    session: Session;
+};
+export type MutationAddPartnerCustomerAccountArgs = {
+    input?: InputMaybe<AddPartnerCustomerAccountInput>;
+    session: Session;
+};
+export type MutationAddPartnerToCartArgs = {
+    input: PartnerToCartInput;
+    session: Session;
+};
+export type MutationAddProductToBookingArgs = {
+    input: ProductToBookingInput;
+    session: Session;
+};
+export type MutationAddProductToOccupantArgs = {
+    input: Array<InputMaybe<ProductToOccupantInput>>;
+    session: Session;
+};
+export type MutationCancelFerryBookingArgs = {
+    input?: InputMaybe<CancelFerryBookingInput>;
+    session: Session;
+};
+export type MutationChangePasswordArgs = {
+    input: ChangePasswordInput;
+    session: Session;
+};
+export type MutationChooseFerryProposalArgs = {
+    input: ChooseFerryProposalInput;
+    session: Session;
+};
+export type MutationChooseProposalFromKeysArgs = {
+    input: ChooseProposalFromKeysInput;
+    session: Session;
+};
+export type MutationChooseRoundTripProposalsArgs = {
+    input: ChooseRoundTripProposalsInput;
+    session: Session;
+};
+export type MutationConfirmFastCheckoutArgs = {
+    input?: InputMaybe<ConfirmFastCheckoutInput>;
+    session: Session;
+};
+export type MutationCreateCustomerAccountArgs = {
+    input?: InputMaybe<CreateCustomerAccountInput>;
+    session: Session;
+};
+export type MutationCreateServiceCustomerAccountArgs = {
+    input?: InputMaybe<CreateServiceCustomerAccountInput>;
+    session: Session;
+};
+export type MutationDisableEnablePartnerCustomerAccountArgs = {
+    input?: InputMaybe<DisableEnablePartnerCustomerAccountInput>;
+    session: Session;
+};
+export type MutationDisableServiceCustomerAccountArgs = {
+    input?: InputMaybe<DisableServiceCustomerAccountInput>;
+    session: Session;
+};
+export type MutationDoFastCheckinArgs = {
+    input?: InputMaybe<DoFastCheckinInput>;
+    session: Session;
+};
+export type MutationDoFastCheckoutArgs = {
+    input?: InputMaybe<DoFastCheckoutInput>;
+    session: Session;
+};
+export type MutationExpireSessionArgs = {
+    session: Session;
+};
+export type MutationFacebookLoginArgs = {
+    input: FacebookLoginInput;
+    session: Session;
+};
+export type MutationLoginArgs = {
+    input: LoginInput;
+    session: Session;
+};
+export type MutationLoginAnyCustomerTypeArgs = {
+    input?: InputMaybe<LoginAnyCustomerTypeInput>;
+    session: Session;
+};
+export type MutationLoginEtoModeArgs = {
+    input: LoginEtoModeInput;
+    session: Session;
+};
+export type MutationLoginHash256Args = {
+    input: LoginHash256Input;
+    session: Session;
+};
+export type MutationLoginPartnerArgs = {
+    input?: InputMaybe<LoginPartnerInput>;
+    session: Session;
+};
+export type MutationLogoutArgs = {
+    session: Session;
+};
+export type MutationPayOnStoredCreditCardArgs = {
+    input?: InputMaybe<PayOnStoredCreditCardInput>;
+    session: Session;
+};
+export type MutationRedirectPaymentGatewayForAmountArgs = {
+    input: PaymentGatewayForAmountInput;
+    session: Session;
+};
+export type MutationRedirectPaymentGatewayForCartArgs = {
+    input: PaymentGatewayForCartInput;
+    session: Session;
+};
+export type MutationRedirectPaymentGatewayForInstalmentArgs = {
+    input: PaymentGatewayForInstalmentInput;
+    session: Session;
+};
+export type MutationRemoveBookingFromCartArgs = {
+    input?: InputMaybe<RemoveBookingFromCartInput>;
+    session: Session;
+};
+export type MutationRemoveCartPaymentsArgs = {
+    session: Session;
+};
+export type MutationRemoveCustomerAccountArgs = {
+    session: Session;
+};
+export type MutationRemoveDiscountCodeArgs = {
+    session: Session;
+};
+export type MutationRemoveGiftCodeArgs = {
+    input?: InputMaybe<RemoveGiftCodeInput>;
+    session: Session;
+};
+export type MutationRemoveOccupantArgs = {
+    input: RemoveOccupantInput;
+    session: Session;
+};
+export type MutationRemoveStayArgs = {
+    input: RemoveStayInput;
+    session: Session;
+};
+export type MutationResetCartArgs = {
+    session: Session;
+};
+export type MutationResetPendingFerryBookingArgs = {
+    session: Session;
+};
+export type MutationSaveCartArgs = {
+    input?: InputMaybe<SaveCartInput>;
+    session: Session;
+};
+export type MutationSaveFerryBookingArgs = {
+    input?: InputMaybe<SaveFerryBookingInput>;
+    session: Session;
+};
+export type MutationSetSessionLanguageArgs = {
+    input: SessionLanguageInput;
+    session: Session;
+};
+export type MutationSwitchToPartnerConventionArgs = {
+    input: SwitchToPartnerConventionInput;
+    session: Session;
+};
+export type MutationUnlockBookingArgs = {
+    input: UnlockBookingInput;
+    session: Session;
+};
+export type MutationUpdateBookingCriteriasArgs = {
+    input: UpdateBookingCriteriasInput;
+    session: Session;
+};
+export type MutationUpdateCartPaymentMethodArgs = {
+    input: CartPaymentMethodInput;
+    session: Session;
+};
+export type MutationUpdateCartPaymentPlansArgs = {
+    input?: InputMaybe<CartPaymentPlansInput>;
+    session: Session;
+};
+export type MutationUpdateCustomerAccountArgs = {
+    input?: InputMaybe<CustomerAccountInput>;
+    session: Session;
+};
+export type MutationUpdateCustomerBookingArgs = {
+    input: CustomerBookingInput;
+    session: Session;
+};
+export type MutationUpdateFerryAccommodationsArgs = {
+    input: UpdateFerryAccommodationsInput;
+    session: Session;
+};
+export type MutationUpdateFerryBookingArgs = {
+    input: UpdateFerryBookingInput;
+    session: Session;
+};
+export type MutationUpdateFerryTravelersInformationArgs = {
+    input: UpdateFerryTravelersInformationInput;
+    session: Session;
+};
+export type MutationUpdateOccupantArgs = {
+    input: OccupantInput;
+    session: Session;
+};
+export type MutationUpdateOccupantSkisetMeasurementsArgs = {
+    input: UpdateOccupantSkisetMeasurementsInput;
+    session: Session;
+};
+export type MutationUpdatePartnerAccountArgs = {
+    input?: InputMaybe<PartnerAccountInput>;
+    session: Session;
+};
+export type MutationUpdatePartnerCustomerAccountArgs = {
+    input?: InputMaybe<UpdatePartnerCustomerAccountInput>;
+    session: Session;
+};
+export type MutationUpdatePartnerPaymentPlansArgs = {
+    input?: InputMaybe<PartnerPaymentPlansInput>;
+    session: Session;
+};
+export type MutationUpdatePayerPaymentPlansArgs = {
+    input?: InputMaybe<PayerPaymentPlansInput>;
+    session: Session;
+};
+export type MutationUpdatePrimaryOccupantArgs = {
+    input: PrimaryOccupantInput;
+    session: Session;
+};
+export type MutationUpdateRoomFromMapArgs = {
+    input: RoomFromMapInput;
+    session: Session;
+};
+export type MutationUpdateServiceCustomerAccountArgs = {
+    input?: InputMaybe<UpdateServiceCustomerAccountInput>;
+    session: Session;
+};
+export type MutationUpdateStayTimeArgs = {
+    input: StayTimeInput;
+    session: Session;
+};
+export type MutationUpdateTotalOccupantsArgs = {
+    input: TotalOccupantsInput;
+    session: Session;
+};
+export type MutationValidateLyraPaymentArgs = {
+    input: LyraPaymentValidationInput;
+    session: Session;
+};
+export type MyLoginInput = {
+    email?: InputMaybe<Scalars["String"]>;
+    firstName?: InputMaybe<Scalars["String"]>;
+    lastName?: InputMaybe<Scalars["String"]>;
+    zipCode?: InputMaybe<Scalars["String"]>;
+};
+export type MyLoginOutput = {
+    __typename?: "MyLoginOutput";
+    login?: Maybe<Scalars["Boolean"]>;
+};
+export type Nationality = {
+    __typename?: "Nationality";
+    code?: Maybe<Scalars["String"]>;
+    label?: Maybe<Scalars["String"]>;
+};
+export type NeobookingTranslationsInput = {
+    languages?: InputMaybe<Array<InputMaybe<Scalars["String"]>>>;
+};
+export type NeobookingTranslationsOutput = {
+    __typename?: "NeobookingTranslationsOutput";
+    translations?: Maybe<Array<Maybe<Language>>>;
+};
+export type ObservationInput = {
+    bookingCartItemIDs?: InputMaybe<Array<InputMaybe<Scalars["Int"]>>>;
+    cartItemID?: InputMaybe<Scalars["Int"]>;
+    observation: Scalars["String"];
+};
+export type ObservationOutput = {
+    __typename?: "ObservationOutput";
+    cart?: Maybe<Cart>;
+};
+export type Occupant = {
+    __typename?: "Occupant";
+    birthDate?: Maybe<Scalars["Date"]>;
+    civility?: Maybe<Civility>;
+    firstName?: Maybe<Scalars["String"]>;
+    giftVoucherCode?: Maybe<Scalars["String"]>;
+    guiid?: Maybe<Scalars["Int"]>;
+    id?: Maybe<Scalars["Int"]>;
+    isAdult?: Maybe<Scalars["Boolean"]>;
+    isBaby?: Maybe<Scalars["Boolean"]>;
+    isChildren1?: Maybe<Scalars["Boolean"]>;
+    isChildren2?: Maybe<Scalars["Boolean"]>;
+    lastName?: Maybe<Scalars["String"]>;
+    lineItems?: Maybe<Array<Maybe<Lineitem>>>;
+    paymentDues?: Maybe<Array<Maybe<PaymentDue>>>;
+    skisetMeasurements?: Maybe<Array<Maybe<OccupantMeasurement>>>;
+    totalAmount?: Maybe<Amount>;
+};
+export type OccupantInput = {
+    birthDate?: InputMaybe<Scalars["Date"]>;
+    cartItemID?: InputMaybe<Scalars["Int"]>;
+    civilityCode?: InputMaybe<Scalars["String"]>;
+    firstName?: InputMaybe<Scalars["String"]>;
+    lastName?: InputMaybe<Scalars["String"]>;
+    occupantGuiid: Scalars["Int"];
+};
+export type OccupantMeasurement = {
+    __typename?: "OccupantMeasurement";
+    measureId: Scalars["Int"];
+    measureType: SkisetMeasureType;
+};
+export type OccupantMeasurementInput = {
+    measureId: Scalars["Int"];
+    measureType: SkisetMeasureType;
+    occupantGuiid: Scalars["Int"];
+};
+export type OccupantOutput = {
+    __typename?: "OccupantOutput";
+    cart?: Maybe<Cart>;
+};
+export type OccupantProductsInput = {
+    cartItemID?: InputMaybe<Scalars["Int"]>;
+    categoryCodes?: InputMaybe<Array<InputMaybe<Scalars["String"]>>>;
+    excludeMandatoryProduct?: InputMaybe<Scalars["Boolean"]>;
+    occupantGuiid: Scalars["Int"];
+};
+export type OccupantProductsOutput = {
+    __typename?: "OccupantProductsOutput";
+    occupantProducts?: Maybe<Array<Maybe<ProductByCategory>>>;
+};
+export declare enum OccupantTypeEnum {
+    IsAdult = "IS_ADULT",
+    IsChildren_1 = "IS_CHILDREN_1",
+    IsChildren_2 = "IS_CHILDREN_2"
+}
+export type OccupantsFromCurrentCustomerInput = {
+    cartItemID?: InputMaybe<Scalars["Int"]>;
+};
+export type OccupantsFromCurrentCustomerOutput = {
+    __typename?: "OccupantsFromCurrentCustomerOutput";
+    occupants?: Maybe<Array<Maybe<Occupant>>>;
+};
+export type Option = {
+    __typename?: "Option";
+    code?: Maybe<Scalars["String"]>;
+    default?: Maybe<Scalars["Boolean"]>;
+    label?: Maybe<Scalars["String"]>;
+};
+export type PartnerAccountInput = {
+    account?: InputMaybe<AccountInput>;
+    address?: InputMaybe<CustomerAddressInput>;
+    birthDate?: InputMaybe<Scalars["Date"]>;
+    civility?: InputMaybe<Scalars["String"]>;
+    contactName?: InputMaybe<Scalars["String"]>;
+    languageCode?: InputMaybe<Scalars["String"]>;
+    partnerName?: InputMaybe<Scalars["String"]>;
+};
+export type PartnerContact = {
+    __typename?: "PartnerContact";
+    mail?: Maybe<Scalars["String"]>;
+    name?: Maybe<Scalars["String"]>;
+    phone1?: Maybe<Scalars["String"]>;
+    phone2?: Maybe<Scalars["String"]>;
+};
+export type PartnerCustomerInfo = {
+    __typename?: "PartnerCustomerInfo";
+    civility?: Maybe<Scalars["String"]>;
+    customerCode?: Maybe<Scalars["String"]>;
+    disabled?: Maybe<Scalars["Boolean"]>;
+    email?: Maybe<Scalars["String"]>;
+    externalCode?: Maybe<Scalars["String"]>;
+    firstName?: Maybe<Scalars["String"]>;
+    name?: Maybe<Scalars["String"]>;
+};
+export type PartnerCustomerInfoOutput = {
+    __typename?: "PartnerCustomerInfoOutput";
+    customers?: Maybe<Array<Maybe<PartnerCustomerInfo>>>;
+};
+export type PartnerOutput = {
+    __typename?: "PartnerOutput";
+    primaryContact?: Maybe<PartnerContact>;
+    service?: Maybe<Service>;
+};
+export type PartnerPaymentPlansInput = {
+    paymentPlan?: InputMaybe<Scalars["String"]>;
+};
+export type PartnerPaymentPlansOutput = {
+    __typename?: "PartnerPaymentPlansOutput";
+    cart?: Maybe<Cart>;
+};
+export type PartnerToCartInput = {
+    partnerCode: Scalars["String"];
+};
+export type PartnerToCartOutput = {
+    __typename?: "PartnerToCartOutput";
+    service?: Maybe<Service>;
+};
+export type Passenger = {
+    __typename?: "Passenger";
+    availablePassengerTypes?: Maybe<Array<Maybe<PassengerType>>>;
+    birthDate: Scalars["Date"];
+    civility?: Maybe<Civility>;
+    firstName?: Maybe<Scalars["String"]>;
+    index?: Maybe<Scalars["Int"]>;
+    lastName: Scalars["String"];
+    nationality?: Maybe<Scalars["String"]>;
+    passengerTypeCode?: Maybe<Scalars["String"]>;
+    passport?: Maybe<Scalars["String"]>;
+    passportExpiry?: Maybe<Scalars["Date"]>;
+};
+export type PassengerInfo = {
+    birthDate?: InputMaybe<Scalars["Date"]>;
+    civility?: InputMaybe<Scalars["String"]>;
+    firstName?: InputMaybe<Scalars["String"]>;
+    index?: InputMaybe<Scalars["Int"]>;
+    lastName?: InputMaybe<Scalars["String"]>;
+    nationality?: InputMaybe<Scalars["String"]>;
+    passport?: InputMaybe<Scalars["String"]>;
+    passportExpiry?: InputMaybe<Scalars["Date"]>;
+    type?: InputMaybe<Scalars["String"]>;
+};
+export type PassengerType = {
+    __typename?: "PassengerType";
+    code: Scalars["String"];
+    label?: Maybe<Scalars["String"]>;
+};
+export type PayerPaymentPlansInput = {
+    paymentPlan?: InputMaybe<Scalars["String"]>;
+};
+export type PayerPaymentPlansOutput = {
+    __typename?: "PayerPaymentPlansOutput";
+    cart?: Maybe<Cart>;
+};
+export type Payment = {
+    __typename?: "Payment";
+    amount?: Maybe<Amount>;
+    date?: Maybe<Scalars["RslDate"]>;
+    guiid?: Maybe<Scalars["Int"]>;
+    id?: Maybe<Scalars["Int"]>;
+    paymentModeLabel?: Maybe<Scalars["String"]>;
+    voucherCode?: Maybe<Scalars["String"]>;
+};
+export type PaymentDue = {
+    __typename?: "PaymentDue";
+    amount?: Maybe<Amount>;
+    code?: Maybe<Scalars["String"]>;
+    creditCard?: Maybe<CreditCard>;
+    date?: Maybe<Scalars["RslDate"]>;
+    guiid?: Maybe<Scalars["Int"]>;
+    id?: Maybe<Scalars["Int"]>;
+    label?: Maybe<Scalars["String"]>;
+    payments?: Maybe<Array<Maybe<Payment>>>;
+    receivedAmount?: Maybe<Amount>;
+    remainingAmount?: Maybe<Amount>;
+    type?: Maybe<PaymentdueType>;
+};
+export type PaymentGatewayForAmountInput = {
+    bookingId: Scalars["Int"];
+    ccAmount: Scalars["BigDecimal"];
+    input: CartPaymentMethodInput;
+    instalmentId: Scalars["Int"];
+};
+export type PaymentGatewayForAmountOutput = {
+    __typename?: "PaymentGatewayForAmountOutput";
+    gateway?: Maybe<Scalars["String"]>;
+};
+export type PaymentGatewayForCartInput = {
+    input: CartPaymentMethodInput;
+    passNewAmountLowerThanPrevious?: InputMaybe<Scalars["Boolean"]>;
+};
+export type PaymentGatewayForCartOutput = {
+    __typename?: "PaymentGatewayForCartOutput";
+    gateway?: Maybe<Scalars["String"]>;
+};
+export type PaymentGatewayForInstalmentInput = {
+    input: CartPaymentMethodInput;
+    instalmentId: Scalars["Int"];
+};
+export type PaymentGatewayForInstalmentOutput = {
+    __typename?: "PaymentGatewayForInstalmentOutput";
+    gateway?: Maybe<Scalars["String"]>;
+};
+export type PaymentMethod = {
+    __typename?: "PaymentMethod";
+    automaticPaymentCode?: Maybe<Scalars["String"]>;
+    /** @deprecated Use 'automaticPaymentMethodOption'. */
+    automaticPaymentMethod?: Maybe<Array<Maybe<Option>>>;
+    automaticPaymentMethodOption?: Maybe<Array<Maybe<PaymentMethodOption>>>;
+    /** @deprecated Use 'paymentMethodOption'. */
+    paymentMethod?: Maybe<Array<Maybe<Option>>>;
+    paymentMethodOption?: Maybe<Array<Maybe<PaymentMethodOption>>>;
+    virtualPaymentCode?: Maybe<Scalars["String"]>;
+};
+export type PaymentMethodOption = {
+    __typename?: "PaymentMethodOption";
+    code?: Maybe<Scalars["String"]>;
+    label?: Maybe<Scalars["String"]>;
+};
+export type PaymentMethodsOutput = {
+    __typename?: "PaymentMethodsOutput";
+    paymentMethod?: Maybe<PaymentMethod>;
+};
+export type PaymentPlan = {
+    __typename?: "PaymentPlan";
+    cartItemID?: Maybe<Scalars["Int"]>;
+    cmsCriterias?: Maybe<Array<Maybe<CriteriaValue>>>;
+    code?: Maybe<Scalars["String"]>;
+    isDefault?: Maybe<Scalars["Boolean"]>;
+    label?: Maybe<Scalars["String"]>;
+    occupantPaymentDues?: Maybe<Array<Maybe<PaymentDue>>>;
+    partnerPaymentDues?: Maybe<Array<Maybe<PaymentDue>>>;
+    paymentMethod?: Maybe<PaymentMethod>;
+};
+export type PaymentPlansInput = {
+    cartItemID?: InputMaybe<Scalars["Int"]>;
+};
+export type PaymentPlansOutput = {
+    __typename?: "PaymentPlansOutput";
+    paymentPlans?: Maybe<Array<Maybe<PaymentPlan>>>;
+};
+export declare enum PaymentdueType {
+    Arrhes = "ARRHES",
+    Cashless = "CASHLESS",
+    Monthly = "MONTHLY",
+    Solde = "SOLDE"
+}
+export type PendingFerryBookingOutput = {
+    __typename?: "PendingFerryBookingOutput";
+    ferryBooking?: Maybe<FerryBooking>;
+};
+export type Port = {
+    __typename?: "Port";
+    label?: Maybe<Scalars["String"]>;
+    portName?: Maybe<Scalars["String"]>;
+};
+export type PostCodeApiDetailInput = {
+    apiSession: Scalars["String"];
+    context: Scalars["String"];
+};
+export type PostCodeApiDetailOutput = {
+    __typename?: "PostCodeApiDetailOutput";
+    code?: Maybe<Scalars["String"]>;
+};
+export type PostCodeApiSimpleInput = {
+    country?: InputMaybe<Scalars["String"]>;
+    postApiContext?: InputMaybe<Scalars["String"]>;
+    term: Scalars["String"];
+};
+export type PostCodeApiSimpleOutput = {
+    __typename?: "PostCodeApiSimpleOutput";
+    code?: Maybe<Scalars["String"]>;
+};
+export type PrimaryOccupant = {
+    __typename?: "PrimaryOccupant";
+    address?: Maybe<Address>;
+    birthDate?: Maybe<Scalars["RslDate"]>;
+    civility?: Maybe<Civility>;
+    customerCode?: Maybe<Scalars["String"]>;
+    firstName?: Maybe<Scalars["String"]>;
+    id?: Maybe<Scalars["Int"]>;
+    /** @deprecated Use 'occupantLanguage'. */
+    language?: Maybe<Option>;
+    lastName?: Maybe<Scalars["String"]>;
+    occupantLanguage?: Maybe<Language>;
+};
+export type PrimaryOccupantInput = {
+    address?: InputMaybe<CustomerAddressInput>;
+    birthDate?: InputMaybe<Scalars["Date"]>;
+    bookingId?: InputMaybe<Scalars["Int"]>;
+    cartItemID?: InputMaybe<Scalars["Int"]>;
+    civility?: InputMaybe<Scalars["String"]>;
+    firstName: Scalars["String"];
+    languageCode?: InputMaybe<Scalars["String"]>;
+    lastName: Scalars["String"];
+};
+export type PrimaryOccupantOutput = {
+    __typename?: "PrimaryOccupantOutput";
+    cart?: Maybe<Cart>;
+};
+export type PrivilegeCard = {
+    __typename?: "PrivilegeCard";
+    active?: Maybe<Scalars["Boolean"]>;
+    bookingId?: Maybe<Scalars["Int"]>;
+    endDate?: Maybe<Scalars["Date"]>;
+    label?: Maybe<Scalars["String"]>;
+    points?: Maybe<Scalars["Int"]>;
+    service?: Maybe<Service>;
+    startDate?: Maybe<Scalars["Date"]>;
+    type?: Maybe<Scalars["String"]>;
+};
+export type PrivilegeCardType = {
+    __typename?: "PrivilegeCardType";
+    code?: Maybe<Scalars["String"]>;
+    label?: Maybe<Scalars["String"]>;
+};
+export type PrivilegeCardTypesOutput = {
+    __typename?: "PrivilegeCardTypesOutput";
+    privilegeCardTypeList?: Maybe<Array<Maybe<PrivilegeCardType>>>;
+    /** @deprecated Use 'privilegeCardTypeList'. */
+    privilegeCardTypes?: Maybe<Array<Maybe<Option>>>;
+};
+export type Product = {
+    __typename?: "Product";
+    ageFrom?: Maybe<Scalars["Int"]>;
+    ageTo?: Maybe<Scalars["Int"]>;
+    categoryCode?: Maybe<Scalars["String"]>;
+    categoryLabel?: Maybe<Scalars["String"]>;
+    cmsCriterias?: Maybe<Array<Maybe<CriteriaValue>>>;
+    code: Scalars["String"];
+    description?: Maybe<Scalars["String"]>;
+    distributionType?: Maybe<ProductDistributionType>;
+    id: Scalars["Int"];
+    imagePath?: Maybe<Scalars["String"]>;
+    isBase?: Maybe<Scalars["Boolean"]>;
+    isPackage?: Maybe<Scalars["Boolean"]>;
+    label?: Maybe<Scalars["String"]>;
+    linkedToMap?: Maybe<Scalars["Boolean"]>;
+    mandatory?: Maybe<Scalars["Boolean"]>;
+    occupantApplication?: Maybe<ProductOccupantApplication>;
+    originalLabel?: Maybe<Scalars["String"]>;
+    otherCode?: Maybe<Scalars["String"]>;
+    otherLabel?: Maybe<Scalars["String"]>;
+    price?: Maybe<Amount>;
+    priceWithoutDiscounts?: Maybe<Amount>;
+    productCriterias?: Maybe<Array<Maybe<CriteriaValue>>>;
+    /** @deprecated Use 'quantityMax'. */
+    quantity?: Maybe<Scalars["Int"]>;
+    quantityMax?: Maybe<Scalars["Int"]>;
+    stock?: Maybe<Scalars["Int"]>;
+    subProducts?: Maybe<Array<Maybe<Product>>>;
+    webLabel?: Maybe<Scalars["String"]>;
+};
+export type ProductByCategory = {
+    __typename?: "ProductByCategory";
+    categoryCode?: Maybe<Scalars["String"]>;
+    categoryLabel?: Maybe<Scalars["String"]>;
+    products?: Maybe<Array<Maybe<Product>>>;
+};
+export type ProductCategoriesOutput = {
+    __typename?: "ProductCategoriesOutput";
+    productCategories?: Maybe<Array<Maybe<ProductCategory>>>;
+};
+export type ProductCategory = {
+    __typename?: "ProductCategory";
+    code?: Maybe<Scalars["String"]>;
+    label?: Maybe<Scalars["String"]>;
+    order?: Maybe<Scalars["Int"]>;
+};
+export declare enum ProductDistributionType {
+    Campaign = "CAMPAIGN",
+    Global = "GLOBAL",
+    Occupant = "OCCUPANT",
+    Room = "ROOM"
+}
+export declare enum ProductOccupantApplication {
+    Everybody = "EVERYBODY",
+    EverybodyInRoom = "EVERYBODY_IN_ROOM",
+    Himself = "HIMSELF"
+}
+export type ProductOption = {
+    __typename?: "ProductOption";
+    code?: Maybe<Scalars["String"]>;
+    label?: Maybe<Scalars["String"]>;
+};
+export type ProductToBookingInput = {
+    cartItemID?: InputMaybe<Scalars["Int"]>;
+    productCode: Scalars["String"];
+    productID: Scalars["Int"];
+    quantity?: InputMaybe<Scalars["Int"]>;
+    stayGuiid?: InputMaybe<Scalars["Int"]>;
+};
+export type ProductToBookingOutput = {
+    __typename?: "ProductToBookingOutput";
+    cart?: Maybe<Cart>;
+};
+export type ProductToOccupantInput = {
+    occupantGuiid: Scalars["Int"];
+    productCode: Scalars["String"];
+    productID: Scalars["Int"];
+    quantity: Scalars["Int"];
+};
+export type ProductToOccupantOutput = {
+    __typename?: "ProductToOccupantOutput";
+    cart?: Maybe<Cart>;
+};
+export type ProductsForOccupantOutput = {
+    __typename?: "ProductsForOccupantOutput";
+    hasProductsForOccupant?: Maybe<Scalars["Boolean"]>;
+};
+export type PropertiesInput = {
+    propertyIds?: InputMaybe<Array<InputMaybe<Scalars["Int"]>>>;
+    roomFeatureCodes?: InputMaybe<Array<InputMaybe<Scalars["String"]>>>;
+    stayType?: InputMaybe<Scalars["Int"]>;
+};
+export type PropertiesOutput = {
+    __typename?: "PropertiesOutput";
+    properties?: Maybe<Array<Maybe<Property>>>;
+};
+export type Property = {
+    __typename?: "Property";
+    address?: Maybe<Address>;
+    cmsCriterias?: Maybe<Array<Maybe<CriteriaValue>>>;
+    description?: Maybe<Scalars["String"]>;
+    id?: Maybe<Scalars["Int"]>;
+    imagePath?: Maybe<Scalars["String"]>;
+    label?: Maybe<Scalars["String"]>;
+    roomFeatures?: Maybe<Array<Maybe<CriteriaValue>>>;
+};
+export type Proposal = {
+    __typename?: "Proposal";
+    baseProductPrice?: Maybe<Amount>;
+    discountInfo?: Maybe<Scalars["String"]>;
+    distribution?: Maybe<Distribution>;
+    endDate?: Maybe<Scalars["Date"]>;
+    imagePath?: Maybe<Scalars["String"]>;
+    isAlternativeProposal?: Maybe<Scalars["Boolean"]>;
+    isCounterProposal?: Maybe<Scalars["Boolean"]>;
+    lineItems?: Maybe<Array<Maybe<Lineitem>>>;
+    nbDays?: Maybe<Scalars["Int"]>;
+    price?: Maybe<Amount>;
+    priceWithoutDiscount?: Maybe<Amount>;
+    /** @deprecated Use 'productOption'. */
+    product?: Maybe<Option>;
+    productOption?: Maybe<ProductOption>;
+    propertyId?: Maybe<Scalars["Int"]>;
+    /**
+     *  Clé de proposition
+     *
+     * ---
+     *
+     * ## test
+     * ### test2
+     */
+    proposalKey?: Maybe<Scalars["String"]>;
+    roomFeaturesValues?: Maybe<Array<Maybe<CriteriaValue>>>;
+    startDate?: Maybe<Scalars["Date"]>;
+    stock?: Maybe<Scalars["String"]>;
+};
+export type ProposalByProperty = {
+    __typename?: "ProposalByProperty";
+    property?: Maybe<Property>;
+    proposals: Array<Proposal>;
+};
+export type ProposalByRoomTypesInput = {
+    baseProductCode: Scalars["String"];
+    campaignCode?: InputMaybe<Scalars["String"]>;
+    childrenBirthdate?: InputMaybe<Array<InputMaybe<Scalars["Date"]>>>;
+    endDate?: InputMaybe<Scalars["Date"]>;
+    nbAdults: Scalars["Int"];
+    nbBabies?: InputMaybe<Scalars["Int"]>;
+    nbChildren1?: InputMaybe<Scalars["Int"]>;
+    nbChildren2?: InputMaybe<Scalars["Int"]>;
+    nbDays?: InputMaybe<Scalars["Int"]>;
+    propertyId: Scalars["Int"];
+    roomTypeCodes: Array<InputMaybe<Scalars["String"]>>;
+    startDate: Scalars["Date"];
+};
+export type ProposalByRoomTypesOutput = {
+    __typename?: "ProposalByRoomTypesOutput";
+    proposals: Array<Proposal>;
+};
+export type ProposalsByKeysInput = {
+    proposalKeys: Array<Scalars["String"]>;
+};
+export type ProposalsByKeysOutput = {
+    __typename?: "ProposalsByKeysOutput";
+    proposals: Array<Proposal>;
+};
+export type ProposalsByPropertiesInput = {
+    criterias?: InputMaybe<Criterias>;
+};
+export type ProposalsByPropertiesOutput = {
+    __typename?: "ProposalsByPropertiesOutput";
+    proposalByProperty: Array<ProposalByProperty>;
+};
+export type ProposalsInput = {
+    criterias?: InputMaybe<Criterias>;
+};
+export type ProposalsOutput = {
+    __typename?: "ProposalsOutput";
+    proposals: Array<Proposal>;
+};
+export type PspUrl = {
+    acceptUrl?: InputMaybe<Scalars["String"]>;
+    cancelUrl?: InputMaybe<Scalars["String"]>;
+    declineUrl?: InputMaybe<Scalars["String"]>;
+    exceptionUrl?: InputMaybe<Scalars["String"]>;
+};
+export type PspUrlOutput = {
+    __typename?: "PspUrlOutput";
+    acceptUrl?: Maybe<Scalars["String"]>;
+    cancelUrl?: Maybe<Scalars["String"]>;
+    declineUrl?: Maybe<Scalars["String"]>;
+    exceptionUrl?: Maybe<Scalars["String"]>;
+};
+/** test query */
+export type Query = {
+    __typename?: "Query";
+    checkApiAlive?: Maybe<ApiAliveOutput>;
+    checkModuleFacebookActivated?: Maybe<ModuleFacebookActivatedOutput>;
+    checkSessionActivated?: Maybe<SessionActivatedOutput>;
+    checkValidLogin?: Maybe<ValidLoginOutput>;
+    getAccommodationProducts?: Maybe<AccommodationProductsOutput>;
+    getAllOccupantProductsAllAgeRanges?: Maybe<AllOccupantProductsAllAgeRangesOutput>;
+    getAlternativeProposalRulesForContractFolder?: Maybe<AlternativeProposalRulesForContractFolderOutput>;
+    getAvailForRoomTypes?: Maybe<AvailForRoomTypesOutput>;
+    getAvailableRoomFeatures?: Maybe<AvailableRoomFeaturesOutput>;
+    getBookingDocuments?: Maybe<BookingDocumentsOutput>;
+    getBookingProducts?: Maybe<BookingProductsOutput>;
+    getBookingRecordCriterias?: Maybe<BookingRecordCriteriasOutput>;
+    getBrochures?: Maybe<BrochuresOutput>;
+    getCampaigns?: Maybe<CampaignsOutput>;
+    getCart?: Maybe<CartOutput>;
+    getCivilities?: Maybe<CivilitiesOutput>;
+    getCountries?: Maybe<CountriesOutput>;
+    /**
+     *  LANG_gql_getCriteria
+     *
+     * ### LANG_gql_actions
+     */
+    getCriteriaInformation?: Maybe<CriteriaInformationOutput>;
+    getCurrentCustomerAccount?: Maybe<CurrentCustomerAccountOutput>;
+    getCustomerBookings?: Maybe<CustomerBookingsOutput>;
+    getCustomerCriterias?: Maybe<CustomerCriteriasOutput>;
+    getCustomerDepositAccounts?: Maybe<CustomerDepositAccountsOutput>;
+    getCustomerGiftCodes?: Maybe<CustomerGiftCodesOutput>;
+    getCustomerLoyaltyPoints?: Maybe<CustomerLoyaltyPointsOutput>;
+    getCustomerPrivilegeCards?: Maybe<CustomerPrivilegeCardsOutput>;
+    getFerryAddonCategories?: Maybe<FerryAddonCategoriesOutput>;
+    getFerryAvailableAccommodations?: Maybe<FerryAvailableAccommodationsOutput>;
+    getFerryCars?: Maybe<FerryCarsOutput>;
+    getFerryCivilities?: Maybe<FerryCivilitiesOutput>;
+    getFerryCrossings?: Maybe<FerryCrossingsOutput>;
+    getFerryNationalities?: Maybe<FerryNationalitiesOutput>;
+    getFerryPorts?: Maybe<FerryPortsOutput>;
+    getFerryProducts?: Maybe<FerryProductsOutput>;
+    getFerryProposals?: Maybe<FerryProposalsOutput>;
+    getFerryTrailerCategories?: Maybe<FerryTrailerCategoriesOutput>;
+    getFerryVehicleCategories?: Maybe<FerryVehicleCategoriesOutput>;
+    getFerryVehicleFuels?: Maybe<FerryVehicleFuelsOutput>;
+    getFidelityLogs?: Maybe<FidelityLogsOutput>;
+    getFidelityRules?: Maybe<FidelityRulesOutput>;
+    getLanguages?: Maybe<LanguagesOutput>;
+    getLyraFormToken?: Maybe<LyraFormTokenOutput>;
+    getMapSelectorData?: Maybe<MapSelectorDataOutput>;
+    getMyLogin?: Maybe<MyLoginOutput>;
+    getNeobookingTranslations?: Maybe<NeobookingTranslationsOutput>;
+    getOccupantProducts?: Maybe<OccupantProductsOutput>;
+    getOccupantsFromCurrentCustomer?: Maybe<OccupantsFromCurrentCustomerOutput>;
+    getPartner?: Maybe<PartnerOutput>;
+    getPartnerCustomers?: Maybe<PartnerCustomerInfoOutput>;
+    getPaymentMethods?: Maybe<PaymentMethodsOutput>;
+    getPaymentPlans?: Maybe<PaymentPlansOutput>;
+    getPendingFerryBooking?: Maybe<PendingFerryBookingOutput>;
+    getPostCodeApiDetail?: Maybe<PostCodeApiDetailOutput>;
+    getPostCodeApiSimple?: Maybe<PostCodeApiSimpleOutput>;
+    /**
+     *  LANG_gql_getPrivilegeCards
+     *
+     * ---
+     *
+     * ## LANG_gql_client
+     * ### LANG_gql_infos
+     */
+    getPrivilegeCardTypes?: Maybe<PrivilegeCardTypesOutput>;
+    getProductCategories?: Maybe<ProductCategoriesOutput>;
+    getProperties?: Maybe<PropertiesOutput>;
+    getProposalByRoomTypes?: Maybe<ProposalByRoomTypesOutput>;
+    getProposals?: Maybe<ProposalsOutput>;
+    getProposalsByKeys?: Maybe<ProposalsByKeysOutput>;
+    getProposalsByProperties?: Maybe<ProposalsByPropertiesOutput>;
+    getRelationships?: Maybe<RelationshipOutput>;
+    getResalysErrorList?: Maybe<ResalysErrorListOutput>;
+    getResalysVersion?: Maybe<ResalysVersionOutput>;
+    getRoomTypeCategories?: Maybe<RoomTypeCategoriesOutput>;
+    getRoomTypes?: Maybe<RoomTypesOutput>;
+    getSalesChannelMode?: Maybe<SalesChannelModeOutput>;
+    /**
+     * getSession
+     * Il devra etre votre premier appel.<br/>
+     *
+     * Il utilisera comme paramètres les informations d'utilisateurs configurés dans Resalys.
+     * Vous obtiendrez une session en réponse.\n
+     * Cette session sera votre clé d'entrée pour toutes les autres requêtes.
+     * Elle est également la clé mémoire qui stocke coté serveur toutes les actions que vous effectuez.
+     * Pour la suite des tests, je vous invite à copier
+     * le résultat de votre session dans l'objet session des "QUERY VARIABLES"
+     * en lieux et place de "@session".
+     */
+    getSession?: Maybe<SessionOutput>;
+    getSkisetMeasurements?: Maybe<MeasurementsOutput>;
+    getTranslations?: Maybe<TranslationsOutput>;
+    getUserLanguage?: Maybe<UserLanguageOutput>;
+    hasProductsForOccupant?: Maybe<ProductsForOccupantOutput>;
+    renewPassword?: Maybe<RenewPasswordOutput>;
+    requestBrochure?: Maybe<BrochureOutput>;
+};
+/** test query */
+export type QueryCheckModuleFacebookActivatedArgs = {
+    session: Session;
+};
+/** test query */
+export type QueryCheckSessionActivatedArgs = {
+    session: Session;
+};
+/** test query */
+export type QueryCheckValidLoginArgs = {
+    input: ValidLoginInput;
+    session: Session;
+};
+/** test query */
+export type QueryGetAccommodationProductsArgs = {
+    input: AccommodationProductsInput;
+    session: Session;
+};
+/** test query */
+export type QueryGetAllOccupantProductsAllAgeRangesArgs = {
+    input: AllOccupantProductsAllAgeRangesInput;
+    session: Session;
+};
+/** test query */
+export type QueryGetAlternativeProposalRulesForContractFolderArgs = {
+    input: AlternativeProposalRulesForContractFolderInput;
+    session: Session;
+};
+/** test query */
+export type QueryGetAvailForRoomTypesArgs = {
+    input?: InputMaybe<AvailForRoomTypesInput>;
+    session: Session;
+};
+/** test query */
+export type QueryGetAvailableRoomFeaturesArgs = {
+    input?: InputMaybe<AvailableRoomFeaturesInput>;
+    session: Session;
+};
+/** test query */
+export type QueryGetBookingDocumentsArgs = {
+    input: BookingDocumentsInput;
+    session: Session;
+};
+/** test query */
+export type QueryGetBookingProductsArgs = {
+    input?: InputMaybe<BookingProductsInput>;
+    session: Session;
+};
+/** test query */
+export type QueryGetBookingRecordCriteriasArgs = {
+    session: Session;
+};
+/** test query */
+export type QueryGetBrochuresArgs = {
+    session: Session;
+};
+/** test query */
+export type QueryGetCampaignsArgs = {
+    session: Session;
+};
+/** test query */
+export type QueryGetCartArgs = {
+    session: Session;
+};
+/** test query */
+export type QueryGetCivilitiesArgs = {
+    session: Session;
+};
+/** test query */
+export type QueryGetCountriesArgs = {
+    session: Session;
+};
+/** test query */
+export type QueryGetCriteriaInformationArgs = {
+    input?: InputMaybe<CriteriaInformationInput>;
+    session: Session;
+};
+/** test query */
+export type QueryGetCurrentCustomerAccountArgs = {
+    session: Session;
+};
+/** test query */
+export type QueryGetCustomerBookingsArgs = {
+    input?: InputMaybe<CustomerBookingsInput>;
+    session: Session;
+};
+/** test query */
+export type QueryGetCustomerCriteriasArgs = {
+    input?: InputMaybe<CustomerCriteriasInput>;
+    session: Session;
+};
+/** test query */
+export type QueryGetCustomerDepositAccountsArgs = {
+    session: Session;
+};
+/** test query */
+export type QueryGetCustomerGiftCodesArgs = {
+    session: Session;
+};
+/** test query */
+export type QueryGetCustomerLoyaltyPointsArgs = {
+    session: Session;
+};
+/** test query */
+export type QueryGetCustomerPrivilegeCardsArgs = {
+    session: Session;
+};
+/** test query */
+export type QueryGetFerryAddonCategoriesArgs = {
+    session: Session;
+};
+/** test query */
+export type QueryGetFerryAvailableAccommodationsArgs = {
+    session: Session;
+};
+/** test query */
+export type QueryGetFerryCarsArgs = {
+    session: Session;
+};
+/** test query */
+export type QueryGetFerryCivilitiesArgs = {
+    session: Session;
+};
+/** test query */
+export type QueryGetFerryCrossingsArgs = {
+    input?: InputMaybe<FerryCrossingsInput>;
+    session: Session;
+};
+/** test query */
+export type QueryGetFerryNationalitiesArgs = {
+    session: Session;
+};
+/** test query */
+export type QueryGetFerryPortsArgs = {
+    session: Session;
+};
+/** test query */
+export type QueryGetFerryProductsArgs = {
+    session: Session;
+};
+/** test query */
+export type QueryGetFerryProposalsArgs = {
+    input: FerryProposalsInput;
+    session: Session;
+};
+/** test query */
+export type QueryGetFerryTrailerCategoriesArgs = {
+    session: Session;
+};
+/** test query */
+export type QueryGetFerryVehicleCategoriesArgs = {
+    session: Session;
+};
+/** test query */
+export type QueryGetFerryVehicleFuelsArgs = {
+    session: Session;
+};
+/** test query */
+export type QueryGetFidelityLogsArgs = {
+    session: Session;
+};
+/** test query */
+export type QueryGetFidelityRulesArgs = {
+    session: Session;
+};
+/** test query */
+export type QueryGetLanguagesArgs = {
+    session: Session;
+};
+/** test query */
+export type QueryGetLyraFormTokenArgs = {
+    input: LyraFormTokenInput;
+    session: Session;
+};
+/** test query */
+export type QueryGetMapSelectorDataArgs = {
+    input?: InputMaybe<MapSelectorDataInput>;
+    session: Session;
+};
+/** test query */
+export type QueryGetMyLoginArgs = {
+    input?: InputMaybe<MyLoginInput>;
+    session: Session;
+};
+/** test query */
+export type QueryGetNeobookingTranslationsArgs = {
+    input?: InputMaybe<NeobookingTranslationsInput>;
+    session: Session;
+};
+/** test query */
+export type QueryGetOccupantProductsArgs = {
+    input?: InputMaybe<OccupantProductsInput>;
+    session: Session;
+};
+/** test query */
+export type QueryGetOccupantsFromCurrentCustomerArgs = {
+    input?: InputMaybe<OccupantsFromCurrentCustomerInput>;
+    session: Session;
+};
+/** test query */
+export type QueryGetPartnerArgs = {
+    session: Session;
+};
+/** test query */
+export type QueryGetPartnerCustomersArgs = {
+    session: Session;
+};
+/** test query */
+export type QueryGetPaymentMethodsArgs = {
+    session: Session;
+};
+/** test query */
+export type QueryGetPaymentPlansArgs = {
+    input?: InputMaybe<PaymentPlansInput>;
+    session: Session;
+};
+/** test query */
+export type QueryGetPendingFerryBookingArgs = {
+    session: Session;
+};
+/** test query */
+export type QueryGetPostCodeApiDetailArgs = {
+    input: PostCodeApiDetailInput;
+    session: Session;
+};
+/** test query */
+export type QueryGetPostCodeApiSimpleArgs = {
+    input: PostCodeApiSimpleInput;
+    session: Session;
+};
+/** test query */
+export type QueryGetPrivilegeCardTypesArgs = {
+    session: Session;
+};
+/** test query */
+export type QueryGetProductCategoriesArgs = {
+    session: Session;
+};
+/** test query */
+export type QueryGetPropertiesArgs = {
+    authentication: AuthenticationInput;
+    input?: InputMaybe<PropertiesInput>;
+};
+/** test query */
+export type QueryGetProposalByRoomTypesArgs = {
+    input: ProposalByRoomTypesInput;
+    session: Session;
+};
+/** test query */
+export type QueryGetProposalsArgs = {
+    input?: InputMaybe<ProposalsInput>;
+    session: Session;
+};
+/** test query */
+export type QueryGetProposalsByKeysArgs = {
+    input: ProposalsByKeysInput;
+    session: Session;
+};
+/** test query */
+export type QueryGetProposalsByPropertiesArgs = {
+    input?: InputMaybe<ProposalsByPropertiesInput>;
+    session: Session;
+};
+/** test query */
+export type QueryGetRelationshipsArgs = {
+    session: Session;
+};
+/** test query */
+export type QueryGetResalysErrorListArgs = {
+    session: Session;
+};
+/** test query */
+export type QueryGetResalysVersionArgs = {
+    session: Session;
+};
+/** test query */
+export type QueryGetRoomTypeCategoriesArgs = {
+    input: RoomTypeCategoriesInput;
+    session: Session;
+};
+/** test query */
+export type QueryGetRoomTypesArgs = {
+    input?: InputMaybe<RoomTypesInput>;
+    session: Session;
+};
+/** test query */
+export type QueryGetSalesChannelModeArgs = {
+    session: Session;
+};
+/** test query */
+export type QueryGetSessionArgs = {
+    input?: InputMaybe<SessionInput>;
+};
+/** test query */
+export type QueryGetSkisetMeasurementsArgs = {
+    session: Session;
+};
+/** test query */
+export type QueryGetTranslationsArgs = {
+    input?: InputMaybe<TranslationsInput>;
+    session: Session;
+};
+/** test query */
+export type QueryGetUserLanguageArgs = {
+    session: Session;
+};
+/** test query */
+export type QueryHasProductsForOccupantArgs = {
+    input?: InputMaybe<HasProductsForOccupantInput>;
+    session: Session;
+};
+/** test query */
+export type QueryRenewPasswordArgs = {
+    input?: InputMaybe<RenewPasswordInput>;
+    session: Session;
+};
+/** test query */
+export type QueryRequestBrochureArgs = {
+    input?: InputMaybe<BrochureInput>;
+    session: Session;
+};
+export type Relationship = {
+    __typename?: "Relationship";
+    id: Scalars["Int"];
+    label?: Maybe<Scalars["String"]>;
+};
+export type RelationshipOutput = {
+    __typename?: "RelationshipOutput";
+    relationships?: Maybe<Array<Maybe<Relationship>>>;
+};
+export type RemoveBookingFromCartInput = {
+    bookingCartItemID: Scalars["Int"];
+};
+export type RemoveBookingFromCartOutput = {
+    __typename?: "RemoveBookingFromCartOutput";
+    cart?: Maybe<Cart>;
+};
+export type RemoveCartPaymentsOutput = {
+    __typename?: "RemoveCartPaymentsOutput";
+    removed?: Maybe<Scalars["Boolean"]>;
+};
+export type RemoveCustomerAccountOutput = {
+    __typename?: "RemoveCustomerAccountOutput";
+    removed?: Maybe<Scalars["Boolean"]>;
+};
+export type RemoveDiscountCodeOutput = {
+    __typename?: "RemoveDiscountCodeOutput";
+    cart?: Maybe<Cart>;
+};
+export type RemoveFerryInput = {
+    ferryID: Scalars["String"];
+};
+export type RemoveFerryOutput = {
+    __typename?: "RemoveFerryOutput";
+    cart?: Maybe<Cart>;
+};
+export type RemoveGiftCodeInput = {
+    cartItemID?: InputMaybe<Scalars["Int"]>;
+    giftCode: Scalars["String"];
+};
+export type RemoveGiftCodeOutput = {
+    __typename?: "RemoveGiftCodeOutput";
+    cart?: Maybe<Cart>;
+};
+export type RemoveOccupantInput = {
+    cartItemID?: InputMaybe<Scalars["Int"]>;
+    occupantGuiid: Scalars["Int"];
+};
+export type RemoveOccupantOutput = {
+    __typename?: "RemoveOccupantOutput";
+    cart?: Maybe<Cart>;
+};
+export type RemoveStayInput = {
+    lastStayRemoveAllFerryConfirmed?: InputMaybe<Scalars["Boolean"]>;
+    stayGuiid: Scalars["Int"];
+};
+export type RemoveStayOutput = {
+    __typename?: "RemoveStayOutput";
+    cart?: Maybe<Cart>;
+};
+export type RenewPasswordInput = {
+    mail?: InputMaybe<Scalars["String"]>;
+};
+export type RenewPasswordOutput = {
+    __typename?: "RenewPasswordOutput";
+    renewPasswordDemand?: Maybe<Scalars["Boolean"]>;
+};
+export type ResalysError = {
+    __typename?: "ResalysError";
+    code?: Maybe<Scalars["Int"]>;
+    message?: Maybe<Scalars["String"]>;
+};
+export type ResalysErrorListOutput = {
+    __typename?: "ResalysErrorListOutput";
+    errorList?: Maybe<Array<Maybe<ResalysError>>>;
+};
+export type ResalysVersionOutput = {
+    __typename?: "ResalysVersionOutput";
+    version?: Maybe<Scalars["String"]>;
+};
+export type ResetCartOutput = {
+    __typename?: "ResetCartOutput";
+    cart?: Maybe<Cart>;
+};
+export type ResetPendingFerryBookingOutput = {
+    __typename?: "ResetPendingFerryBookingOutput";
+    ferryBooking?: Maybe<FerryBooking>;
+};
+export type RoomFeature = {
+    __typename?: "RoomFeature";
+    categoryLabel?: Maybe<Scalars["String"]>;
+    code: Scalars["String"];
+    label?: Maybe<Scalars["String"]>;
+    options?: Maybe<Array<Maybe<RoomFeatureOption>>>;
+};
+export type RoomFeatureOption = {
+    __typename?: "RoomFeatureOption";
+    code: Scalars["String"];
+    label?: Maybe<Scalars["String"]>;
+};
+export type RoomFeatureValue = {
+    code: Scalars["String"];
+    mandatory?: InputMaybe<Scalars["Boolean"]>;
+    value: Scalars["String"];
+};
+export type RoomFromMapInput = {
+    cartItemID?: InputMaybe<Scalars["Int"]>;
+    mapUHID: Array<InputMaybe<Scalars["String"]>>;
+    stayGuiid: Scalars["Int"];
+};
+export type RoomFromMapOutput = {
+    __typename?: "RoomFromMapOutput";
+    cart?: Maybe<Cart>;
+};
+export type RoomInfos = {
+    __typename?: "RoomInfos";
+    commercialRoomTypeCode?: Maybe<Scalars["String"]>;
+    commercialRoomTypeLabel?: Maybe<Scalars["String"]>;
+    nbRooms?: Maybe<Scalars["Int"]>;
+};
+export type RoomType = {
+    __typename?: "RoomType";
+    categoryCode?: Maybe<Scalars["String"]>;
+    categoryLabel?: Maybe<Scalars["String"]>;
+    cmsCriterias?: Maybe<Array<Maybe<CriteriaValue>>>;
+    code: Scalars["String"];
+    description?: Maybe<Scalars["String"]>;
+    label?: Maybe<Scalars["String"]>;
+    pax?: Maybe<Scalars["Int"]>;
+    paxMax?: Maybe<Scalars["Int"]>;
+    propertyId?: Maybe<Scalars["Int"]>;
+    quantity?: Maybe<Scalars["Int"]>;
+    roomFeatures?: Maybe<Array<Maybe<CriteriaValue>>>;
+    webLabel?: Maybe<Scalars["String"]>;
+};
+export type RoomTypeCategoriesInput = {
+    propertyId: Scalars["Int"];
+};
+export type RoomTypeCategoriesOutput = {
+    __typename?: "RoomTypeCategoriesOutput";
+    roomTypeCategories?: Maybe<Array<Maybe<RoomTypeCategory>>>;
+};
+export type RoomTypeCategory = {
+    __typename?: "RoomTypeCategory";
+    code?: Maybe<Scalars["String"]>;
+    label?: Maybe<Scalars["String"]>;
+    roomTypes?: Maybe<Array<Maybe<RoomType>>>;
+};
+export type RoomTypesInput = {
+    propertyId?: InputMaybe<Scalars["Int"]>;
+    roomTypeCategoryCode?: InputMaybe<Scalars["String"]>;
+};
+export type RoomTypesOutput = {
+    __typename?: "RoomTypesOutput";
+    roomTypeList?: Maybe<Array<Maybe<RoomType>>>;
+    /** @deprecated Use 'roomTypeList'. */
+    roomTypes?: Maybe<Array<Maybe<Option>>>;
+};
+export type SalesChannelModeOutput = {
+    __typename?: "SalesChannelModeOutput";
+    mode?: Maybe<Scalars["Int"]>;
+};
+export type SaveCartInput = {
+    cartItemID?: InputMaybe<Scalars["Int"]>;
+    fastCheckinCheckout?: InputMaybe<Scalars["Boolean"]>;
+    passNewAmountLowerThanPrevious?: InputMaybe<Scalars["Boolean"]>;
+};
+export type SaveCartOutput = {
+    __typename?: "SaveCartOutput";
+    cart?: Maybe<Cart>;
+};
+export type SaveFerryBookingInput = {
+    occupantGuiid?: InputMaybe<Scalars["Int"]>;
+    productCode?: InputMaybe<Scalars["String"]>;
+};
+export type SaveFerryBookingOutput = {
+    __typename?: "SaveFerryBookingOutput";
+    cart?: Maybe<Cart>;
+};
+export type Service = {
+    __typename?: "Service";
+    address?: Maybe<Address>;
+    birthDate?: Maybe<Scalars["RslDate"]>;
+    civility?: Maybe<Civility>;
+    clientType?: Maybe<ClientType>;
+    criterias?: Maybe<Array<Maybe<CriteriaValue>>>;
+    customerCode?: Maybe<Scalars["String"]>;
+    customerType?: Maybe<CustomerType>;
+    defaultPartnerServiceDisabled?: Maybe<Scalars["Boolean"]>;
+    disabled?: Maybe<Scalars["Boolean"]>;
+    fidelityPoints?: Maybe<Scalars["Int"]>;
+    firstName?: Maybe<Scalars["String"]>;
+    id?: Maybe<Scalars["Int"]>;
+    /** @deprecated Use 'serviceLanguage'. */
+    language?: Maybe<Option>;
+    lastName?: Maybe<Scalars["String"]>;
+    login?: Maybe<Scalars["String"]>;
+    needValidation?: Maybe<Scalars["Boolean"]>;
+    /** @deprecated Use 'relationshipObject'. */
+    relationship?: Maybe<Scalars["String"]>;
+    relationshipObject?: Maybe<Relationship>;
+    serviceLanguage?: Maybe<Language>;
+    servicesList?: Maybe<Array<Maybe<Service>>>;
+};
+export type ServiceRelationship = {
+    relationship: Scalars["Int"];
+    serviceId: Scalars["Int"];
+};
+export type Session = {
+    name?: InputMaybe<Scalars["String"]>;
+};
+export type SessionActivatedOutput = {
+    __typename?: "SessionActivatedOutput";
+    activated?: Maybe<Scalars["Boolean"]>;
+};
+export type SessionInput = {
+    publicPartnerCode?: InputMaybe<Scalars["String"]>;
+    username: Scalars["String"];
+};
+export type SessionLanguageInput = {
+    languageCode?: InputMaybe<Scalars["String"]>;
+};
+export type SessionOutput = {
+    __typename?: "SessionOutput";
+    name?: Maybe<Scalars["String"]>;
+};
+export type Shoesize = {
+    __typename?: "Shoesize";
+    id?: Maybe<Scalars["Int"]>;
+    value?: Maybe<Scalars["String"]>;
+};
+export declare enum SkisetMeasureType {
+    Height = "HEIGHT",
+    Shoesize = "SHOESIZE",
+    Weight = "WEIGHT"
+}
+export type Stay = {
+    __typename?: "Stay";
+    arrivalTime?: Maybe<Scalars["LocalTime"]>;
+    departureTime?: Maybe<Scalars["LocalTime"]>;
+    distribution?: Maybe<Distribution>;
+    endDate?: Maybe<Scalars["Date"]>;
+    guiid?: Maybe<Scalars["Int"]>;
+    id?: Maybe<Scalars["Int"]>;
+    nbDays?: Maybe<Scalars["Int"]>;
+    occupants?: Maybe<Array<Maybe<Occupant>>>;
+    proposalkey?: Maybe<Scalars["String"]>;
+    startDate?: Maybe<Scalars["Date"]>;
+    totalAmount?: Maybe<Amount>;
+};
+export type StayMapInfos = {
+    __typename?: "StayMapInfos";
+    hasNoAvailableRoom?: Maybe<Scalars["Boolean"]>;
+    listStayRoomGuiid?: Maybe<Array<Maybe<Scalars["Int"]>>>;
+    stayGuiid?: Maybe<Scalars["Int"]>;
+};
+export type StayTimeInput = {
+    arrivalTime?: InputMaybe<Scalars["LocalTime"]>;
+    cartItemID?: InputMaybe<Scalars["Int"]>;
+    departureTime?: InputMaybe<Scalars["LocalTime"]>;
+    stayGuiid: Scalars["Int"];
+};
+export type StayTimeOutput = {
+    __typename?: "StayTimeOutput";
+    cart?: Maybe<Cart>;
+};
+export type Supplier = {
+    __typename?: "Supplier";
+    code?: Maybe<Scalars["String"]>;
+    label?: Maybe<Scalars["String"]>;
+};
+export type SwitchToPartnerConventionInput = {
+    CartItemID?: InputMaybe<Scalars["Int"]>;
+    partnerCode: Scalars["String"];
+};
+export type SwitchToPartnerConventionOutput = {
+    __typename?: "SwitchToPartnerConventionOutput";
+    cart?: Maybe<Cart>;
+};
+export type TotalOccupantsInput = {
+    cartItemID?: InputMaybe<Scalars["Int"]>;
+    nbAdults?: InputMaybe<Scalars["Int"]>;
+    nbBabies?: InputMaybe<Scalars["Int"]>;
+    nbChildren1?: InputMaybe<Scalars["Int"]>;
+    nbChildren2?: InputMaybe<Scalars["Int"]>;
+    stayGuiid: Scalars["Int"];
+};
+export type TotalOccupantsOutput = {
+    __typename?: "TotalOccupantsOutput";
+    cart?: Maybe<Cart>;
+};
+export type Trailer = {
+    __typename?: "Trailer";
+    amount?: Maybe<Amount>;
+    height?: Maybe<Scalars["Float"]>;
+    length?: Maybe<Scalars["Float"]>;
+    mark?: Maybe<Scalars["String"]>;
+    model?: Maybe<Scalars["String"]>;
+    registration?: Maybe<Scalars["String"]>;
+    trailerType: Scalars["String"];
+};
+export type TrailerCategory = {
+    __typename?: "TrailerCategory";
+    code: Scalars["String"];
+    label?: Maybe<Scalars["String"]>;
+};
+export type TrailerInfo = {
+    licensePlate?: InputMaybe<Scalars["String"]>;
+};
+export type Translation = {
+    __typename?: "Translation";
+    code?: Maybe<Scalars["String"]>;
+    value?: Maybe<Scalars["String"]>;
+};
+export type TranslationsInput = {
+    listLanguageVarCode?: InputMaybe<Array<InputMaybe<Scalars["String"]>>>;
+};
+export type TranslationsOutput = {
+    __typename?: "TranslationsOutput";
+    translations?: Maybe<Array<Maybe<Translation>>>;
+};
+export type Trip = {
+    __typename?: "Trip";
+    accommodations?: Maybe<Array<Maybe<Accommodation>>>;
+    accommodationsAmount?: Maybe<Amount>;
+    arrivalDate: Scalars["FerryDate"];
+    arrivalPort: Port;
+    arrivalTime: Scalars["FerryTime"];
+    coreTrip?: Maybe<CoreTrip>;
+    departureDate: Scalars["FerryDate"];
+    departurePort: Port;
+    departureTime: Scalars["FerryTime"];
+    duration: Scalars["FerryTime"];
+    /** @deprecated Moved in CoreTrip */
+    routeAmount?: Maybe<Amount>;
+    shipName?: Maybe<Scalars["String"]>;
+    trailer?: Maybe<Trailer>;
+    vehicle?: Maybe<Vehicle>;
+};
+export type UnlockBookingInput = {
+    bookingId: Scalars["Int"];
+};
+export type UnlockBookingOutput = {
+    __typename?: "UnlockBookingOutput";
+    bookingUnlocked?: Maybe<Scalars["Boolean"]>;
+};
+export type UpdateBookingCriteriasInput = {
+    cartItemID?: InputMaybe<Scalars["Int"]>;
+    criterias?: InputMaybe<Array<InputMaybe<CriteriaValueInput>>>;
+};
+export type UpdateBookingCriteriasOutput = {
+    __typename?: "UpdateBookingCriteriasOutput";
+    cart?: Maybe<Cart>;
+};
+export type UpdateFerryAccommodationsInput = {
+    outwardAccommodations?: InputMaybe<Array<InputMaybe<AccommodationInput>>>;
+    returnAccommodations?: InputMaybe<Array<InputMaybe<AccommodationInput>>>;
+};
+export type UpdateFerryAccommodationsOutput = {
+    __typename?: "UpdateFerryAccommodationsOutput";
+    ferryBooking?: Maybe<FerryBooking>;
+};
+export type UpdateFerryBookingInput = {
+    cartItemID?: InputMaybe<Scalars["Int"]>;
+    lineItemGuiid?: InputMaybe<Scalars["Int"]>;
+    /** @deprecated Use 'lineItemGuiid'. */
+    resFerryId?: InputMaybe<Scalars["Int"]>;
+};
+export type UpdateFerryBookingOutput = {
+    __typename?: "UpdateFerryBookingOutput";
+    ferryBooking?: Maybe<FerryBooking>;
+};
+export type UpdateFerryTravelersInformationInput = {
+    contact?: InputMaybe<ContactInfo>;
+    passengers?: InputMaybe<Array<InputMaybe<PassengerInfo>>>;
+    trailer?: InputMaybe<TrailerInfo>;
+    vehicle?: InputMaybe<VehicleInfo>;
+};
+export type UpdateFerryTravelersInformationOutput = {
+    __typename?: "UpdateFerryTravelersInformationOutput";
+    ferryBooking?: Maybe<FerryBooking>;
+};
+export type UpdateOccupantSkisetMeasurementsInput = {
+    cartItemID?: InputMaybe<Scalars["Int"]>;
+    occupantSkisetMeasurements?: InputMaybe<Array<InputMaybe<OccupantMeasurementInput>>>;
+};
+export type UpdateOccupantSkisetMeasurementsOutput = {
+    __typename?: "UpdateOccupantSkisetMeasurementsOutput";
+    cart?: Maybe<Cart>;
+};
+export type UpdatePartnerCustomerAccountInput = {
+    address: CustomerAddressInput;
+    birthDate?: InputMaybe<Scalars["Date"]>;
+    civility?: InputMaybe<Scalars["String"]>;
+    customerCode: Scalars["String"];
+    firstName?: InputMaybe<Scalars["String"]>;
+    lastName?: InputMaybe<Scalars["String"]>;
+    relationshipId?: InputMaybe<Scalars["Int"]>;
+};
+export type UpdateServiceCustomerAccountInput = {
+    birthDate?: InputMaybe<Scalars["Date"]>;
+    civility?: InputMaybe<Scalars["String"]>;
+    firstName?: InputMaybe<Scalars["String"]>;
+    lastName?: InputMaybe<Scalars["String"]>;
+    relationshipId?: InputMaybe<Scalars["Int"]>;
+    serviceId: Scalars["Int"];
+};
+export type User = {
+    __typename?: "User";
+    grouping?: Maybe<UserGrouping>;
+    name?: Maybe<Scalars["String"]>;
+    profile?: Maybe<UserProfile>;
+    userType?: Maybe<UserType>;
+};
+export type UserGrouping = {
+    __typename?: "UserGrouping";
+    code?: Maybe<Scalars["String"]>;
+    label?: Maybe<Scalars["String"]>;
+};
+export type UserLanguageOutput = {
+    __typename?: "UserLanguageOutput";
+    languageCode?: Maybe<Scalars["String"]>;
+};
+export type UserProfile = {
+    __typename?: "UserProfile";
+    code?: Maybe<Scalars["String"]>;
+    label?: Maybe<Scalars["String"]>;
+};
+export type UserType = {
+    __typename?: "UserType";
+    code?: Maybe<Scalars["Int"]>;
+    label?: Maybe<Scalars["String"]>;
+};
+export type ValidLoginInput = {
+    loginHashInput: LoginHash256Input;
+};
+export type ValidLoginOutput = {
+    __typename?: "ValidLoginOutput";
+    valid?: Maybe<Scalars["Boolean"]>;
+};
+export type Vehicle = {
+    __typename?: "Vehicle";
+    additionalHeight?: Maybe<Scalars["Float"]>;
+    additionalLength?: Maybe<Scalars["Float"]>;
+    height?: Maybe<Scalars["Float"]>;
+    length?: Maybe<Scalars["Float"]>;
+    mark?: Maybe<Scalars["String"]>;
+    model?: Maybe<Scalars["String"]>;
+    registration?: Maybe<Scalars["String"]>;
+    vehicleType: Scalars["String"];
+};
+export type VehicleCategory = {
+    __typename?: "VehicleCategory";
+    code: Scalars["String"];
+    isCar?: Maybe<Scalars["Boolean"]>;
+    label?: Maybe<Scalars["String"]>;
+};
+export type VehicleInfo = {
+    fuel?: InputMaybe<Scalars["String"]>;
+    licensePlate?: InputMaybe<Scalars["String"]>;
+};
+/**
+ *  LANG_gql_WeeklyCriterias
+ * LANG_gql_WeeklyCriterias_2
+ */
+export type WeeklyCriterias = {
+    baseProductCode?: InputMaybe<Scalars["String"]>;
+    childrenBirthDates?: InputMaybe<Array<InputMaybe<Scalars["Date"]>>>;
+    division?: InputMaybe<Scalars["String"]>;
+    endDate?: InputMaybe<Scalars["Date"]>;
+    ignoreDayConstraints?: InputMaybe<Scalars["Boolean"]>;
+    maxRooms?: InputMaybe<Scalars["Int"]>;
+    month?: InputMaybe<Scalars["Int"]>;
+    nbAdults: Scalars["Int"];
+    nbBabies?: InputMaybe<Scalars["Int"]>;
+    nbChildren1?: InputMaybe<Scalars["Int"]>;
+    nbChildren2?: InputMaybe<Scalars["Int"]>;
+    periodCode?: InputMaybe<Scalars["String"]>;
+    propertyId: Scalars["Int"];
+    roomTypeCategoryCodes?: InputMaybe<Array<InputMaybe<Scalars["String"]>>>;
+    startDate?: InputMaybe<Scalars["Date"]>;
+    useCachedProposalsStd?: InputMaybe<Scalars["Boolean"]>;
+    year?: InputMaybe<Scalars["Int"]>;
+};
+export type Weight = {
+    __typename?: "Weight";
+    id?: Maybe<Scalars["Int"]>;
+    value?: Maybe<Scalars["String"]>;
+};
+export type PayOnStoredCreditCardInput = {
+    amount: AmountInput;
+    creditcardGuiid: Scalars["Int"];
+    paymentDueGuiid: Scalars["Int"];
+};
+export type PayOnStoredCreditCardOutput = {
+    __typename?: "payOnStoredCreditCardOutput";
+    cart?: Maybe<Cart>;
+};