@qite/tide-booking-component 1.4.124 → 1.4.125

package/build/build-cjs/src/booking-wizard/features/flight-options/flight-filter.d.ts

@@ -0,0 +1,9 @@
+import React from 'react';
+import { FlightFilterOptions } from '../../types';
+interface FlightFilterProps {
+    filterOptions: FlightFilterOptions;
+    resultCount: number;
+    applyFilter: (options: FlightFilterOptions) => void;
+}
+declare const FlightFilter: React.FC<FlightFilterProps>;
+export default FlightFilter;

package/build/build-cjs/src/booking-wizard/features/flight-options/flight-option-flight.d.ts

@@ -0,0 +1,8 @@
+import React from 'react';
+import { GroupedFlightDetails } from '../../types';
+interface FlightOptionFlightProps {
+    details: GroupedFlightDetails;
+    isOptionsVisible: boolean;
+}
+declare const FlightOptionFlight: React.FC<FlightOptionFlightProps>;
+export default FlightOptionFlight;

package/build/build-cjs/src/booking-wizard/features/flight-options/flight-option-modal.d.ts

@@ -0,0 +1,3 @@
+import React from 'react';
+declare const FlightOptionModal: ({}: {}) => React.JSX.Element;
+export default FlightOptionModal;

package/build/build-cjs/src/booking-wizard/features/flight-options/flight-option.d.ts

@@ -0,0 +1,10 @@
+import React from 'react';
+import { GroupedFlights } from '../../types';
+interface FlightOptionProps {
+    item: GroupedFlights;
+    isSelected: boolean;
+    currentPrice: number;
+    onChange: (item: GroupedFlights) => void;
+}
+declare const FlightOption: React.FC<FlightOptionProps>;
+export default FlightOption;

package/build/build-cjs/src/booking-wizard/features/flight-options/flight-utils.d.ts

@@ -0,0 +1,6 @@
+import { BookingPackageFlight } from '@qite/tide-client/build/types';
+import { FlightFilterOptions, GroupedFlights } from '../../types';
+export declare const buildGroupedFlights: (outwardFlights: BookingPackageFlight[] | undefined, returnFlights: BookingPackageFlight[] | undefined) => GroupedFlights[];
+export declare const buildFilterOptions: (outwardFlights: BookingPackageFlight[] | undefined, returnFlights: BookingPackageFlight[] | undefined, translations: any) => FlightFilterOptions | undefined;
+export declare const filterGroupedFlights: (groups: GroupedFlights[], filterOptions: FlightFilterOptions | undefined) => GroupedFlights[];
+export declare const formatMinutes: (minutes: number) => string;

package/build/build-cjs/src/booking-wizard/features/flight-options/index.d.ts

@@ -0,0 +1,5 @@
+import React from 'react';
+interface FlightOptionsFormProps {
+}
+declare const FlightOptionsForm: React.FC<FlightOptionsFormProps>;
+export default FlightOptionsForm;

package/build/build-cjs/src/booking-wizard/features/price-details/price-details-api.d.ts

@@ -0,0 +1,6 @@
+import { BookingPackageBookRequest, BookingPackageRequest, BookingPriceDetails } from '@qite/tide-client/build/types';
+import { ApiSettingsState } from '../../../shared/types';
+declare const priceDetailsApi: {
+    fetchPriceDetails: (apiSettings: ApiSettingsState, request: BookingPackageRequest<BookingPackageBookRequest>, signal: AbortSignal, languageCode?: string) => Promise<BookingPriceDetails>;
+};
+export default priceDetailsApi;

package/build/build-cjs/src/booking-wizard/features/price-details/price-details-slice.d.ts

@@ -0,0 +1,23 @@
+import { RootState } from '../../store';
+import { BookingPriceDetail, BookingPriceDetails, BookingProductNotification } from '@qite/tide-client/build/types';
+export interface PriceDetailsState {
+    priceDetails: BookingPriceDetail[];
+    notifications: BookingProductNotification[];
+    deposit?: number;
+    commission?: number;
+    isBusy: boolean;
+}
+export declare const fetchPriceDetails: import("@reduxjs/toolkit").AsyncThunk<BookingPriceDetails, void, {
+    state?: unknown;
+    dispatch?: import("@reduxjs/toolkit").ThunkDispatch<unknown, unknown, import("@reduxjs/toolkit").UnknownAction>;
+    extra?: unknown;
+    rejectValue?: unknown;
+    serializedErrorType?: unknown;
+    pendingMeta?: unknown;
+    fulfilledMeta?: unknown;
+    rejectedMeta?: unknown;
+}>;
+export declare const resetPriceDetails: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<"priceDetails/resetPriceDetails">, setNotifications: import("@reduxjs/toolkit").ActionCreatorWithPayload<BookingProductNotification[], "priceDetails/setNotifications">;
+export declare const selectNotifications: (state: RootState) => BookingProductNotification[];
+declare const _default: import("@reduxjs/toolkit").Reducer<PriceDetailsState>;
+export default _default;

