@soma-vertical-web/multi-lib-sacurai 0.0.1

package/contexts/contexts/cart/AddToCart.d.ts

@@ -0,0 +1,6 @@
+import { AddToCartContextProps, AddToCartProviderProps } from '../../../types/layout/team-components/AddToCart';
+
+declare const AddToCartContext: import('react').Context<AddToCartContextProps>;
+declare const AddToCartProvider: ({ children, delay, gap, ...props }: AddToCartProviderProps) => import("react/jsx-runtime").JSX.Element;
+declare const useAddToCartContext: () => AddToCartContextProps;
+export { AddToCartContext, AddToCartProvider, useAddToCartContext };

package/contexts/contexts/cart/Context.d.ts

@@ -0,0 +1,6 @@
+import { CartContextProps, CartProviderProps } from '../../../types/contexts/store/cart';
+
+declare const CartContext: import('react').Context<CartContextProps>;
+declare const CartProvider: ({ children, SELLER_CODE_VALIDATION_KEYS, CARTPROVIDER_MESSAGE_PRODUCT_REMOVE, data, ...props }: CartProviderProps) => import("react/jsx-runtime").JSX.Element;
+declare const useCartContext: () => CartContextProps;
+export { CartContext, CartProvider, useCartContext };

package/contexts/contexts/cart/MiniCartData.d.ts

@@ -0,0 +1,7 @@
+import { PropsWithChildren } from 'react';
+import { MiniCartDataContextProps } from '../../../types/contexts/contexts/cart/index';
+
+declare const MiniCartDataContext: import('react').Context<MiniCartDataContextProps>;
+declare const MiniCartDataProvider: ({ children }: PropsWithChildren) => import("react/jsx-runtime").JSX.Element;
+declare const useMiniCartDataContext: () => MiniCartDataContextProps;
+export { MiniCartDataContext, MiniCartDataProvider, useMiniCartDataContext };

package/contexts/contexts/cart/UIContext.d.ts

@@ -0,0 +1,6 @@
+import { UIContextProps, UIProviderProps } from '../../../types/contexts/contexts/cart';
+
+declare const UIContext: import('react').Context<UIContextProps>;
+declare const UIProvider: ({ children, ...props }: UIProviderProps) => import("react/jsx-runtime").JSX.Element;
+declare const useUIContext: () => UIContextProps;
+export { UIContext, UIProvider, useUIContext };

package/contexts/contexts/cms/FlagsAndTagsContext.d.ts

@@ -0,0 +1,27 @@
+import { FlagsAndTagsProviderProps } from '../../../types/contexts/contexts/cms/FlagsAndTags';
+import { IFlagsAndTagsContent } from '../../../types/cms/ContentTypes/FlagsAndTags';
+import { ProductType_PDC } from '../../../types/global/product';
+
+export declare const FlagsAndTagsContext: import('react').Context<{
+    tags: IFlagsAndTagsContent["config"];
+}>;
+export declare const FlagsAndTagsProvider: ({ data, children, }: FlagsAndTagsProviderProps) => import("react/jsx-runtime").JSX.Element;
+export declare const useFlagsAndTags: () => {
+    tags: {
+        commercial: {
+            items: import('../../../types/cms/ContentTypes/FlagsAndTags').FlagTagWithCluster[];
+        };
+        institucional: {
+            items: import('../../../types/cms/ContentTypes/FlagsAndTags').FlagTagWithCluster[];
+        };
+        flagDiscount: import('../../../types/cms/ContentTypes/FlagsAndTags').TagDiscountPercentage;
+        flagPdp: import('../../../types/cms/ContentTypes/FlagsAndTags').CommonFlagType;
+        flagGoldenPdp: import('../../../types/cms/ContentTypes/FlagsAndTags').FlagGoldenPdp;
+    };
+    getAvailableProductTag: (clusters: ProductType_PDC["cluster"]["highlights"]) => {
+        commercial: import('../../../types/cms/ContentTypes/FlagsAndTags').FlagTagWithCluster | undefined;
+        institucional: import('../../../types/cms/ContentTypes/FlagsAndTags').FlagTagWithCluster | undefined;
+        flagPdp: import('../../../types/cms/ContentTypes/FlagsAndTags').CommonFlagType;
+        flagGoldenPdp: import('../../../types/cms/ContentTypes/FlagsAndTags').FlagGoldenPdp | undefined;
+    };
+};

package/contexts/contexts/cms/PDPContentContext.d.ts

@@ -0,0 +1,6 @@
+import { PDPContentProviderProps } from '../../../types/cms/ContentTypes/PDP';
+
+export declare const PDPContentProvider: ({ children, data, productId, COMMON_PAGE_COLUMN_GAP, SectionZone, }: PDPContentProviderProps) => import("react/jsx-runtime").JSX.Element;
+export declare const usePDPContent: () => {
+    productId?: string;
+};

