@qite/tide-booking-component 1.4.57 → 1.4.59

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

@@ -0,0 +1,392 @@
+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 selectIsFetchingPriceDetails: (state: RootState) => boolean;

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

@@ -1,9 +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;
+  group: BookingOptionGroup<PerBookingPackageOption> | BookingOptionGroup<PerUnitPackageOption> | BookingOptionGroup<PerPaxPackageOption>;
+  parentId: string;
+  handleNoneSelectionChanged: () => void;
 }
 declare const NoneOption: React.FC<NoneOptionProps>;
 export default NoneOption;

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

@@ -1,8 +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;
+  airGroup: BookingAirlineGroup<AirlineBookingPackageOption>;
+  onGroupChange?: (group: BookingAirlineGroup<AirlineBookingPackageOption> | BookingAirportGroup<AirportBookingPackageOption>) => void;
 }
 declare const OptionBookingAirlineGroup: React.FC<OptionBookingAirlineGroupProps>;
 export default OptionBookingAirlineGroup;

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

@@ -1,12 +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;
+  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-esm/src/booking-wizard/features/product-options/option-item.d.ts

@@ -1,11 +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;
+  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-esm/src/booking-wizard/features/product-options/option-pax-card.d.ts

@@ -1,10 +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;
+  pax: BookingOptionPax[];
+  requestRoomsPax?: BookingPackagePax[];
+  parentIndex?: number;
+  onPaxChange?: (pax: BookingOptionPax[], index?: number) => void;
 }
 declare const OptionPaxCard: React.FC<OptionPaxCardProps>;
 export default OptionPaxCard;

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

@@ -1,13 +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;
+  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-esm/src/booking-wizard/features/product-options/option-room.d.ts

@@ -1,11 +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[];
+  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-esm/src/booking-wizard/features/product-options/option-unit-group.d.ts

@@ -1,13 +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;
+  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-esm/src/booking-wizard/features/product-options/option-units-card.d.ts

@@ -1,9 +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;
+  units: BookingOptionUnit[];
+  parentIndex?: number;
+  onUnitsChange?: (units: BookingOptionUnit[], index?: number) => void;
 }
 declare const OptionUnitsCard: React.FC<OptionUnitsCardProps>;
 export default OptionUnitsCard;

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

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

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

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

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

@@ -1,9 +1,22 @@
 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;
+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-esm/src/booking-wizard/features/room-options/room.d.ts

@@ -1,12 +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;
+  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-esm/src/booking-wizard/features/room-options/traveler-rooms.d.ts

@@ -1,9 +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;
+  index: number;
+  room: SelectableRoom;
+  onRoomChange: (index: number, accommodationCode: string, regimeCode: string | null) => void;
 }
 declare const TravelerRooms: React.FC<TravelerRoomsProps>;
 export default TravelerRooms;

package/build/build-esm/src/booking-wizard/features/sidebar/index.d.ts

@@ -1,7 +1,7 @@
 import React from 'react';
 interface SidebarProps {
-    productName: string;
-    thumbnailUrl?: string;
+  productName: string;
+  thumbnailUrl?: string;
 }
 declare const SidebarContainer: React.FC<SidebarProps>;
 export default SidebarContainer;

package/build/build-esm/src/booking-wizard/features/sidebar/sidebar-flight.d.ts

@@ -1,8 +1,8 @@
 import { BookingPackageFlightMetaData } from '@qite/tide-client/build/types';
 import React from 'react';
 interface SidebarFlightProps {
-    title: string;
-    flightMetaData: BookingPackageFlightMetaData;
+  title: string;
+  flightMetaData: BookingPackageFlightMetaData;
 }
 declare const SidebarFlight: React.FC<SidebarFlightProps>;
 export default SidebarFlight;