package/build/build-cjs/src/booking-wizard/features/price-details/selectors.d.ts

@@ -0,0 +1,378 @@
+import { RootState } from '../../store';
+import { PricePerPaxType } from '../../types';
+import { BookingPackageRequestRoom, BookingPriceDetail } from '@qite/tide-client';
+export declare const selectPriceDetails: (state: RootState) => BookingPriceDetail[];
+export declare const selectPackagePriceDetails: ((state: {
+    booking: import("../booking/booking-slice").BookingState;
+    travelersForm: import("../travelers-form/travelers-form-slice").TravelersFormState;
+    priceDetails: import("./price-details-slice").PriceDetailsState;
+    summary: import("../summary/summary-slice").SummaryState;
+    apiSettings: import("../../..").ApiSettingsState;
+}) => BookingPriceDetail[]) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: BookingPriceDetail[]) => BookingPriceDetail[];
+    memoizedResultFunc: ((resultFuncArgs_0: BookingPriceDetail[]) => BookingPriceDetail[]) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => BookingPriceDetail[];
+    dependencies: [(state: RootState) => BookingPriceDetail[]];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    argsMemoize: typeof import("reselect").weakMapMemoize;
+    memoize: typeof import("reselect").weakMapMemoize;
+};
+export declare const selectSeparatePackagePriceDetails: ((state: {
+    booking: import("../booking/booking-slice").BookingState;
+    travelersForm: import("../travelers-form/travelers-form-slice").TravelersFormState;
+    priceDetails: import("./price-details-slice").PriceDetailsState;
+    summary: import("../summary/summary-slice").SummaryState;
+    apiSettings: import("../../..").ApiSettingsState;
+}) => BookingPriceDetail[]) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: BookingPriceDetail[]) => BookingPriceDetail[];
+    memoizedResultFunc: ((resultFuncArgs_0: BookingPriceDetail[]) => BookingPriceDetail[]) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => BookingPriceDetail[];
+    dependencies: [((state: {
+        booking: import("../booking/booking-slice").BookingState;
+        travelersForm: import("../travelers-form/travelers-form-slice").TravelersFormState;
+        priceDetails: import("./price-details-slice").PriceDetailsState;
+        summary: import("../summary/summary-slice").SummaryState;
+        apiSettings: import("../../..").ApiSettingsState;
+    }) => BookingPriceDetail[]) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    } & {
+        resultFunc: (resultFuncArgs_0: BookingPriceDetail[]) => BookingPriceDetail[];
+        memoizedResultFunc: ((resultFuncArgs_0: BookingPriceDetail[]) => BookingPriceDetail[]) & {
+            clearCache: () => void;
+            resultsCount: () => number;
+            resetResultsCount: () => void;
+        };
+        lastResult: () => BookingPriceDetail[];
+        dependencies: [(state: RootState) => BookingPriceDetail[]];
+        recomputations: () => number;
+        resetRecomputations: () => void;
+        dependencyRecomputations: () => number;
+        resetDependencyRecomputations: () => void;
+    } & {
+        argsMemoize: typeof import("reselect").weakMapMemoize;
+        memoize: typeof import("reselect").weakMapMemoize;
+    }];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    argsMemoize: typeof import("reselect").weakMapMemoize;
+    memoize: typeof import("reselect").weakMapMemoize;
+};
+export declare const selectBasePrice: ((state: {
+    booking: import("../booking/booking-slice").BookingState;
+    travelersForm: import("../travelers-form/travelers-form-slice").TravelersFormState;
+    priceDetails: import("./price-details-slice").PriceDetailsState;
+    summary: import("../summary/summary-slice").SummaryState;
+    apiSettings: import("../../..").ApiSettingsState;
+}) => number) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: BookingPriceDetail[]) => number;
+    memoizedResultFunc: ((resultFuncArgs_0: BookingPriceDetail[]) => number) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => number;
+    dependencies: [((state: {
+        booking: import("../booking/booking-slice").BookingState;
+        travelersForm: import("../travelers-form/travelers-form-slice").TravelersFormState;
+        priceDetails: import("./price-details-slice").PriceDetailsState;
+        summary: import("../summary/summary-slice").SummaryState;
+        apiSettings: import("../../..").ApiSettingsState;
+    }) => BookingPriceDetail[]) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    } & {
+        resultFunc: (resultFuncArgs_0: BookingPriceDetail[]) => BookingPriceDetail[];
+        memoizedResultFunc: ((resultFuncArgs_0: BookingPriceDetail[]) => BookingPriceDetail[]) & {
+            clearCache: () => void;
+            resultsCount: () => number;
+            resetResultsCount: () => void;
+        };
+        lastResult: () => BookingPriceDetail[];
+        dependencies: [(state: RootState) => BookingPriceDetail[]];
+        recomputations: () => number;
+        resetRecomputations: () => void;
+        dependencyRecomputations: () => number;
+        resetDependencyRecomputations: () => void;
+    } & {
+        argsMemoize: typeof import("reselect").weakMapMemoize;
+        memoize: typeof import("reselect").weakMapMemoize;
+    }];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    argsMemoize: typeof import("reselect").weakMapMemoize;
+    memoize: typeof import("reselect").weakMapMemoize;
+};
+export declare const selectSeparateExtraPriceDetails: ((state: {
+    booking: import("../booking/booking-slice").BookingState;
+    travelersForm: import("../travelers-form/travelers-form-slice").TravelersFormState;
+    priceDetails: import("./price-details-slice").PriceDetailsState;
+    summary: import("../summary/summary-slice").SummaryState;
+    apiSettings: import("../../..").ApiSettingsState;
+}) => BookingPriceDetail[]) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: BookingPriceDetail[]) => BookingPriceDetail[];
+    memoizedResultFunc: ((resultFuncArgs_0: BookingPriceDetail[]) => BookingPriceDetail[]) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => BookingPriceDetail[];
+    dependencies: [(state: RootState) => BookingPriceDetail[]];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    argsMemoize: typeof import("reselect").weakMapMemoize;
+    memoize: typeof import("reselect").weakMapMemoize;
+};
+export declare const selectTotalPrice: ((state: {
+    booking: import("../booking/booking-slice").BookingState;
+    travelersForm: import("../travelers-form/travelers-form-slice").TravelersFormState;
+    priceDetails: import("./price-details-slice").PriceDetailsState;
+    summary: import("../summary/summary-slice").SummaryState;
+    apiSettings: import("../../..").ApiSettingsState;
+}) => number) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: number, resultFuncArgs_1: BookingPriceDetail[]) => number;
+    memoizedResultFunc: ((resultFuncArgs_0: number, resultFuncArgs_1: BookingPriceDetail[]) => number) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => number;
+    dependencies: [((state: {
+        booking: import("../booking/booking-slice").BookingState;
+        travelersForm: import("../travelers-form/travelers-form-slice").TravelersFormState;
+        priceDetails: import("./price-details-slice").PriceDetailsState;
+        summary: import("../summary/summary-slice").SummaryState;
+        apiSettings: import("../../..").ApiSettingsState;
+    }) => number) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    } & {
+        resultFunc: (resultFuncArgs_0: BookingPriceDetail[]) => number;
+        memoizedResultFunc: ((resultFuncArgs_0: BookingPriceDetail[]) => number) & {
+            clearCache: () => void;
+            resultsCount: () => number;
+            resetResultsCount: () => void;
+        };
+        lastResult: () => number;
+        dependencies: [((state: {
+            booking: import("../booking/booking-slice").BookingState;
+            travelersForm: import("../travelers-form/travelers-form-slice").TravelersFormState;
+            priceDetails: import("./price-details-slice").PriceDetailsState;
+            summary: import("../summary/summary-slice").SummaryState;
+            apiSettings: import("../../..").ApiSettingsState;
+        }) => BookingPriceDetail[]) & {
+            clearCache: () => void;
+            resultsCount: () => number;
+            resetResultsCount: () => void;
+        } & {
+            resultFunc: (resultFuncArgs_0: BookingPriceDetail[]) => BookingPriceDetail[];
+            memoizedResultFunc: ((resultFuncArgs_0: BookingPriceDetail[]) => BookingPriceDetail[]) & {
+                clearCache: () => void;
+                resultsCount: () => number;
+                resetResultsCount: () => void;
+            };
+            lastResult: () => BookingPriceDetail[];
+            dependencies: [(state: RootState) => BookingPriceDetail[]];
+            recomputations: () => number;
+            resetRecomputations: () => void;
+            dependencyRecomputations: () => number;
+            resetDependencyRecomputations: () => void;
+        } & {
+            argsMemoize: typeof import("reselect").weakMapMemoize;
+            memoize: typeof import("reselect").weakMapMemoize;
+        }];
+        recomputations: () => number;
+        resetRecomputations: () => void;
+        dependencyRecomputations: () => number;
+        resetDependencyRecomputations: () => void;
+    } & {
+        argsMemoize: typeof import("reselect").weakMapMemoize;
+        memoize: typeof import("reselect").weakMapMemoize;
+    }, ((state: {
+        booking: import("../booking/booking-slice").BookingState;
+        travelersForm: import("../travelers-form/travelers-form-slice").TravelersFormState;
+        priceDetails: import("./price-details-slice").PriceDetailsState;
+        summary: import("../summary/summary-slice").SummaryState;
+        apiSettings: import("../../..").ApiSettingsState;
+    }) => BookingPriceDetail[]) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    } & {
+        resultFunc: (resultFuncArgs_0: BookingPriceDetail[]) => BookingPriceDetail[];
+        memoizedResultFunc: ((resultFuncArgs_0: BookingPriceDetail[]) => BookingPriceDetail[]) & {
+            clearCache: () => void;
+            resultsCount: () => number;
+            resetResultsCount: () => void;
+        };
+        lastResult: () => BookingPriceDetail[];
+        dependencies: [(state: RootState) => BookingPriceDetail[]];
+        recomputations: () => number;
+        resetRecomputations: () => void;
+        dependencyRecomputations: () => number;
+        resetDependencyRecomputations: () => void;
+    } & {
+        argsMemoize: typeof import("reselect").weakMapMemoize;
+        memoize: typeof import("reselect").weakMapMemoize;
+    }];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    argsMemoize: typeof import("reselect").weakMapMemoize;
+    memoize: typeof import("reselect").weakMapMemoize;
+};
+export declare const selectBasePricePerPaxType: ((state: {
+    booking: import("../booking/booking-slice").BookingState;
+    travelersForm: import("../travelers-form/travelers-form-slice").TravelersFormState;
+    priceDetails: import("./price-details-slice").PriceDetailsState;
+    summary: import("../summary/summary-slice").SummaryState;
+    apiSettings: import("../../..").ApiSettingsState;
+}) => PricePerPaxType[]) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: BookingPriceDetail[], resultFuncArgs_1: BookingPackageRequestRoom[] | undefined) => PricePerPaxType[];
+    memoizedResultFunc: ((resultFuncArgs_0: BookingPriceDetail[], resultFuncArgs_1: BookingPackageRequestRoom[] | undefined) => PricePerPaxType[]) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => PricePerPaxType[];
+    dependencies: [((state: {
+        booking: import("../booking/booking-slice").BookingState;
+        travelersForm: import("../travelers-form/travelers-form-slice").TravelersFormState;
+        priceDetails: import("./price-details-slice").PriceDetailsState;
+        summary: import("../summary/summary-slice").SummaryState;
+        apiSettings: import("../../..").ApiSettingsState;
+    }) => BookingPriceDetail[]) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    } & {
+        resultFunc: (resultFuncArgs_0: BookingPriceDetail[]) => BookingPriceDetail[];
+        memoizedResultFunc: ((resultFuncArgs_0: BookingPriceDetail[]) => BookingPriceDetail[]) & {
+            clearCache: () => void;
+            resultsCount: () => number;
+            resetResultsCount: () => void;
+        };
+        lastResult: () => BookingPriceDetail[];
+        dependencies: [(state: RootState) => BookingPriceDetail[]];
+        recomputations: () => number;
+        resetRecomputations: () => void;
+        dependencyRecomputations: () => number;
+        resetDependencyRecomputations: () => void;
+    } & {
+        argsMemoize: typeof import("reselect").weakMapMemoize;
+        memoize: typeof import("reselect").weakMapMemoize;
+    }, (state: RootState) => BookingPackageRequestRoom[] | undefined];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    argsMemoize: typeof import("reselect").weakMapMemoize;
+    memoize: typeof import("reselect").weakMapMemoize;
+};
+export declare const selectSeparateExtraPriceDetailsPerPaxType: ((state: {
+    booking: import("../booking/booking-slice").BookingState;
+    travelersForm: import("../travelers-form/travelers-form-slice").TravelersFormState;
+    priceDetails: import("./price-details-slice").PriceDetailsState;
+    summary: import("../summary/summary-slice").SummaryState;
+    apiSettings: import("../../..").ApiSettingsState;
+}) => PricePerPaxType[]) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: BookingPriceDetail[], resultFuncArgs_1: BookingPackageRequestRoom[] | undefined) => PricePerPaxType[];
+    memoizedResultFunc: ((resultFuncArgs_0: BookingPriceDetail[], resultFuncArgs_1: BookingPackageRequestRoom[] | undefined) => PricePerPaxType[]) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => PricePerPaxType[];
+    dependencies: [((state: {
+        booking: import("../booking/booking-slice").BookingState;
+        travelersForm: import("../travelers-form/travelers-form-slice").TravelersFormState;
+        priceDetails: import("./price-details-slice").PriceDetailsState;
+        summary: import("../summary/summary-slice").SummaryState;
+        apiSettings: import("../../..").ApiSettingsState;
+    }) => BookingPriceDetail[]) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    } & {
+        resultFunc: (resultFuncArgs_0: BookingPriceDetail[]) => BookingPriceDetail[];
+        memoizedResultFunc: ((resultFuncArgs_0: BookingPriceDetail[]) => BookingPriceDetail[]) & {
+            clearCache: () => void;
+            resultsCount: () => number;
+            resetResultsCount: () => void;
+        };
+        lastResult: () => BookingPriceDetail[];
+        dependencies: [(state: RootState) => BookingPriceDetail[]];
+        recomputations: () => number;
+        resetRecomputations: () => void;
+        dependencyRecomputations: () => number;
+        resetDependencyRecomputations: () => void;
+    } & {
+        argsMemoize: typeof import("reselect").weakMapMemoize;
+        memoize: typeof import("reselect").weakMapMemoize;
+    }, (state: RootState) => BookingPackageRequestRoom[] | undefined];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    argsMemoize: typeof import("reselect").weakMapMemoize;
+    memoize: typeof import("reselect").weakMapMemoize;
+};
+export declare const selectDeposit: (state: RootState) => number | undefined;
+export declare const selectCommission: (state: RootState) => number | undefined;
+export declare const selectIsFetchingPriceDetails: (state: RootState) => boolean;