package/contexts/contexts/cms/PLPContentContext.d.ts

@@ -0,0 +1,4 @@
+import { PLPContentContextProps, PLPContentProviderProps } from '../../../types/cms/ContentTypes/PLP';
+
+export declare const PLPContentProvider: ({ children, data, device, SectionZone, COMMON_PAGE_COLUMN_GAP_PDC, }: PLPContentProviderProps) => import("react/jsx-runtime").JSX.Element;
+export declare const usePLPContent: () => PLPContentContextProps;

package/contexts/contexts/events/EventContext.d.ts

@@ -0,0 +1,6 @@
+import { EventContextProps, EventProviderProps } from '../../../types/data/events';
+
+declare const EventContext: import('react').Context<EventContextProps>;
+declare const EventProvider: ({ children, evtFunctionsConfigs }: EventProviderProps) => import("react/jsx-runtime").JSX.Element;
+declare const useEventContext: () => EventContextProps;
+export { EventContext, EventProvider, useEventContext };

package/contexts/contexts/header/HeaderCategoryContext.d.ts

@@ -0,0 +1,7 @@
+import { PropsWithChildren } from 'react';
+import { HeaderCategoryContext } from 'libs/multi-lib/src/types/layout/team-components/Header/index';
+
+declare const HeaderCategoryContext: import('react').Context<HeaderCategoryContext>;
+declare const HeaderCategoryProvider: ({ children }: PropsWithChildren) => import("react/jsx-runtime").JSX.Element;
+declare const useHeaderCategoryContext: () => HeaderCategoryContext;
+export { HeaderCategoryContext, HeaderCategoryProvider, useHeaderCategoryContext, };

package/contexts/contexts/header/HeaderContext.d.ts

@@ -0,0 +1,6 @@
+import { HeaderContextProps, HeaderProviderProps } from '../../../types/layout/team-components/Header';
+
+declare const HeaderContext: import('react').Context<HeaderContextProps>;
+declare const HeaderProvider: ({ children, headerData, ...props }: HeaderProviderProps) => import("react/jsx-runtime").JSX.Element;
+declare const useHeaderContext: () => HeaderContextProps;
+export { HeaderContext, HeaderProvider, useHeaderContext };

package/contexts/contexts/header/MenuMobileContext.d.ts

@@ -0,0 +1,7 @@
+import { CommonProps, ContextProps } from '../../../types/layout/team-components/Menu/Mobile';
+import { PropsWithChildren } from 'react';
+
+declare const MenuMobileContext: import('react').Context<ContextProps>;
+declare const MenuMobileProvider: ({ children, ...props }: PropsWithChildren<CommonProps>) => import("react/jsx-runtime").JSX.Element;
+declare const useMenuMobileContext: () => ContextProps;
+export { MenuMobileContext, MenuMobileProvider, useMenuMobileContext };

package/contexts/contexts/header/TipBarContext.d.ts

@@ -0,0 +1,6 @@
+import { TipBarContextProps, TipBarProviderProps } from '../../../types/contexts/contexts/header';
+
+declare const TipBarContext: import('react').Context<TipBarContextProps>;
+declare const TipBarProvider: ({ data, children, ...rest }: TipBarProviderProps) => import("react/jsx-runtime").JSX.Element;
+declare const useTipBarContext: () => TipBarContextProps;
+export { TipBarContext, TipBarProvider, useTipBarContext };

package/contexts/contexts/header/UserMenuContext.d.ts

@@ -0,0 +1,6 @@
+import { UserMenuContextProps, UserMenuProviderProps } from '../../../types/layout/team-components/UserMenu';
+
+declare const UserMenuContext: import('react').Context<UserMenuContextProps>;
+declare const UserMenuProvider: ({ children, delay, gap, isOpen, setIsOpen, target, ...props }: UserMenuProviderProps) => import("react/jsx-runtime").JSX.Element;
+declare const useUserMenuContext: () => UserMenuContextProps;
+export { UserMenuContext, UserMenuProvider, useUserMenuContext };

package/contexts/contexts/newsletter/Context.d.ts

@@ -0,0 +1,6 @@
+import { NewsletterContextProps, NewsletterProviderProps } from '../../../types/layout/team-components/Newsletter';
+
+declare const NewsletterContext: import('react').Context<NewsletterContextProps>;
+declare const NewsletterProvider: ({ children, masterDataEmailField, fields, variant, CONSTANTS: { MASTER_DATA_ENTITY, NEWSLETTER_CONFIGS }, }: NewsletterProviderProps) => import("react/jsx-runtime").JSX.Element;
+declare const useNewsletterContext: () => NewsletterContextProps;
+export { NewsletterContext, NewsletterProvider, useNewsletterContext };

