@sentecacommerce-theme/lib 0.13.5-alpha.5 → 0.13.5

package/dist/types/hooks/useProduct/index.d.ts

@@ -1,24 +1,8 @@
 import React from 'react';
-import { ProductDTO, ProductVariantDTO, AttributeRuleDTO, ProductAttributeDraftDTO, SelectedOptionDTO, ReviewRatingStatisticsDTO, AssetSourceDTO } from '@sentecacommerce/sdk';
-import { SelectedOptionType } from './utils';
+import type { ProductDTO, ReviewRatingStatisticsDTO } from '@sentecacommerce/sdk';
 import { getProductBySlugConfig } from '../../api/productsApi';
 import { AssetsMap } from '../../utils/assetsToMap';
-export { AssetSourceDTO };
-export interface OptionsType {
-    definitionKey: string;
-    label: string;
-    elements?: SubOptionType[];
-}
-export interface SubOptionType {
-    optionKey: string;
-    label: string;
-    imageIndex?: number;
-}
-export interface ContentType {
-    key: string;
-    name?: string;
-    content?: string;
-}
+import { VariantMap, VariantType, ContentType, AttributeRulesMap } from '../useProductVariants';
 export interface MetaInfoCategoryType {
     name: string;
     id: string;
@@ -56,65 +40,6 @@ interface SeoInformationType {
     description?: string;
     keywords?: string;
 }
-interface AttributeRulesType extends AttributeRuleDTO {
-    label: string;
-    values: {
-        [id: string]: {
-            label: string;
-            extra: any;
-            combinations: {
-                [id: string]: string;
-            };
-        };
-    };
-}
-export interface VariantType extends Omit<ProductVariantDTO, 'attributes' | 'availableOptions' | 'selectedOptions' | 'labels'> {
-    attributes: ProductAttributeDraftDTO[];
-    options?: OptionsType[];
-    selectedOptions: SelectedOptionDTO[];
-    mappedSelectedOptions?: SelectedOptionType[];
-    isAvailable: boolean;
-    quantity?: number;
-    inventory: {
-        hasAvailableQuantity?: boolean;
-        availableQuantity?: number;
-    };
-    labels?: string[];
-    getAttribute: (rule: string) => {
-        id: string;
-        label: string;
-        name: string;
-        extra: any;
-        combinations: {
-            [id: string]: string;
-        };
-    };
-    getAttributeByKey: (key: string) => undefined | any;
-    getAvailabilityByStore: () => InventoryAvailabilityType[] | undefined;
-}
-interface VariantMap {
-    [productId: string]: VariantType;
-}
-export interface BooleanKVP {
-    [sku: string]: boolean | undefined;
-}
-export interface AttributeRulesMap {
-    [name: string]: AttributeRulesType;
-}
-export interface CombinationsMap {
-    [id: string]: {
-        value: string;
-        params: {
-            [id: string]: string;
-        };
-    };
-}
-export interface InventoryAvailabilityType {
-    storeName: string;
-    availableQuantity: number;
-    acceptsBackorders: boolean;
-    restockableInDays: number;
-}
 declare type ProductProviderProps = {
     children: React.ReactNode;
     product?: ProductDTO;
@@ -129,6 +54,7 @@ declare type ProductProviderProps = {
         expand?: string;
         project?: string;
     };
+    includeBrandInName?: boolean;
 };
 declare type ProductStateContextType = {
     attributeRules: AttributeRulesMap;
@@ -136,6 +62,7 @@ declare type ProductStateContextType = {
     seoData: SeoInformationType;
     variants?: VariantMap;
     selectedVariant?: VariantType | null;
+    collapsedImages?: object;
 };
 export declare type VideoType = {
     type: string;
@@ -163,7 +90,8 @@ declare type CountFunctionsContextType = {
     };
     getProductVideos: () => VideoType[];
 };
-export declare function ProductProvider({ product, children, defaultVariantId, }: ProductProviderProps): JSX.Element;
+export declare function ProductProvider({ product, children, defaultVariantId, includeBrandInName, }: ProductProviderProps): JSX.Element;
 export declare function useProductState(): ProductStateContextType;
 export declare function useProductFunctions(): CountFunctionsContextType;
 export declare function useProduct(slug: string, config?: getProductBySlugConfig): import("react-query").QueryResult<ProductDTO, unknown>;
+export {};

package/dist/types/hooks/useProduct/utils/index.d.ts

@@ -1,5 +1,6 @@
-import { ProductAttributeDTO, CustomField, ProductDTO, ProductVariantDTO, InventoryAvailability, OptionDefinitionDTO, SelectedOptionDTO, IdReferenceDTO, ProductVariantLabelDTO } from '@sentecacommerce/sdk';
-import { AttributeRulesMap, CombinationsMap, BooleanKVP, InventoryAvailabilityType, MetaInformationType, OptionsType } from '../index';
+import { ProductAttributeDTO, CustomField, ProductDTO, ProductVariantDTO, InventoryAvailability, OptionDefinitionDTO, SelectedOptionDTO, IdReferenceDTO, ProductVariantLabelDTO, AttributeRuleDTO } from '@sentecacommerce/sdk';
+import { InventoryAvailabilityType, OptionsType, AttributeRulesMap, BooleanKVP, CombinationsMap } from '../../useProductVariants';
+import { MetaInformationType } from '../index';
 export declare const createCustomFieldsMap: (customFields?: CustomField[] | undefined) => BooleanKVP | undefined;
 export declare const createCombinationsMap: (mappedAttributeRulesKeys: string[], attributesArray: {
     variantId: string;
@@ -11,7 +12,8 @@ export declare const createProductContent: (data: any) => {
     name: string;
     content: string;
 };
-export declare const createAttributeRulesMap: (product?: ProductDTO | undefined) => any;
+export declare const createCollapseKeyImagesMap: (product?: ProductDTO | undefined) => {} | undefined;
+export declare const createAttributeRulesMap: (product?: ProductDTO | undefined, isLineItem?: boolean) => any;
 export declare const createMappedOptions: (options?: OptionDefinitionDTO[] | undefined) => OptionsType[];
 export declare type SelectedOptionType = {
     label?: string;
@@ -23,7 +25,7 @@ export declare type SelectedOptionType = {
 };
 export declare const createSelectedOption2: (options?: OptionsType[] | undefined, selectedOption?: SelectedOptionDTO | undefined) => SelectedOptionType;
 export declare const createSelectedOption: (options?: OptionDefinitionDTO[] | undefined, selectedOption?: SelectedOptionDTO | undefined) => SelectedOptionType;
-export declare const createMappedAttributes: (currentVariant: ProductVariantDTO) => ProductAttributeDTO[];
+export declare const createMappedAttributes: (currentVariant: ProductVariantDTO, isLineItem?: boolean) => any;
 export declare const processAvailabilityPerStore: (availabilities?: InventoryAvailability[] | undefined) => InventoryAvailabilityType[] | undefined;
 export declare const getProductVideos: (assets: MetaInformationType['assets']) => {
     type: string;
@@ -39,3 +41,4 @@ export declare const formatCategories: (categories?: IdReferenceDTO[] | undefine
     link: string;
 }[];
 export declare const createLabelsMap: (data?: ProductVariantLabelDTO[] | undefined) => string[] | undefined;
+export declare function remapLineItemAttributes(attributes: ProductAttributeDTO[]): ProductAttributeDTO[] | AttributeRuleDTO[];

package/dist/types/hooks/useProductVariants/index.d.ts

@@ -0,0 +1,34 @@
+import React from 'react';
+import { VariantType, BooleanKVP, VariantMap, AttributeRulesMap, CombinationsMap } from './types';
+export * from './types';
+export declare const useProductVariants: ({ product, defaultVariantId, isLineItem, }: {
+    product: any;
+    defaultVariantId: any;
+    isLineItem?: boolean | undefined;
+}) => {
+    combinations: CombinationsMap;
+    attributeRules: AttributeRulesMap;
+    variants: VariantMap;
+    selectedVariant: VariantType | null;
+    setSelectedVariant: React.Dispatch<React.SetStateAction<VariantType | null>>;
+    customFields: BooleanKVP;
+    getVariantByAttribute: (key: string) => VariantType;
+    getVariantById: (id: string) => VariantType;
+    getCombinationsAndAttributeRules: () => {
+        combinations: CombinationsMap;
+        attributeRules: AttributeRulesMap;
+    };
+    getCombinationsForAttributeRule: (key: string, id: string) => {
+        label: string;
+        extra: any;
+        combinations: {
+            [id: string]: string;
+        };
+    };
+    getVariantByCombination: (key: string, value: string) => VariantType;
+    getCustomFieldValue: (field: string) => boolean | undefined;
+    selectVariantByAttribute: (key: string) => void;
+    selectVariantByCombination: (key: string, value: string) => void;
+    selectVariantOptions: (definitionKey: string, optionKey: string) => void;
+    selectVariantById: (id: string) => void;
+};

package/dist/types/hooks/useProductVariants/types.d.ts

@@ -0,0 +1,79 @@
+import type { ProductVariantDTO, ProductAttributeDraftDTO, SelectedOptionDTO, AttributeRuleDTO, LangValue } from '@sentecacommerce/sdk';
+import { SelectedOptionType } from '../useProduct/utils';
+export interface VariantType extends Omit<ProductVariantDTO, 'attributes' | 'availableOptions' | 'selectedOptions' | 'labels'> {
+    name?: LangValue[];
+    slug?: LangValue[];
+    attributes: ProductAttributeDraftDTO[];
+    options?: OptionsType[];
+    selectedOptions: SelectedOptionDTO[];
+    mappedSelectedOptions?: SelectedOptionType[];
+    isAvailable: boolean;
+    quantity?: number;
+    inventory: {
+        hasAvailableQuantity?: boolean;
+        availableQuantity?: number;
+    };
+    labels?: string[];
+    getAttribute: (rule: string) => {
+        id: string;
+        label: string;
+        name: string;
+        extra: any;
+        combinations: {
+            [id: string]: string;
+        };
+    };
+    getAttributeByKey: (key: string) => undefined | any;
+    getAvailabilityByStore: () => InventoryAvailabilityType[] | undefined;
+    variantAttributes?: any[];
+}
+export interface OptionsType {
+    definitionKey: string;
+    label: string;
+    elements?: SubOptionType[];
+}
+export interface SubOptionType {
+    optionKey: string;
+    label: string;
+    imageIndex?: number;
+}
+export interface ContentType {
+    key: string;
+    name?: string;
+    content?: string;
+}
+export interface AttributeRulesType extends AttributeRuleDTO {
+    label: string;
+    values: {
+        [id: string]: {
+            label: string;
+            extra: any;
+            combinations: {
+                [id: string]: string;
+            };
+        };
+    };
+}
+export interface VariantMap {
+    [productId: string]: VariantType;
+}
+export interface BooleanKVP {
+    [sku: string]: boolean | undefined;
+}
+export interface AttributeRulesMap {
+    [name: string]: AttributeRulesType;
+}
+export interface CombinationsMap {
+    [id: string]: {
+        value: string;
+        params: {
+            [id: string]: string;
+        };
+    };
+}
+export interface InventoryAvailabilityType {
+    storeName: string;
+    availableQuantity: number;
+    acceptsBackorders: boolean;
+    restockableInDays: number;
+}

package/dist/types/hooks/useVouchers/index.d.ts

@@ -9,5 +9,5 @@ declare type DiscountCode = {
     endDate: string;
     isUsed: boolean;
 };
-declare const useVouchers: (data?: DiscountCodeFilterResultDTO | undefined) => DiscountCode[];
-export { useVouchers };
+export declare const useVouchers: (data?: DiscountCodeFilterResultDTO | undefined) => DiscountCode[];
+export {};

package/dist/types/hooks/useZoom/index.d.ts

@@ -12,7 +12,7 @@ declare type ZoomProps = {
     isDesktopZoomed: boolean;
     imageRefs: React.MutableRefObject<HTMLDivElement[]>;
 };
-declare const useZoom: ({ carousel }: {
+export declare const useZoom: ({ carousel }: {
     carousel?: CarouselType | undefined;
 }) => {
     isZoomed: boolean;
@@ -29,4 +29,4 @@ declare const useZoom: ({ carousel }: {
     };
 };
 export declare const ZoomImageWrapper: (props: ZoomProps) => JSX.Element;
-export { useZoom };
+export {};

package/dist/types/hooks/wishlist-hooks/useWishlist/index.d.ts

@@ -1,4 +1,4 @@
-declare const useWishlist: ({ productId, variantId, collapseKey, onAddCallback, onRemoveCallback, }: {
+export declare const useWishlist: ({ productId, variantId, collapseKey, onAddCallback, onRemoveCallback, }: {
     productId: string;
     variantId?: string | undefined;
     collapseKey?: string | undefined;
@@ -9,4 +9,3 @@ declare const useWishlist: ({ productId, variantId, collapseKey, onAddCallback,
     removeFromWishlist: () => void;
     isInWishlist: boolean | undefined;
 };
-export { useWishlist };

package/dist/types/index.d.ts

@@ -1,4 +1,3 @@
-export * from './dto';
 export * from './api/productsApi';
 export * from './api/pagesApi';
 export * from './api/usersApi';
@@ -86,6 +85,7 @@ export * from './hooks/useRouterRedirect';
 export * from './hooks/useProgressBar';
 export * from './hooks/useCatalogDiscounts';
 export * from './hooks/useLocalRating';
+export * from './hooks/useProductVariants/types';
 export * from './utils';
 export * from './types';
 export * from './seo';
@@ -105,6 +105,7 @@ export * from './brands';
 export * from './navigation';
 export * from './GDPR';
 export * from './user';
+export * from './basket';
 export * from './ui';
 export * from './wishlist';
 export * from './build';

package/dist/types/listing/api/queries/useAggregateQuery.d.ts

@@ -1,21 +1,23 @@
 import { RangeAggregationResult, TermAggregationResult, RangeAggregation, TermAggregation, StatAggregation } from '@sentecacommerce/sdk';
 import { NextRouter } from 'next/router';
 import { PredicateType } from './usePredicate';
-import { Aggregate } from '../../types';
+import { Aggregate, AggregateSortEnum } from '../../types';
+import { ListingPageMeta } from '../..';
 export declare type AggregationResultType = RangeAggregationResult & TermAggregationResult & RangeAggregationResult;
 export declare type AggregateType = TermAggregation & StatAggregation & RangeAggregation;
 export declare enum AggregateRequestEnum {
     Filters = "filters",
     Categories = "categories"
 }
-export declare const useAggregateQuery: (aggregates: Aggregate[], request: AggregateRequestEnum) => import("react-query").QueryResult<import("@sentecacommerce/sdk").CatalogAggregateResponseDTO | undefined, unknown>;
-export declare function prepareAggregateQuery({ request, predicate, aggregates, router, postFilter, slug, config, }: {
+export declare const useAggregateQuery: (aggregates: Aggregate[], request: AggregateRequestEnum, sort?: AggregateSortEnum | undefined) => import("react-query").QueryResult<import("@sentecacommerce/sdk").CatalogAggregateResponseDTO | undefined, unknown>;
+export declare function prepareAggregateQuery({ request, predicate, aggregates, router, postFilter, slug, config, attributeSortType, }: {
     request: AggregateRequestEnum;
     aggregates: Aggregate[];
     router: NextRouter;
     postFilter: string | undefined;
     predicate?: PredicateType;
-    config?: any;
+    config?: ListingPageMeta;
     slug: string;
+    attributeSortType?: AggregateSortEnum;
 }): any;
 export declare function generateAggregateKey(aggregates?: Aggregate[]): string | undefined;

package/dist/types/listing/api/queries/useListingQuery.d.ts

@@ -2,15 +2,18 @@ import { CatalogFilterResultDTO } from '@sentecacommerce/sdk';
 import { QueryResult } from 'react-query';
 import { NextRouter } from 'next/router';
 import { PredicateType } from '..';
+import { ListingPageMeta } from '../..';
+import { StringField } from '@sentecacommerce-theme/cms';
 export declare const useListingQuery: () => QueryResult<CatalogFilterResultDTO, unknown>;
-export declare function processListingQuery({ predicate, router, limit, sort, postFilter, offset, config, slug, }: {
+export declare function processListingQuery({ predicate, router, limit, sort, postFilter, offset, config, slug, includeVariants, }: {
     predicate?: PredicateType;
     router: NextRouter;
     limit: number;
     offset: number;
     sort?: string;
     postFilter?: string;
-    config?: any;
+    config?: ListingPageMeta;
     slug?: string;
+    includeVariants?: boolean;
 }): Promise<CatalogFilterResultDTO>;
-export declare function isListingQueryEnabled(type: string, predicate?: PredicateType): boolean;
+export declare function isListingQueryEnabled(type: StringField, predicate?: PredicateType): boolean;

package/dist/types/listing/api/queries/usePredicate.d.ts

@@ -1,8 +1,9 @@
 import { CategoryDTO, ViewDTO, BrandDTO } from '@sentecacommerce/sdk';
 import { QueryResult } from 'react-query';
 import { NextRouter } from 'next/router';
+import { ListingPageMeta } from '../..';
 export declare type PredicateType = CategoryDTO & ViewDTO & BrandDTO & {
     breadcrumb?: any;
 };
 export declare const usePredicate: () => QueryResult<PredicateType | undefined, unknown>;
-export declare function processPredicateRequest(slug: string, router: NextRouter, aliasedSlug: string, mainConfig?: any): Promise<any>;
+export declare function processPredicateRequest(slug: string, router: NextRouter, aliasedSlug: string, mainConfig?: ListingPageMeta): Promise<any>;

package/dist/types/listing/components/BasicListingSEO.d.ts

@@ -3,6 +3,8 @@ export declare type BasicListingSEOProps = {
     favorDescriptionTemplateOverMeta?: boolean;
     titleTemplate?: string;
     descriptionTemplate?: string;
+    pageTemplate?: string;
+    currentPageTemplate?: string;
 };
 /**
  * Template Options:
@@ -10,4 +12,4 @@ export declare type BasicListingSEOProps = {
  * :description: -> is going to be replace with the description
  * :name: -> is going to be replace with the name
  */
-export declare const BasicListingSEO: ({ favorTitleTemplateOverMeta, favorDescriptionTemplateOverMeta, titleTemplate, descriptionTemplate, }: BasicListingSEOProps) => JSX.Element;
+export declare const BasicListingSEO: ({ favorTitleTemplateOverMeta, favorDescriptionTemplateOverMeta, titleTemplate, descriptionTemplate, pageTemplate, }: BasicListingSEOProps) => JSX.Element;

package/dist/types/listing/hooks/useListingAlias.d.ts

@@ -1,3 +1,4 @@
-export declare const useListingAlias: () => {
+import { ListingPageMeta } from '..';
+export declare const useListingAlias: (meta: ListingPageMeta) => {
     slug: string;
 };

package/dist/types/listing/hooks/useListingFilters.d.ts

@@ -1,7 +1,6 @@
 import React from 'react';
 import { AggregationResultType } from '../api';
 import { RangeAggregation, StatAggregation, TermAggregation } from '@sentecacommerce/sdk';
-export type { RangeAggregation, StatAggregation, TermAggregation, } from '@sentecacommerce/sdk';
 export declare type ListingAggregationResultType = {
     selected: boolean;
     data: AggregationResultType;

package/dist/types/listing/hooks/useListingItems.d.ts

@@ -1,11 +1,12 @@
 import { SearchResultDTO } from '@sentecacommerce/sdk';
+import type { NumberField, StringField } from '@sentecacommerce-theme/cms';
 export declare type SearchResultItem = {
     isPlaceholder?: boolean;
 } & SearchResultDTO;
 export declare type UseListingItemsProps = {
     items?: SearchResultItem[];
-    total?: number;
-    didYouMean?: string;
+    total?: NumberField;
+    didYouMean?: StringField;
     isLoading: boolean;
     isFetching: boolean;
 };

package/dist/types/listing/hooks/useListingMeta.d.ts

@@ -1,4 +1,6 @@
 import { AssetType } from '../../utils/assetsToMap';
+import { NextRouter } from 'next/router';
+import { Node } from './useListingCategories';
 export declare type UseListingMetaResult = {
     displayName: string;
     description: string;
@@ -10,3 +12,5 @@ export declare type UseListingMetaResult = {
     getCustomFieldByKey: (key: string) => any | undefined;
 };
 export declare const useListingMeta: () => UseListingMetaResult;
+export declare function getFilterByType(filterType: string, router?: NextRouter): string;
+export declare function getCategoryName(router?: NextRouter, categories?: Node[] | null): string | undefined;

package/dist/types/listing/hooks/useListingSEOCategories.d.ts

@@ -1,9 +1,11 @@
+import type { EnumField, StringField } from '@sentecacommerce-theme/cms';
+import { ComponentTypeEnum } from '..';
 export declare type SeoFilter = {
-    name?: string;
-    component?: string;
+    name?: StringField;
+    component?: EnumField<ComponentTypeEnum>;
     items?: {
-        name: string;
-        url: string;
+        name: StringField;
+        url: StringField;
     }[];
 };
 export declare type UseListingSEOCategoriesPropsResult = {

package/dist/types/listing/hooks/useSlideFilter.d.ts

@@ -3,6 +3,10 @@ export declare const useSlideFilter: (filterName: string, min: number, max: numb
         from: number;
         to: number;
     };
+    applyFilter: (data: {
+        from: number;
+        to: number;
+    }) => void;
     updateValue: (data: {
         from: number;
         to: number;

package/dist/types/listing/hooks/useSort.d.ts

@@ -1,9 +1,10 @@
+import { StringField } from '@sentecacommerce-theme/cms';
 declare type Props = {
-    sorts: {
-        key: string;
-        label: string;
+    sorts?: {
+        key: StringField;
+        label: StringField;
     }[];
-    defaultSortKey: string;
+    defaultSortKey?: StringField;
     onSelect?: () => void;
 };
 declare type SortOptionType = {
@@ -17,5 +18,5 @@ export declare type UseSortResults = {
     selectedSort: SortOptionType;
     resetSort: () => void;
 };
-export declare const useSort: ({ onSelect, sorts, defaultSortKey, }: Props) => UseSortResults;
+export declare const useSort: (props?: Props | undefined) => UseSortResults;
 export {};

package/dist/types/listing/hooks/utils.d.ts

@@ -2,9 +2,10 @@ import { AggregationResultType } from '../api';
 import { CatalogAggregateResponseDTO } from '@sentecacommerce/sdk';
 import { Aggregate } from '../types';
 import { NextRouter } from 'next/router';
-export declare function processCategoriesResponse(response?: CatalogAggregateResponseDTO, type?: string, term?: string): AggregationResultType[];
+import type { StringField } from '@sentecacommerce-theme/cms';
+export declare function processCategoriesResponse(response?: CatalogAggregateResponseDTO, type?: StringField, term?: StringField): AggregationResultType[];
 export declare function getAggregateTypeAndTerm(aggregates?: Aggregate): {
     type: string;
-    term: string | undefined;
+    term: import("@sentecacommerce-theme/cms").EnumField<StringField>;
 };
 export declare function getAttributePageType(router: NextRouter, slug: string): string[];

package/dist/types/listing/ssr/prefetchCategories.d.ts

@@ -1,5 +1,5 @@
 import { NextRouter } from 'next/router';
 import type { QueryCache } from 'react-query';
-import { Aggregate } from '../types';
+import { Aggregate, ListingPageMeta } from '../types';
 import { PredicateType } from '../api';
-export declare function prefetchCategories(queryCache: QueryCache, router: NextRouter, predicate: PredicateType, aggregates: Aggregate[], config?: any): Promise<import("@sentecacommerce/sdk").CatalogAggregateResponseDTO>;
+export declare function prefetchCategories(queryCache: QueryCache, router: NextRouter, predicate: PredicateType, aggregates: Aggregate[], config: ListingPageMeta): Promise<import("@sentecacommerce/sdk").CatalogAggregateResponseDTO>;

package/dist/types/listing/ssr/prefetchListing.d.ts

@@ -1,12 +1,11 @@
 import { NextRouter } from 'next/router';
 import type { QueryCache } from 'react-query';
 import { PredicateType } from '../api';
-export declare function prefetchListing({ queryCache, router, predicate, config, }: {
+import { ListingPageMeta } from '..';
+export declare function prefetchListing({ queryCache, router, predicate, config, defaultSortKey, }: {
     queryCache: QueryCache;
     router: NextRouter;
     predicate?: PredicateType;
-    filterExtension?: string;
-    defaultLimit?: number;
-    defaultSortKey?: string;
-    config?: any;
+    defaultSortKey: string;
+    config: ListingPageMeta;
 }): Promise<import("@sentecacommerce/sdk").CatalogFilterResultDTO>;

package/dist/types/listing/ssr/prefetchPredicate.d.ts

@@ -1,3 +1,4 @@
 import { NextRouter } from 'next/router';
 import type { QueryCache } from 'react-query';
-export declare function prefetchPredicate(queryCache: QueryCache, router: NextRouter, config: any): Promise<any>;
+import { ListingPageMeta } from '..';
+export declare function prefetchPredicate(queryCache: QueryCache, router: NextRouter, config: ListingPageMeta): Promise<any>;

package/dist/types/listing/types.d.ts

@@ -1,4 +1,4 @@
-import { BooleanField, TextField, NumberField } from '@sentecacommerce-theme/base';
+import { BooleanField, StringField, NumberField, EnumField, ListField, GroupField } from '@sentecacommerce-theme/cms';
 export declare type FiltersQuery = {
     storeKey?: string;
     currencyCode?: string;
@@ -16,6 +16,10 @@ export declare type FiltersQuery = {
     offset?: number;
     sort?: string;
 };
+export declare enum AggregateSortEnum {
+    Index = "index",
+    Alphabetically = "alphabetically"
+}
 export declare enum ListingTypesEnum {
     Category = "category",
     Brand = "brand",
@@ -46,25 +50,49 @@ export declare enum ComponentTypeEnum {
     RangeSlider = "range-slider"
 }
 export declare type Aggregate = {
-    label: TextField;
-    aggregationType: AggregationTypeEnum;
-    aggregationDefinition: TextField;
-    filterDefinition: TextField;
-    order: NumberField;
-    collapsed?: BooleanField;
-    component: ComponentTypeEnum;
+    label: StringField;
+    aggregationType: EnumField<AggregationTypeEnum>;
+    aggregationDefinition: EnumField<StringField>;
+    filterDefinition: StringField;
+    order?: NumberField;
+    collapsed: BooleanField;
+    hideOn?: ListField<ListingTypesEnum>;
+    component: EnumField<ComponentTypeEnum>;
 };
 export declare type ListingPageSortOption = {
-    key: TextField;
-    label: TextField;
+    key: StringField;
+    label: StringField;
 };
 export interface DefaultListingPageProps {
     type: ListingTypesEnum;
-    seoAggregates?: Aggregate;
-    aggregates?: Aggregate[];
-    defaultSortKey: TextField;
+    seoAggregates?: GroupField<Aggregate>;
+    aggregates?: ListField<Aggregate>;
+    defaultSortKey?: StringField;
     categoryTreeConfig?: Aggregate;
-    sortOptions: ListingPageSortOption[];
-    productsPerPage?: NumberField;
-    filterExtension?: TextField;
+    sortOptions?: ListField<ListingPageSortOption>;
+    attributeSortType?: AggregateSortEnum;
+    includeVariants?: boolean;
+    meta: ListingPageMeta;
+}
+export interface ListingPageMeta {
+    slugAliases: {
+        [key: string]: string;
+    };
+    titleAliases: {
+        [key: string]: string;
+    };
+    filterExtension?: StringField;
+    collapseMode?: StringField;
+    limit: NumberField;
+    includeVariants?: BooleanField;
+    getTitle?: GetListingPageTitle;
 }
+export declare type GetListingPageTitle = (type: ListingTypesEnum, meta: Omit<ListingPageMeta, 'getTitle'>, data: {
+    brand?: string;
+    category?: string;
+    defaultName?: string;
+    attribute?: string;
+    search?: string;
+    isWithAttribute: boolean;
+    childAttribute?: string;
+}) => string;

package/dist/types/listing/utils/buildCategoryQuery.d.ts

@@ -1,5 +1,6 @@
 import { NextRouter } from 'next/router';
 import { ListingTypesEnum, Aggregate, PredicateType } from '../index';
+import { ListingPageMeta } from '../types';
 export declare const buildCategoryQuery: ({ aggregates, predicate, postFilter, pageType, config, router, slug, }: {
     pageType: ListingTypesEnum;
     aggregates: Aggregate[];
@@ -7,7 +8,7 @@ export declare const buildCategoryQuery: ({ aggregates, predicate, postFilter, p
     postFilter?: string | undefined;
     predicate?: PredicateType | undefined;
     slug: string;
-    config?: any;
+    config?: ListingPageMeta | undefined;
 }) => {
     [x: string]: string;
     filter: string;