package/build/build-cjs/src/booking-wizard/features/price-details/util.d.ts

@@ -0,0 +1,2 @@
+import { BookingPackage, ChangedLine } from '@qite/tide-client/build/types';
+export declare const updatePackageDetails: (packageDetails: BookingPackage, changedLines: ChangedLine[]) => BookingPackage;

package/build/build-cjs/src/booking-wizard/features/product-options/no-options.d.ts

@@ -0,0 +1,3 @@
+import React from 'react';
+declare const NoOptions: () => React.JSX.Element;
+export default NoOptions;

package/build/build-cjs/src/booking-wizard/features/product-options/none-option.d.ts

@@ -0,0 +1,9 @@
+import { BookingOptionGroup, PerBookingPackageOption, PerPaxPackageOption, PerUnitPackageOption } from '@qite/tide-client/build/types';
+import React from 'react';
+interface NoneOptionProps {
+    group: BookingOptionGroup<PerBookingPackageOption> | BookingOptionGroup<PerUnitPackageOption> | BookingOptionGroup<PerPaxPackageOption>;
+    parentId: string;
+    handleNoneSelectionChanged: () => void;
+}
+declare const NoneOption: React.FC<NoneOptionProps>;
+export default NoneOption;

package/build/build-cjs/src/booking-wizard/features/product-options/option-booking-airline-group.d.ts