package/contexts/contexts/pdp/PDPContext.d.ts

@@ -0,0 +1,6 @@
+import { PDPContextProps, PDPProviderProps } from '../../../types/contexts/contexts/pdp';
+
+declare const PDPContext: import('react').Context<PDPContextProps>;
+declare const PDPProvider: ({ children, gridScrollBack }: PDPProviderProps) => import("react/jsx-runtime").JSX.Element;
+declare const usePDPContext: () => PDPContextProps;
+export { PDPProvider, usePDPContext, PDPContext };

package/contexts/contexts/pdp/PDPDataContext.d.ts

@@ -0,0 +1,4 @@
+import { PDPDataContextProps, PDPDataProviderProps } from '../../../types/contexts/contexts/pdp';
+
+export declare const PDPDataProvider: ({ children, productData, isKit, PDP_INFO, NAME_SPLIT_SYMBOL, TEXTURE_IMAGE, }: PDPDataProviderProps) => import("react/jsx-runtime").JSX.Element;
+export declare const usePDPDataContext: () => PDPDataContextProps;

package/contexts/contexts/plp/FilterContext.d.ts

@@ -0,0 +1,6 @@
+import { FilterContextProps, FilterProviderProps } from '../../../types/layout/team-components/Filter';
+
+declare const FilterContext: import('react').Context<FilterContextProps>;
+declare const FilterProvider: ({ children, filters, PLP_FILTERS, ...props }: FilterProviderProps) => import("react/jsx-runtime").JSX.Element;
+declare const useFilterContext: () => FilterContextProps;
+export { FilterContext, FilterProvider, useFilterContext };

package/contexts/contexts/plp/PLPConstants.d.ts

@@ -0,0 +1,6 @@
+import { PLPConstantsContextProps, PLPConstantsProviderProps } from '../../../types/contexts/contexts/plp';
+
+declare const PLPConstants: import('react').Context<PLPConstantsContextProps>;
+declare const PLPConstantsProvider: ({ children, ...props }: PLPConstantsProviderProps) => import("react/jsx-runtime").JSX.Element;
+declare const usePLPConstants: () => PLPConstantsContextProps;
+export { PLPConstants, PLPConstantsProvider, usePLPConstants };

package/contexts/contexts/plp/PLPContext.d.ts

@@ -0,0 +1,6 @@
+import { PLPContextProps, PLPProviderProps } from '../../../types/contexts/contexts/plp';
+
+declare const PLPContext: import('react').Context<PLPContextProps>;
+declare const PLPProvider: ({ children, slug, searchParams, collectionId, brand, itemsPerPage, PLP_SORT_DEFAULT }: PLPProviderProps) => import("react/jsx-runtime").JSX.Element;
+declare const usePLPContext: () => PLPContextProps;
+export { PLPContext, PLPProvider, usePLPContext };

package/contexts/contexts/plp/PLPInfiniteContext.tsx.d.ts

@@ -0,0 +1,6 @@
+import { PLPInfiniteContextProps, PLPInfiniteProviderProps } from '../../../types/contexts/contexts/plp';
+
+declare const PLPInfiniteContext: import('react').Context<PLPInfiniteContextProps>;
+declare const PLPInfiniteProvider: ({ banners, children }: PLPInfiniteProviderProps) => import("react/jsx-runtime").JSX.Element;
+declare const usePLPInfiniteContext: () => PLPInfiniteContextProps;
+export { PLPInfiniteContext, PLPInfiniteProvider, usePLPInfiniteContext };

package/contexts/contexts/plp/PLPNavigationContext.d.ts

@@ -0,0 +1,6 @@
+import { PDCNavigationContextProps, PDCNavigationProviderProps } from '../../../types/layout/team-components/PLPNavigation';
+
+declare const PDCNavigationContext: import('react').Context<PDCNavigationContextProps>;
+declare const PDCNavigationProvider: ({ children, ...props }: PDCNavigationProviderProps) => import("react/jsx-runtime").JSX.Element;
+declare const usePLPNavigationContext: () => PDCNavigationContextProps;
+export { PDCNavigationContext, PDCNavigationProvider, usePLPNavigationContext };

package/contexts/contexts/product-card/ProductCardContext.d.ts

@@ -0,0 +1,6 @@
+import { ProductCardContextProps, ProductCardProviderProps } from '../../../types/layout/team-components/ProductCard';
+
+declare const ProductCardContext: import('react').Context<ProductCardContextProps>;
+declare const ProductCardProvider: ({ children, item, index, shelfTitle, ...props }: ProductCardProviderProps) => import("react/jsx-runtime").JSX.Element;
+declare const useProductCardContext: () => ProductCardContextProps;
+export { ProductCardContext, ProductCardProvider, useProductCardContext };

package/contexts/contexts/search/Constants.d.ts

@@ -0,0 +1,6 @@
+import { SearchConstantsProviderProps, SearchConstantsContextProps } from '../../../types/contexts/contexts/search';
+
+declare const SearchConstants: import('react').Context<SearchConstantsContextProps>;
+declare const SearchConstantsProvider: ({ children, ...props }: SearchConstantsProviderProps) => import("react/jsx-runtime").JSX.Element;
+declare const useSearchConstants: () => SearchConstantsContextProps;
+export { SearchConstants, SearchConstantsProvider, useSearchConstants };

package/contexts/contexts/search/Facets.d.ts

@@ -0,0 +1,5 @@
+import { FacetsContextProps, FacetsProviderProps } from '../../../types/contexts/contexts/search';
+
+declare const FacetsProvider: ({ children, forceUpdate, }: FacetsProviderProps) => import("react/jsx-runtime").JSX.Element;
+declare const useFacetsContext: () => FacetsContextProps;
+export { FacetsProvider, useFacetsContext };

package/contexts/contexts/search/Products.d.ts

@@ -0,0 +1,5 @@
+import { ProductsContextProps, ProductsProviderProps } from '../../../types/contexts/contexts/search';
+
+declare const ProductsProvider: ({ children, query, forceUpdate, }: ProductsProviderProps) => import("react/jsx-runtime").JSX.Element;
+declare const useProductsContext: () => ProductsContextProps;
+export { ProductsProvider, useProductsContext };

package/contexts/contexts/search/Root.d.ts

@@ -0,0 +1,5 @@
+import { RootContextProps, RootProviderProps } from '../../../types/contexts/contexts/search';
+
+declare const RootProvider: ({ children, fetch }: RootProviderProps) => import("react/jsx-runtime").JSX.Element;
+declare const useRootContext: () => RootContextProps;
+export { RootProvider, useRootContext };

package/contexts/contexts/search/Search.d.ts

@@ -0,0 +1,5 @@
+import { SearchProviderProps, SearchContextProps } from '../../../types/contexts/contexts/search';
+
+declare const SearchProvider: ({ children, sort, state, count, collectionId, brand, searchParams, ITEMS_PER_PAGE }: SearchProviderProps) => import("react/jsx-runtime").JSX.Element;
+declare const useSearchContext: () => SearchContextProps;
+export { SearchProvider, useSearchContext };

package/contexts/contexts/search/SuggestedTerms.d.ts

@@ -0,0 +1,5 @@
+import { SuggestedTermsContextProps, SuggestedTermsProviderProps } from '../../../types/contexts/contexts/search';
+
+declare const SuggestedTermsProvider: ({ children, ...props }: SuggestedTermsProviderProps) => import("react/jsx-runtime").JSX.Element;
+declare const useSuggestedTermsContext: () => SuggestedTermsContextProps;
+export { SuggestedTermsProvider, useSuggestedTermsContext, };

package/contexts/contexts/search/TopSearches.d.ts

@@ -0,0 +1,6 @@
+import { TopSearchesContextProps } from '../../../types/contexts/contexts/search';
+import { PropsWithChildren } from 'react';
+
+declare const TopSearchesProvider: ({ children }: PropsWithChildren) => import("react/jsx-runtime").JSX.Element;
+declare const useTopSearches: () => TopSearchesContextProps;
+export { TopSearchesProvider, useTopSearches };

package/contexts/hooks/useBackPDC.d.ts

@@ -0,0 +1,3 @@
+import { UseBackPDCProps } from '../../types/contexts/hooks';
+
+export declare const useBackPDC: ({ gridScrollBack }: UseBackPDCProps) => void;

package/contexts/hooks/useClipboard.d.ts

@@ -0,0 +1,4 @@
+type CopiedValue = string | null;
+type CopyFn = (text: string) => Promise<boolean>;
+export declare const useClipboard: () => [CopiedValue, CopyFn];
+export {};

package/contexts/hooks/useDisableZoom.d.ts

@@ -0,0 +1 @@
+export declare const useDisableZoom: () => void;

package/contexts/hooks/useLocalStorage.d.ts

@@ -0,0 +1 @@
+export declare const useLocalStorage: (key: any, defaultValue: any) => any[];

package/contexts/hooks/useMediator.d.ts

@@ -0,0 +1 @@
+export declare function useMediator<T>(event: string, handler: (data: T) => void): void;

package/contexts/hooks/useOnClickOutside.d.ts

@@ -0,0 +1,3 @@
+export declare const useOnClickOutside: <T extends HTMLElement = HTMLElement>(callback: () => void) => {
+    ref: import('react').RefObject<T | null>;
+};

package/contexts/hooks/useOnScreen.d.ts