@@ -0,0 +1,8 @@
+import { AirlineBookingPackageOption, AirportBookingPackageOption, BookingAirlineGroup, BookingAirportGroup } from '@qite/tide-client/build/types';
+import React from 'react';
+interface OptionBookingAirlineGroupProps {
+    airGroup: BookingAirlineGroup<AirlineBookingPackageOption>;
+    onGroupChange?: (group: BookingAirlineGroup<AirlineBookingPackageOption> | BookingAirportGroup<AirportBookingPackageOption>) => void;
+}
+declare const OptionBookingAirlineGroup: React.FC<OptionBookingAirlineGroupProps>;
+export default OptionBookingAirlineGroup;

package/build/build-cjs/src/booking-wizard/features/product-options/option-booking-group.d.ts

@@ -0,0 +1,12 @@
+import { BookingOptionGroup, PerBookingPackageOption } from '@qite/tide-client/build/types';
+import React from 'react';
+interface OptionBookingGroupProps {
+    optionId?: string;
+    group: BookingOptionGroup<PerBookingPackageOption>;
+    firstClassName: string;
+    secondClassName: string;
+    parentId: string;
+    onGroupChange?: (group: BookingOptionGroup<PerBookingPackageOption>, optionId?: string) => void;
+}
+declare const OptionBookingGroup: React.FC<OptionBookingGroupProps>;
+export default OptionBookingGroup;