@@ -0,0 +1,4 @@
+import { ObserverProps } from '../../types/layout/utils';
+import { MutableRefObject } from 'react';
+
+export declare function useOnScreen(ref: MutableRefObject<HTMLElement | null>, stopOnIntersection?: boolean, observerOptions?: ObserverProps['observerOptions']): boolean;

package/contexts/hooks/useOperations.d.ts

@@ -0,0 +1,19 @@
+import { CartItemStore, AddToCart } from '../../types/contexts/store/cart';
+import { SelectedAddress } from '../../types/data/api/checkout/order-form';
+import { ShippingOption, ShippingData, DeliveryMode } from '../../types/data/api/checkout/order-form/shipping';
+
+declare const useOperations: () => {
+    addCoupon: (orderFormId: string, coupon: string) => Promise<any>;
+    addItem: (orderFormId: string, items: CartItemStore[], item: AddToCart | AddToCart[]) => Promise<any>;
+    addSellerCode: (orderFormId: string, code: string, keys?: Record<string, string>, isOpen?: boolean) => Promise<any>;
+    addMarketingData: (orderFormId: string, marketingData: any) => Promise<any>;
+    giftItem: (orderFormId: string, id: string, itemIndex: number, remove?: boolean) => Promise<any>;
+    emptyCart: (orderFormId: string) => Promise<any>;
+    getOrderForm: (orderFormId?: string, priority?: "low" | "high") => Promise<any>;
+    insertProfileEmail: (orderFormId: string, email: string) => Promise<any>;
+    removeItem: (orderFormId: string, itemsStore: CartItemStore[], productId: string) => Promise<any>;
+    shipping: (orderFormId: string, postalCode: string, country: string, index: number, selectedAddresses: SelectedAddress[], deliveryMode?: DeliveryMode | null, setDeliveryWindow?: boolean) => Promise<any>;
+    shippingUpdate: (orderFormId: string, options?: ShippingOption[], selectedAddresses?: ShippingData["selectedAddresses"]) => Promise<any>;
+    updateItemQuantity: (orderFormId: string, items: CartItemStore[], productId: string, quantity: number, quantityOld: number) => Promise<any>;
+};
+export default useOperations;

package/contexts/hooks/useScrollRestoration.d.ts

@@ -0,0 +1,3 @@
+import { UseScrollRestorationProps } from '../../types/contexts/hooks';
+
+export declare const useScrollRestoration: ({ productCount, PLP_GRID_SCROLL_BACK }: UseScrollRestorationProps) => void;

package/contexts/hooks/useScrollRestorationInfinite.d.ts

@@ -0,0 +1,4 @@
+import { UseScrollRestorationInfiniteProps } from '../../types/contexts/hooks';
+
+export declare const useScrollRestorationInfinite: ({ pages, load, PLP_GRID_SCROLL_BACK }: UseScrollRestorationInfiniteProps) => void;
+export default useScrollRestorationInfinite;

package/contexts/hooks/useSentinel.d.ts

@@ -0,0 +1,11 @@
+export declare const useSentinel: ({ callback, onEnterViewportOnce, options, }: {
+    callback: Function;
+    onEnterViewportOnce?: boolean;
+    options: {
+        root?: Element | Document | null;
+        rootMargin?: string;
+        threshold?: number | number[];
+    };
+}) => {
+    element: import('react').RefObject<HTMLDivElement | null>;
+};

package/contexts/hooks/useTouchZoomPan.d.ts

@@ -0,0 +1,8 @@
+export declare const useTouchZoomPan: ({ defaultScale, maxScale, }: {
+    defaultScale?: number | undefined;
+    maxScale?: number | undefined;
+}) => {
+    containerRef: import('react').RefObject<HTMLDivElement | null>;
+    imgRef: import('react').RefObject<HTMLImageElement | null>;
+    scale: number;
+};

package/contexts/index.d.ts

@@ -0,0 +1,159 @@
+import { useOnScreen } from './hooks/useOnScreen';
+import { Mediator } from './contexts/GlobalContext';
+
+import * as cart from './store/cart';
+import * as header from './store/header';
+import * as pdp from './store/pdp';
+import * as wishlist from './store/wishlist';
+export declare const contexts: {
+    contexts: {
+        addToCart: {
+            hook: () => import('../types/layout/team-components/AddToCart').AddToCartContextProps;
+            provider: ({ children, delay, gap, ...props }: import('../types/layout/team-components/AddToCart').AddToCartProviderProps) => import("react/jsx-runtime").JSX.Element;
+        };
+        cart: {
+            hook: () => import('../types/contexts/store/cart').CartContextProps;
+            provider: ({ children, SELLER_CODE_VALIDATION_KEYS, CARTPROVIDER_MESSAGE_PRODUCT_REMOVE, data, ...props }: import('../types/contexts/store/cart').CartProviderProps) => import("react/jsx-runtime").JSX.Element;
+        };
+        cms: {
+            FlagsAndTags: {
+                context: import('react').Context<{
+                    tags: import('../types/cms/ContentTypes/FlagsAndTags').IFlagsAndTagsContent["config"];
+                }>;
+                hook: () => {
+                    tags: {
+                        commercial: {
+                            items: import('../types/cms/ContentTypes/FlagsAndTags').FlagTagWithCluster[];
+                        };
+                        institucional: {
+                            items: import('../types/cms/ContentTypes/FlagsAndTags').FlagTagWithCluster[];
+                        };
+                        flagDiscount: import('../types/cms/ContentTypes/FlagsAndTags').TagDiscountPercentage;
+                        flagPdp: import('../types/cms/ContentTypes/FlagsAndTags').CommonFlagType;
+                        flagGoldenPdp: import('../types/cms/ContentTypes/FlagsAndTags').FlagGoldenPdp;
+                    };
+                    getAvailableProductTag: (clusters: import('../types/global/product').ProductType_PDC["cluster"]["highlights"]) => {
+                        commercial: import('../types/cms/ContentTypes/FlagsAndTags').FlagTagWithCluster | undefined;
+                        institucional: import('../types/cms/ContentTypes/FlagsAndTags').FlagTagWithCluster | undefined;
+                        flagPdp: import('../types/cms/ContentTypes/FlagsAndTags').CommonFlagType;
+                        flagGoldenPdp: import('../types/cms/ContentTypes/FlagsAndTags').FlagGoldenPdp | undefined;
+                    };
+                };
+                provider: ({ data, children, }: import('../types/contexts/contexts/cms/FlagsAndTags').FlagsAndTagsProviderProps) => import("react/jsx-runtime").JSX.Element;
+            };
+        };
+        newsletter: {
+            hook: () => import('../types/layout/team-components/Newsletter').NewsletterContextProps;
+            provider: ({ children, masterDataEmailField, fields, variant, CONSTANTS: { MASTER_DATA_ENTITY, NEWSLETTER_CONFIGS }, }: import('../types/layout/team-components/Newsletter').NewsletterProviderProps) => import("react/jsx-runtime").JSX.Element;
+        };
+        events: {
+            hook: () => import('../types/data/events').EventContextProps;
+            provider: ({ children, evtFunctionsConfigs }: import('../types/data/events').EventProviderProps) => import("react/jsx-runtime").JSX.Element;
+        };
+        global: {
+            hook: () => import('../types/contexts/contexts/global').GlobalContextProps;
+            provider: ({ children, headerConfigs, pathname, ...props }: import('../types/contexts/contexts/global').GlobalProviderProps) => import("react/jsx-runtime").JSX.Element;
+            mediator: typeof Mediator;
+        };
+        header: {
+            hook: () => import('../types/layout/team-components/Header').HeaderContextProps;
+            provider: ({ children, headerData, ...props }: import('../types/layout/team-components/Header').HeaderProviderProps) => import("react/jsx-runtime").JSX.Element;
+        };
+        menuMobile: {
+            hook: () => import('../types/layout/team-components/Menu/Mobile').ContextProps;
+            provider: ({ children, ...props }: import('react').PropsWithChildren<import('../types/layout/team-components/Menu/Mobile').CommonProps>) => import("react/jsx-runtime").JSX.Element;
+        };
+        next: {
+            hook: () => {
+                pathname: string;
+                nextimage: React.ComponentType<any>;
+                router: import('next/dist/shared/lib/app-router-context.shared-runtime').AppRouterInstance;
+            };
+            provider: ({ children, ...props }: import('../types/contexts/contexts/next').NextProviderProps) => import("react/jsx-runtime").JSX.Element;
+        };
+        pdp: {
+            provider: ({ children, gridScrollBack }: import('../types/contexts/contexts/pdp').PDPProviderProps) => import("react/jsx-runtime").JSX.Element;
+        };
+        PDPContent: {
+            provider: ({ children, data, productId, COMMON_PAGE_COLUMN_GAP, SectionZone, }: import('../types/cms/ContentTypes/PDP').PDPContentProviderProps) => import("react/jsx-runtime").JSX.Element;
+            hook: () => {
+                productId?: string;
+            };
+        };
+        plp: {
+            provider: ({ children, slug, searchParams, collectionId, brand, itemsPerPage, PLP_SORT_DEFAULT }: import('../types/contexts/contexts/plp').PLPProviderProps) => import("react/jsx-runtime").JSX.Element;
+            hook: () => import('../types/contexts/contexts/plp').PLPContextProps;
+        };
+        plpFilter: {
+            hook: () => import('../types/layout/team-components/Filter').FilterContextProps;
+            provider: ({ children, filters, PLP_FILTERS, ...props }: import('../types/layout/team-components/Filter').FilterProviderProps) => import("react/jsx-runtime").JSX.Element;
+        };
+        PLPContent: {
+            provider: ({ children, data, device, SectionZone, COMMON_PAGE_COLUMN_GAP_PDC, }: import('../types/cms/ContentTypes/PLP').PLPContentProviderProps) => import("react/jsx-runtime").JSX.Element;
+            hook: () => import('../types/cms/ContentTypes/PLP').PLPContentContextProps;
+        };
+        plpInfinite: {
+            provider: ({ banners, children }: import('../types/contexts/contexts/plp').PLPInfiniteProviderProps) => import("react/jsx-runtime").JSX.Element;
+            hook: () => import('../types/contexts/contexts/plp').PLPInfiniteContextProps;
+        };
+        pdpdata: {
+            provider: ({ children, productData, isKit, PDP_INFO, NAME_SPLIT_SYMBOL, TEXTURE_IMAGE, }: import('../types/contexts/contexts/pdp').PDPDataProviderProps) => import("react/jsx-runtime").JSX.Element;
+        };
+        searchFacets: {
+            hook: () => import('../types/contexts/contexts/search').FacetsContextProps;
+            provider: ({ children, forceUpdate, }: import('../types/contexts/contexts/search').FacetsProviderProps) => import("react/jsx-runtime").JSX.Element;
+        };
+        searchProducts: {
+            hook: () => import('../types/contexts/contexts/search').ProductsContextProps;
+            provider: ({ children, query, forceUpdate, }: import('../types/contexts/contexts/search').ProductsProviderProps) => import("react/jsx-runtime").JSX.Element;
+        };
+        searchRoot: {
+            hook: () => import('../types/contexts/contexts/search').RootContextProps;
+            provider: ({ children, fetch }: import('../types/contexts/contexts/search').RootProviderProps) => import("react/jsx-runtime").JSX.Element;
+        };
+        searchSearch: {
+            hook: () => import('../types/contexts/contexts/search').SearchContextProps;
+            provider: ({ children, sort, state, count, collectionId, brand, searchParams, ITEMS_PER_PAGE }: import('../types/contexts/contexts/search').SearchProviderProps) => import("react/jsx-runtime").JSX.Element;
+        };
+        session: {
+            hook: () => import('../types/contexts/contexts/session').ISessionContext;
+            provider: ({ children, AUTH_TOKEN_COOKIE, accountName, }: import('../types/contexts/contexts/session').SessionProviderProps) => import("react/jsx-runtime").JSX.Element;
+        };
+        ui: {
+            hook: () => import('../types/contexts/contexts/cart').UIContextProps;
+            provider: ({ children, ...props }: import('../types/contexts/contexts/cart').UIProviderProps) => import("react/jsx-runtime").JSX.Element;
+        };
+    };
+    hooks: {
+        useBackPDC: ({ gridScrollBack }: import('../types/contexts/hooks').UseBackPDCProps) => void;
+        useClipboard: () => [string | null, (text: string) => Promise<boolean>];
+        useDisableZoom: () => void;
+        useLocalStorage: (key: any, defaultValue: any) => any[];
+        useOnScreen: typeof useOnScreen;
+        useSentinel: ({ callback, onEnterViewportOnce, options, }: {
+            callback: Function;
+            onEnterViewportOnce?: boolean;
+            options: {
+                root?: Element | Document | null;
+                rootMargin?: string;
+                threshold?: number | number[];
+            };
+        }) => {
+            element: import('react').RefObject<HTMLDivElement | null>;
+        };
+        useTouchZoomPan: ({ defaultScale, maxScale, }: {
+            defaultScale?: number | undefined;
+            maxScale?: number | undefined;
+        }) => {
+            containerRef: import('react').RefObject<HTMLDivElement | null>;
+            imgRef: import('react').RefObject<HTMLImageElement | null>;
+            scale: number;
+        };
+    };
+    stores: {
+        cart: typeof cart;
+        header: typeof header;
+        pdp: typeof pdp;
+        wishlist: typeof wishlist;
+    };
+};