package/build/build-cjs/src/booking-wizard/features/product-options/option-item.d.ts

@@ -0,0 +1,11 @@
+import { PerPackageOption } from '@qite/tide-client/build/types';
+import React from 'react';
+interface OptionItemProps {
+    option: PerPackageOption;
+    parentId: string;
+    index: number;
+    selectedPrice: number;
+    onOptionChange?: (option: PerPackageOption, index: number) => void;
+}
+declare const OptionItem: React.FC<OptionItemProps>;
+export default OptionItem;

package/build/build-cjs/src/booking-wizard/features/product-options/option-pax-card.d.ts

@@ -0,0 +1,10 @@
+import { BookingOptionPax, BookingPackagePax } from '@qite/tide-client/build/types';
+import React from 'react';
+interface OptionPaxCardProps {
+    pax: BookingOptionPax[];
+    requestRoomsPax?: BookingPackagePax[];
+    parentIndex?: number;
+    onPaxChange?: (pax: BookingOptionPax[], index?: number) => void;
+}
+declare const OptionPaxCard: React.FC<OptionPaxCardProps>;
+export default OptionPaxCard;

package/build/build-cjs/src/booking-wizard/features/product-options/option-pax-group.d.ts

@@ -0,0 +1,13 @@
+import { BookingOptionGroup, PerPaxPackageOption } from '@qite/tide-client/build/types';
+import React from 'react';
+interface OptionPaxGroupProps {
+    paxId: number;
+    optionId?: string;
+    group: BookingOptionGroup<PerPaxPackageOption>;
+    firstClassName: string;
+    secondClassName: string;
+    parentId: string;
+    onGroupChange?: (group: BookingOptionGroup<PerPaxPackageOption>, paxId: number, optionId?: string) => void;
+}
+declare const OptionPaxGroup: React.FC<OptionPaxGroupProps>;
+export default OptionPaxGroup;