package/contexts/store/cart.d.ts

@@ -0,0 +1,11 @@
+import { CartStore } from '../../types/contexts/store/cart';
+
+export declare const KEY_INDEXED_STORE = "soma::cart";
+export declare const KEY_INDEXED_OPTIONS = "soma::options";
+export declare const useCartStore: import('zustand').UseBoundStore<import('zustand').StoreApi<CartStore>>;
+export declare const useGetCartStoreState: () => CartStore;
+export declare const useGetNotificationsStore: () => import('../../types/contexts/store/cart').NotificationStore[];
+export declare const useGetNotificationActions: () => {
+    addNotification(message: string, callback?: () => void): void;
+    removeNotification(id: number): void;
+};

package/contexts/store/header.d.ts

@@ -0,0 +1,24 @@
+import { HeaderCategoryStore } from '../../types/contexts/store/header';
+
+export declare const resetAllHeaderStores: () => void;
+export declare const useGetHeaderCategoryStore: () => HeaderCategoryStore;
+export declare const useActionsHeaderCategory: () => {
+    reset: () => void;
+    setValue: (value: HeaderCategoryStore) => void;
+    updateValue: (value: HeaderCategoryStore) => void;
+};
+export declare const useGetMenuMobileIsOpen: () => boolean;
+export declare const useActionsMenuMobileIsOpen: () => {
+    reset: () => void;
+    setValue: (value: boolean) => void;
+};
+export declare const useGetSearchModalIsOpen: () => boolean;
+export declare const useActionsSearchModalIsOpen: () => {
+    reset: () => void;
+    setValue: (value: boolean) => void;
+};
+export declare const useGetUserMenuIsOpen: () => boolean;
+export declare const useActionsUserMenuIsOpen: () => {
+    reset: () => void;
+    setValue: (value: boolean) => void;
+};

package/contexts/store/helpers.d.ts

@@ -0,0 +1,3 @@
+import { CommonUseStoreType } from '../../types/contexts/store/helpers';
+
+export declare const commonCreateStore: <T>(initialValue: T, storeResetFns?: Set<() => void>) => import('zustand').UseBoundStore<import('zustand').StoreApi<CommonUseStoreType<T>>>;

package/contexts/store/pdp.d.ts

@@ -0,0 +1,28 @@
+import { SelectedSkuInfoType } from '../../types/contexts/store/pdp';
+
+export declare const resetAllPDPStores: () => void;
+export declare const useGetPDPSelectedSkuInfo: () => SelectedSkuInfoType;
+export declare const useActionsPDPSelectedSkuInfo: () => {
+    reset: () => void;
+    setValue: (value: SelectedSkuInfoType) => void;
+};
+export declare const useGetPDPOpenLetMeKnow: () => boolean;
+export declare const useActionsPDPOpenLetMeKnow: () => {
+    reset: () => void;
+    setValue: (value: boolean) => void;
+};
+export declare const useGetPDPShowNotify: () => boolean;
+export declare const useActionsPDPShowNotify: () => {
+    reset: () => void;
+    setValue: (value: boolean) => void;
+};
+export declare const useGetPDPShowBottomNavigation: () => boolean;
+export declare const useActionsPDPShowBottomNavigation: () => {
+    reset: () => void;
+    setValue: (value: boolean) => void;
+};
+export declare const useGetPDPOpenMeasurements: () => boolean;
+export declare const useActionsPDPOpenMeasurements: () => {
+    reset: () => void;
+    setValue: (value: boolean) => void;
+};

package/contexts/store/plp.d.ts

@@ -0,0 +1,3 @@
+import { PageState } from '../../types/contexts/contexts/plp';
+
+export declare const usePLPInfiniteScroll: import('zustand').UseBoundStore<import('zustand').StoreApi<PageState>>;

package/contexts/store/wishlist.d.ts

@@ -0,0 +1,12 @@
+export declare const useGetWishlistStore: () => string[];
+export declare const useGetWishlistFeedbackStore: () => {
+    active: boolean;
+    action: "add" | "remove" | "";
+};
+export declare const useActionsWishlistStore: () => {
+    reset: () => void;
+    setValue: (value: import('../../types/contexts/store/wishlist').WishListStateValue) => void;
+    toggleProduct: (productId: string) => void;
+    updateList: (list: string[]) => void;
+    resetFeedback: () => void;
+};

package/data/api/DitoIngest/sendDitoEvent.d.ts

@@ -0,0 +1,3 @@
+import { DitoIdentifyBody, DitoTrackBody } from '../../../types/data/api/dito-ingest';
+
+export declare const sendDitoEvent: (data: Array<DitoIdentifyBody | DitoTrackBody>) => Promise<any>;

package/data/api/catalog/index.d.ts

@@ -0,0 +1,2 @@
+export * from './kit';
+export * from './product/info';

package/data/api/catalog/kit/index.d.ts

@@ -0,0 +1,11 @@
+import { FetchFunctionsProps } from '../../../../types/data/api';
+
+import * as yup from 'yup';
+declare const schema: yup.ObjectSchema<{
+    skuId: string | undefined;
+}, yup.AnyObject, {
+    skuId: undefined;
+}, "">;
+type SchemaType = yup.InferType<typeof schema>;
+export declare function getCatalogKitProducts({ apiUrl, body, fetchOptions }: FetchFunctionsProps<SchemaType>): Promise<any>;
+export {};