package/build/build-cjs/src/booking-wizard/features/product-options/option-room.d.ts

@@ -0,0 +1,11 @@
+import { BookingOptionPax, BookingPackagePax, BookingPackageRoom } from '@qite/tide-client/build/types';
+import React from 'react';
+interface OptionRoomProps {
+    packageRoom: BookingPackageRoom;
+    pax: BookingPackagePax[];
+    optionPax?: BookingOptionPax[];
+    onRoomChange: (index: number, accommodationCode: string, regimeCode: string | null) => void;
+    includedServiceTypes?: number[];
+}
+declare const OptionRoom: React.FC<OptionRoomProps>;
+export default OptionRoom;

package/build/build-cjs/src/booking-wizard/features/product-options/option-unit-group.d.ts

@@ -0,0 +1,13 @@
+import { BookingOptionGroup, PerUnitPackageOption } from '@qite/tide-client/build/types';
+import React from 'react';
+interface OptionUnitGroupProps {
+    unitIndex: number;
+    optionId?: string;
+    group: BookingOptionGroup<PerUnitPackageOption>;
+    firstClassName: string;
+    secondClassName: string;
+    parentId: string;
+    onGroupChange?: (group: BookingOptionGroup<PerUnitPackageOption>, unitIndex: number, optionId?: string) => void;
+}
+declare const OptionUnitGroup: React.FC<OptionUnitGroupProps>;
+export default OptionUnitGroup;

package/build/build-cjs/src/booking-wizard/features/product-options/option-units-card.d.ts

@@ -0,0 +1,9 @@
+import { BookingOptionUnit } from '@qite/tide-client/build/types';
+import React from 'react';
+interface OptionUnitsCardProps {
+    units: BookingOptionUnit[];
+    parentIndex?: number;
+    onUnitsChange?: (units: BookingOptionUnit[], index?: number) => void;
+}
+declare const OptionUnitsCard: React.FC<OptionUnitsCardProps>;
+export default OptionUnitsCard;

package/build/build-cjs/src/booking-wizard/features/product-options/option-utils.d.ts

@@ -0,0 +1,9 @@
+import { BookingOptionGroup, BookingOptionPax, BookingOptionUnit, PerPackageOption } from '@qite/tide-client/build/types';
+import { BookingPackageOptionMappingInfo } from '@qite/tide-client/build/types/booking-v2/shared/booking-package-option-mapping-info';
+type OptionWithGroups = PerPackageOption & {
+    groups?: BookingOptionGroup<any>[];
+    units?: BookingOptionUnit[];
+    pax?: BookingOptionPax[];
+};
+export declare function applyMappedSelection<T extends OptionWithGroups>(groups: BookingOptionGroup<T>[], parentProductCode: string, parentAccoCode: string, parentRegimeCode: string, mappingInfo: BookingPackageOptionMappingInfo): BookingOptionGroup<T>[];
+export {};

package/build/build-cjs/src/booking-wizard/features/product-options/options-form.d.ts

@@ -0,0 +1,5 @@
+import React from 'react';
+interface OptionsFormProps {
+}
+declare const OptionsForm: React.FC<OptionsFormProps>;
+export default OptionsForm;

package/build/build-cjs/src/booking-wizard/features/room-options/index.d.ts

@@ -0,0 +1,5 @@
+import React from 'react';
+interface RoomOptionsFormProps {
+}
+declare const RoomOptionsForm: React.FC<RoomOptionsFormProps>;
+export default RoomOptionsForm;

package/build/build-cjs/src/booking-wizard/features/room-options/room-utils.d.ts

@@ -0,0 +1,9 @@
+import { BookingPackageAvailability, BookingPackageRoom } from '@qite/tide-client/build/types';
+import { AccommodationContent, RegimeContent, SelectableRoom } from '../../types';
+export declare const buildSelectableRooms: (packageRooms: BookingPackageRoom[], accommodations: AccommodationContent[] | undefined, regimes: RegimeContent[] | undefined, accommodationViews: {
+    [key: string]: string;
+} | undefined) => SelectableRoom[];
+export declare const updatePackageRooms: (rooms: BookingPackageRoom[], index: number, accommodationCode: string, regimeCode: string | null, availabilities: BookingPackageAvailability[]) => {
+    options: import("@qite/tide-client/build/types").BookingPackageRoomOption[];
+    index: number;
+}[];

package/build/build-cjs/src/booking-wizard/features/room-options/room.d.ts

@@ -0,0 +1,12 @@
+import React from 'react';
+import { SelectableRoomAccommodation } from '../../types';
+interface RoomOptionProps {
+    room: SelectableRoomAccommodation;
+    hasAlternatives?: boolean;
+    selectedRoomPrice?: number;
+    onAcommodationChange?: (accommodationCode: string, regimeCode: string) => void;
+    onRegimeChange?: (code: string) => void;
+    onToggleAlternatives?: () => void;
+}
+declare const RoomOption: React.FC<RoomOptionProps>;
+export default RoomOption;

package/build/build-cjs/src/booking-wizard/features/room-options/traveler-rooms.d.ts

@@ -0,0 +1,9 @@
+import React from 'react';
+import { SelectableRoom } from '../../types';
+interface TravelerRoomsProps {
+    index: number;
+    room: SelectableRoom;
+    onRoomChange: (index: number, accommodationCode: string, regimeCode: string | null) => void;
+}
+declare const TravelerRooms: React.FC<TravelerRoomsProps>;
+export default TravelerRooms;