@relewise/web-components/dist/index.d.ts

Relewise is a next generation personalization SaaS-platform, which offers functionality within product- and content recommendations and personalized search. Our official Web Components provide simple and easy components for rendering personalized experien

import { BooleanAvailableFacetValue } from '@relewise/client';
import { BrandFacet } from '@relewise/client';
import { BrandFacetResult } from '@relewise/client';
import { BrandNameAndIdResultAvailableFacetValue } from '@relewise/client';
import { CategoryFacet } from '@relewise/client';
import { CategoryFacetResult } from '@relewise/client';
import { CategoryHierarchyFacet } from '@relewise/client';
import { CategoryHierarchyFacetResult } from '@relewise/client';
import { CategoryNameAndIdResultAvailableFacetValue } from '@relewise/client';
import { ContentAssortmentFacet } from '@relewise/client';
import { ContentAssortmentFacetResult } from '@relewise/client';
import { ContentDataBooleanValueFacet } from '@relewise/client';
import { ContentDataBooleanValueFacetResult } from '@relewise/client';
import { ContentDataDoubleRangeFacet } from '@relewise/client';
import { ContentDataDoubleRangeFacetResult } from '@relewise/client';
import { ContentDataDoubleRangesFacet } from '@relewise/client';
import { ContentDataDoubleRangesFacetResult } from '@relewise/client';
import { ContentDataDoubleValueFacet } from '@relewise/client';
import { ContentDataDoubleValueFacetResult } from '@relewise/client';
import { ContentDataIntegerValueFacet } from '@relewise/client';
import { ContentDataIntegerValueFacetResult } from '@relewise/client';
import { ContentDataObjectFacet } from '@relewise/client';
import { ContentDataObjectFacetResult } from '@relewise/client';
import { ContentDataStringValueFacet } from '@relewise/client';
import { ContentDataStringValueFacetResult } from '@relewise/client';
import { ContentRecommendationRequest } from '@relewise/client';
import { ContentRecommendationResponse } from '@relewise/client';
import { ContentResult } from '@relewise/client';
import { ContentsViewedAfterViewingContentRequest } from '@relewise/client';
import { ContentsViewedAfterViewingMultipleContentsRequest } from '@relewise/client';
import { ContentsViewedAfterViewingMultipleProductsRequest } from '@relewise/client';
import { ContentsViewedAfterViewingProductRequest } from '@relewise/client';
import { CSSResult } from 'lit';
import { DataObjectBooleanValueFacet } from '@relewise/client';
import { DataObjectBooleanValueFacetResult } from '@relewise/client';
import { DataObjectDoubleRangeFacet } from '@relewise/client';
import { DataObjectDoubleRangeFacetResult } from '@relewise/client';
import { DataObjectDoubleRangesFacet } from '@relewise/client';
import { DataObjectDoubleRangesFacetResult } from '@relewise/client';
import { DataObjectDoubleValueFacet } from '@relewise/client';
import { DataObjectDoubleValueFacetResult } from '@relewise/client';
import { DataObjectFacet } from '@relewise/client';
import { DataObjectFacetResult } from '@relewise/client';
import { DataObjectStringValueFacet } from '@relewise/client';
import { DataObjectStringValueFacetResult } from '@relewise/client';
import { DecimalNullableChainableRangeAvailableFacetValue } from '@relewise/client';
import { FacetBuilder } from '@relewise/client';
import { FilterBuilder } from '@relewise/client';
import { Int32AvailableFacetValue } from '@relewise/client';
import { LitElement } from 'lit';
import { nothing } from 'lit';
import { PopularContentsRequest } from '@relewise/client';
import { PopularProductsRequest } from '@relewise/client';
import { PriceRangeFacet } from '@relewise/client';
import { PriceRangeFacetResult } from '@relewise/client';
import { PriceRangesFacet } from '@relewise/client';
import { PriceRangesFacetResult } from '@relewise/client';
import { ProductAssortmentFacet } from '@relewise/client';
import { ProductAssortmentFacetResult } from '@relewise/client';
import { ProductCategoryAssortmentFacet } from '@relewise/client';
import { ProductCategoryAssortmentFacetResult } from '@relewise/client';
import { ProductCategoryDataBooleanValueFacet } from '@relewise/client';
import { ProductCategoryDataBooleanValueFacetResult } from '@relewise/client';
import { ProductCategoryDataDoubleRangeFacet } from '@relewise/client';
import { ProductCategoryDataDoubleRangeFacetResult } from '@relewise/client';
import { ProductCategoryDataDoubleRangesFacet } from '@relewise/client';
import { ProductCategoryDataDoubleRangesFacetResult } from '@relewise/client';
import { ProductCategoryDataDoubleValueFacet } from '@relewise/client';
import { ProductCategoryDataDoubleValueFacetResult } from '@relewise/client';
import { ProductCategoryDataObjectFacet } from '@relewise/client';
import { ProductCategoryDataObjectFacetResult } from '@relewise/client';
import { ProductCategoryDataStringValueFacet } from '@relewise/client';
import { ProductCategoryDataStringValueFacetResult } from '@relewise/client';
import { ProductCategoryResult } from '@relewise/client';
import { ProductCategorySearchBuilder } from '@relewise/client';
import { ProductDataBooleanValueFacet } from '@relewise/client';
import { ProductDataBooleanValueFacetResult } from '@relewise/client';
import { ProductDataDoubleRangeFacet } from '@relewise/client';
import { ProductDataDoubleRangeFacetResult } from '@relewise/client';
import { ProductDataDoubleRangesFacet } from '@relewise/client';
import { ProductDataDoubleRangesFacetResult } from '@relewise/client';
import { ProductDataDoubleValueFacet } from '@relewise/client';
import { ProductDataDoubleValueFacetResult } from '@relewise/client';
import { ProductDataIntegerValueFacet } from '@relewise/client';
import { ProductDataIntegerValueFacetResult } from '@relewise/client';
import { ProductDataObjectFacet } from '@relewise/client';
import { ProductDataObjectFacetResult } from '@relewise/client';
import { ProductDataStringValueFacet } from '@relewise/client';
import { ProductDataStringValueFacetResult } from '@relewise/client';
import { ProductFacetResult } from '@relewise/client';
import { ProductRecommendationRequest } from '@relewise/client';
import { ProductRecommendationResponse } from '@relewise/client';
import { ProductResult } from '@relewise/client';
import { ProductSearchBuilder } from '@relewise/client';
import { ProductSearchResponse } from '@relewise/client';
import { ProductSettingsRecommendationBuilder } from '@relewise/client';
import { ProductsViewedAfterViewingContentRequest } from '@relewise/client';
import { ProductsViewedAfterViewingProductRequest } from '@relewise/client';
import { PropertyValues } from 'lit';
import { PurchasedWithMultipleProductsRequest } from '@relewise/client';
import { PurchasedWithProductRequest } from '@relewise/client';
import { RecentlyPurchasedFacet } from '@relewise/client';
import { RecommendationRequestBuilder } from '@relewise/client';
import { Recommender } from '@relewise/client';
import { RedirectResult } from '@relewise/client';
import { RelevanceModifierBuilder } from '@relewise/client';
import { RelewiseClientOptions } from '@relewise/client';
import { Searcher } from '@relewise/client';
import { SearchTermPredictionResult } from '@relewise/client';
import { SelectedCategoryPropertiesSettings } from '@relewise/client';
import { SelectedContentPropertiesSettings } from '@relewise/client';
import { SelectedProductCategoryPropertiesSettings } from '@relewise/client';
import { SelectedProductPropertiesSettings } from '@relewise/client';
import { SelectedVariantPropertiesSettings } from '@relewise/client';
import { Settings } from '@relewise/client';
import { StringAvailableFacetValue } from '@relewise/client';
import { TargetedRecommendationConfigurations as TargetedRecommendationConfigurations_2 } from 'src/targetedRecommendationConfigurations';
import { TemplateResult } from 'lit-html';
import { TemplateResult as TemplateResult_2 } from 'lit';
import { Tracker } from '@relewise/client';
import { unsafeHTML } from 'lit-html/directives/unsafe-html.js';
import { User } from '@relewise/client';
import { VariantSpecificationFacet } from '@relewise/client';
import { VariantSpecificationFacetResult } from '@relewise/client';

export declare function addFilters(filters: Partial<Filters>): void;

export declare class App {
    useRecommendations(): App;
    useBehavioralTracking(): App;
    updateContextSettings(contextSettings: Partial<ContextSettings>): App;
    useSearch(options?: RelewiseUISearchOptions): App;
    registerSearchTarget(target: string, configuration: TargetedSearchConfiguration): App;
    registerRecommendationTarget(target: string, configuration: TargetedRecommendationConfiguration): App;
}

export declare type BatchingContextValue = {
    requests: {
        request: ProductRecommendationRequest;
        id: EventTarget | null;
        result?: ProductRecommendationResponse | null;
    }[];
};

export declare class BrandView extends LitElement {
    brandId: string | null;
    connectedCallback(): Promise<void>;
}

export declare class Button extends LitElement {
    buttonText: string | null;
    handleClick: () => void;
    connectedCallback(): void;
    render(): TemplateResult<1>;
    static styles: CSSResult[];
}

export declare class ChecklistBooleanValueFacet extends ChecklistFacetBase {
    result: ProductDataBooleanValueFacetResult | null;
    handleChange(e: Event, item: BooleanAvailableFacetValue): void;
    getOptionDisplayValue(item: BooleanAvailableFacetValue): string;
    shouldOptionBeChecked(item: BooleanAvailableFacetValue): boolean;
}

export declare type CheckListFacet = BrandFacetResult | CategoryFacetResult | ProductDataStringValueFacetResult | ProductDataBooleanValueFacetResult | ProductAssortmentFacetResult | PriceRangesFacetResult | ProductDataDoubleRangesFacetResult | ProductDataDoubleValueFacetResult;

export declare abstract class ChecklistFacetBase extends LitElement {
    abstract handleChange(e: Event, item: CheckListFacetValue): void;
    abstract getOptionDisplayValue(item: CheckListFacetValue): string;
    abstract shouldOptionBeChecked(item: CheckListFacetValue): boolean;
    result: CheckListFacet | null;
    label: string;
    selectedValues: string[];
    showAll: boolean;
    clearSelectedValuesBound: () => void;
    connectedCallback(): void;
    disconnectedCallback(): void;
    clearSelectedValues(): void;
    updateUrlState(searchForProducts?: boolean): void;
    render(): TemplateResult<1> | typeof nothing | undefined;
    static styles: CSSResult[];
}

export declare type CheckListFacetValue = BrandNameAndIdResultAvailableFacetValue | StringAvailableFacetValue | BooleanAvailableFacetValue | Int32AvailableFacetValue | DecimalNullableChainableRangeAvailableFacetValue;

export declare class ChecklistNumberValueFacet extends ChecklistFacetBase {
    result: ProductAssortmentFacetResult | ProductDataDoubleValueFacetResult | null;
    handleChange(e: Event, item: Int32AvailableFacetValue): void;
    getOptionDisplayValue(item: Int32AvailableFacetValue): string;
    shouldOptionBeChecked(item: BrandNameAndIdResultAvailableFacetValue | StringAvailableFacetValue | BooleanAvailableFacetValue | Int32AvailableFacetValue): boolean;
}

export declare class ChecklistObjectValueFacet extends ChecklistFacetBase {
    result: BrandFacetResult | CategoryFacetResult | null;
    handleChange(e: Event, item: BrandNameAndIdResultAvailableFacetValue | CategoryNameAndIdResultAvailableFacetValue): void;
    getOptionDisplayValue(item: BrandNameAndIdResultAvailableFacetValue | CategoryNameAndIdResultAvailableFacetValue): string;
    shouldOptionBeChecked(item: BrandNameAndIdResultAvailableFacetValue | CategoryNameAndIdResultAvailableFacetValue): boolean;
}

export declare class ChecklistRangesObjectValueFacet extends ChecklistFacetBase {
    result: PriceRangesFacetResult | ProductDataDoubleRangesFacetResult | null;
    handleChange(e: Event, item: DecimalNullableChainableRangeAvailableFacetValue): void;
    getOptionDisplayValue(item: DecimalNullableChainableRangeAvailableFacetValue): string;
    shouldOptionBeChecked(item: DecimalNullableChainableRangeAvailableFacetValue): boolean;
}

export declare class ChecklistStringValueFacet extends ChecklistFacetBase {
    result: ProductDataStringValueFacetResult | null;
    handleChange(e: Event, item: StringAvailableFacetValue): void;
    getOptionDisplayValue(item: StringAvailableFacetValue): string;
    shouldOptionBeChecked(item: StringAvailableFacetValue): boolean;
}

export declare function clearUrlState(): void;

export declare type CommonTemplateHelpers = TemplateHelpers & {
    unsafeHTML: typeof unsafeHTML;
    nothing: typeof nothing;
    user: User | null;
};

export declare class ContentCategoryView extends LitElement {
    idPath: string | null;
    connectedCallback(): Promise<void>;
}

export declare abstract class ContentRecommendationBase extends LitElement {
    target: string | null;
    numberOfRecommendations: number;
    displayedAtLocation?: string;
    content: ContentResult[] | null;
    private user;
    abstract fetchContent(): Promise<ContentRecommendationResponse | undefined> | undefined;
    abstract buildRequest(): Promise<ContentRecommendationRequest | undefined>;
    fetchAndUpdateContentBound: () => Promise<void>;
    connectedCallback(): Promise<void>;
    disconnectedCallback(): void;
    fetchAndUpdateContent(): Promise<void>;
    render(): TemplateResult<1> | undefined;
    static styles: CSSResult;
}

export declare class ContentSentimentButtons extends LitElement {
    user: User | null;
    content: ContentResult | null;
    private sentiment;
    private isWorking;
    private handleUserEngagementChanged;
    connectedCallback(): void;
    disconnectedCallback(): void;
    protected willUpdate(changed: PropertyValues<this>): void;
    render(): TemplateResult<1> | typeof nothing;
    private onLikeClick;
    private onDislikeClick;
    private submitEngagement;
    private dispatchChangeEvent;
    static styles: CSSResult;
}

export declare interface ContentTemplateExtensions {
    html: (strings: TemplateStringsArray, ...values: unknown[]) => TemplateResult_2<1>;
    helpers: CommonTemplateHelpers;
}

export declare class ContentTile extends LitElement {
    content: ContentResult | null;
    private user;
    protected createRenderRoot(): HTMLElement | DocumentFragment;
    connectedCallback(): void;
    render(): TemplateResult<1> | undefined;
    renderTileContent(content: ContentResult): TemplateResult<1>;
    private getContentImageAlt;
    static defaultStyles: CSSResult[];
}

export declare class ContentView extends LitElement {
    contentId: string | null;
    connectedCallback(): Promise<void>;
}

export declare class ContentViewedAfterViewingContent extends ContentRecommendationBase {
    contentId: string | undefined;
    fetchContent(): Promise<ContentRecommendationResponse | undefined>;
    buildRequest(): Promise<ContentsViewedAfterViewingContentRequest | undefined>;
}

export declare class ContentViewedAfterViewingMultipleContent extends ContentRecommendationBase {
    private contentIds;
    connectedCallback(): Promise<void>;
    private parseContentIds;
    fetchContent(): Promise<ContentRecommendationResponse | undefined>;
    buildRequest(): Promise<ContentsViewedAfterViewingMultipleContentsRequest | undefined>;
}

export declare class ContentViewedAfterViewingMultipleProducts extends ContentRecommendationBase {
    private productAndVariantIds;
    connectedCallback(): Promise<void>;
    private parseProductAndVariantIds;
    fetchContent(): Promise<ContentRecommendationResponse | undefined>;
    buildRequest(): Promise<ContentsViewedAfterViewingMultipleProductsRequest | undefined>;
}

export declare class ContentViewedAfterViewingProduct extends ContentRecommendationBase {
    productId: string | undefined;
    variantId: string | undefined;
    fetchContent(): Promise<ContentRecommendationResponse | undefined>;
    buildRequest(): Promise<ContentsViewedAfterViewingProductRequest | undefined>;
}

declare const context_2: {
    __context__: BatchingContextValue;
};
export { context_2 as context }

export declare interface ContextSettings {
    getUser: () => Promise<User> | User;
    language: string;
    currency: string;
}

export declare function createProductCategorySearchBuilder(searchTerm: string | null | undefined, settings: Settings): ProductCategorySearchBuilder;

export declare function createProductSearchBuilder(searchTerm: string | null | undefined, settings: Settings): ProductSearchBuilder;

export declare const defaultExplodedVariants = 1;

export declare const defaultProductCategoryProperties: Partial<SelectedCategoryPropertiesSettings>;

export declare const Events: {
    contextSettingsUpdated: string;
    search: string;
    applyFacet: string;
    applySorting: string;
    loadMoreProducts: string;
    showLoadingSpinner: string;
    dimPreviousResult: string;
    searchingForProductsCompleted: string;
    registerProductRecommendation: string;
    userEngagementChanged: string;
};

export declare type Facet = ContentAssortmentFacet | ProductAssortmentFacet | ProductCategoryAssortmentFacet | BrandFacet | CategoryFacet | CategoryHierarchyFacet | ContentDataObjectFacet | ContentDataDoubleRangeFacet | ContentDataDoubleRangesFacet | ContentDataStringValueFacet | ContentDataBooleanValueFacet | ContentDataDoubleValueFacet | ContentDataIntegerValueFacet | DataObjectFacet | DataObjectDoubleRangeFacet | DataObjectDoubleRangesFacet | DataObjectStringValueFacet | DataObjectBooleanValueFacet | DataObjectDoubleValueFacet | PriceRangeFacet | PriceRangesFacet | ProductCategoryDataObjectFacet | ProductCategoryDataDoubleRangeFacet | ProductCategoryDataDoubleRangesFacet | ProductCategoryDataStringValueFacet | ProductCategoryDataBooleanValueFacet | ProductCategoryDataDoubleValueFacet | ProductDataObjectFacet | ProductDataDoubleRangeFacet | ProductDataDoubleRangesFacet | ProductDataStringValueFacet | ProductDataBooleanValueFacet | ProductDataDoubleValueFacet | ProductDataIntegerValueFacet | RecentlyPurchasedFacet | VariantSpecificationFacet;

export declare interface FacetLocalization {
    save?: string;
    showMore?: string;
    showLess?: string;
    filter?: string;
    yes?: string;
    no?: string;
}

export declare type FacetResult = ProductAssortmentFacetResult | ContentAssortmentFacetResult | ProductCategoryAssortmentFacetResult | BrandFacetResult | CategoryFacetResult | CategoryHierarchyFacetResult | ContentDataObjectFacetResult | ContentDataDoubleRangeFacetResult | ContentDataDoubleRangesFacetResult | ContentDataStringValueFacetResult | ContentDataBooleanValueFacetResult | ContentDataDoubleValueFacetResult | ContentDataIntegerValueFacetResult | DataObjectFacetResult | DataObjectDoubleRangeFacetResult | DataObjectDoubleRangesFacetResult | DataObjectStringValueFacetResult | DataObjectBooleanValueFacetResult | DataObjectDoubleValueFacetResult | PriceRangeFacetResult | PriceRangesFacetResult | ProductCategoryDataObjectFacetResult | ProductCategoryDataDoubleRangeFacetResult | ProductCategoryDataDoubleRangesFacetResult | ProductCategoryDataStringValueFacetResult | ProductCategoryDataBooleanValueFacetResult | ProductCategoryDataDoubleValueFacetResult | ProductDataObjectFacetResult | ProductDataDoubleRangeFacetResult | ProductDataDoubleRangesFacetResult | ProductDataStringValueFacetResult | ProductDataBooleanValueFacetResult | ProductDataDoubleValueFacetResult | ProductDataIntegerValueFacetResult | VariantSpecificationFacetResult;

export declare class Facets extends LitElement {
    facetResult: ProductFacetResult | null | undefined;
    labels: string[];
    showFacets: boolean;
    showDimmingOverlay: boolean;
    handleResizeEventBound: () => void;
    handleDimPreviousResultEventBound: () => void;
    handleSearchingForProductsCompletedEventBound: () => void;
    connectedCallback(): void;
    disconnectedCallback(): void;
    handleResizeEvent(): void;
    handleDimPreviousResultEvent(): void;
    handleSearchingForProductsCompletedEvent(): void;
    renderFacet(label: string, facetResult: FacetResult, styling: string, isLast: boolean): TemplateResult_2<1> | typeof nothing;
    render(): TemplateResult_2<1>;
    static styles: CSSResult[];
}

export declare class FavoriteButtonContent extends LitElement {
    user: User | null;
    content: ContentResult | null;
    private isWorking;
    private isFavorite;
    private handleUserEngagementChanged;
    connectedCallback(): void;
    disconnectedCallback(): void;
    protected willUpdate(changed: PropertyValues<this>): void;
    render(): TemplateResult<1> | typeof nothing;
    private onToggle;
    private dispatchChangeEvent;
    static styles: CSSResult;
}

export declare interface FavoriteButtonLocalization {
    addToFavorites?: string;
    removeFavorite?: string;
}

export declare class FavoriteButtonProducts extends LitElement {
    user: User | null;
    product: ProductResult | null;
    trackOnVariant: Boolean;
    private isWorking;
    private isFavorite;
    private handleUserEngagementChanged;
    connectedCallback(): void;
    disconnectedCallback(): void;
    protected willUpdate(changed: PropertyValues<this>): void;
    render(): TemplateResult<1> | typeof nothing;
    private onToggle;
    private dispatchChangeEvent;
    static styles: CSSResult;
}

export declare type FavoriteChangeDetail = {
    isFavorite: boolean;
    entityType?: 'Product' | 'Content';
    productId?: string;
    variantId?: string | null;
    contentId?: string;
};

export declare class FilterIcon extends LitElement {
    connectedCallback(): void;
    render(): TemplateResult<1>;
    static styles: CSSResult;
}

export declare interface Filters {
    product?: (builder: FilterBuilder) => void;
    productCategory?: (builder: FilterBuilder) => void;
    content?: (builder: FilterBuilder) => void;
}

export declare function getNumberOfProductsToFetch(): number | null;

export declare function getProductRecommendationBuilderWithDefaults<T extends ProductSettingsRecommendationBuilder>(createBuilder: (settings: Settings) => T, displayedAtLocation: string, target?: string | null): Promise<T>;

export declare function getRecommender(options: RelewiseUIOptions): Recommender;

export declare function getRelewiseContextSettings(displayedAtLocation: string): Promise<Settings>;

export declare function getRelewiseRecommendationTargetedConfigurations(): TargetedRecommendationConfigurations_2;

export declare function getRelewiseSearchTargetedConfigurations(): TargetedSearchConfigurations;

export declare function getRelewiseUIOptions(): RelewiseUIOptions;

export declare function getRelewiseUISearchOptions(): RelewiseUISearchOptions | undefined;

export declare function getSearcher(options: RelewiseUIOptions): Searcher;

export declare function getSelectedContentProperties(options: RelewiseUIOptions): Partial<SelectedContentPropertiesSettings>;

export declare function getSelectedProductProperties(options: RelewiseUIOptions): Partial<SelectedProductPropertiesSettings>;

export declare function getTracker(options: RelewiseUIOptions): Tracker;

export declare function idPathAsArray(idPath: string | null): string[] | null;

export declare function initializeRelewiseUI(options: RelewiseUIOptions): App;

export declare class LoadingSpinner extends LitElement {
    render(): TemplateResult<1>;
    static styles: CSSResult[];
}

export declare interface LoadMoreLocalization {
    loadMore?: string;
    showing?: string;
    outOf?: string;
    products?: string;
}

export declare class LoadMoreProducts extends LitElement {
    hits: number | null;
    productsLoaded: number | null;
    loading: boolean;
    handleShowLoadingSpinnerEventBound: () => void;
    handleSearchingForProductsCompletedEventBound: () => void;
    connectedCallback(): void;
    disconnectedCallback(): void;
    handleShowLoadingSpinnerEvent(): void;
    handleSearchingForProductsCompletedEvent(): void;
    render(): TemplateResult<1> | undefined;
    static styles: CSSResult[];
}

export declare class NumberRangeFacet extends LitElement {
    result: (ProductDataDoubleRangeFacetResult) | null;
    label: string;
    upperBound: number | null | undefined;
    lowerBound: number | null | undefined;
    connectedCallback(): void;
    handleLowerBoundChange(event: Event): void;
    handleUpperBoundChange(event: Event): void;
    save(): void;
    handleKeyEvent(event: KeyboardEvent): void;
    render(): TemplateResult<1> | undefined;
    static styles: CSSResult[];
}

export declare class PersonalContent extends ContentRecommendationBase {
    fetchContent(): Promise<ContentRecommendationResponse | undefined>;
    buildRequest(): Promise<ContentRecommendationRequest>;
}

export declare class PersonalProducts extends ProductRecommendationBase {
    fetchProducts(): Promise<ProductRecommendationResponse | undefined>;
    buildRequest(): Promise<ProductRecommendationRequest>;
}

export declare class PopularContent extends ContentRecommendationBase {
    sinceMinutesAgo: number;
    fetchContent(): Promise<ContentRecommendationResponse | undefined>;
    buildRequest(): Promise<PopularContentsRequest>;
}

export declare class PopularProducts extends ProductRecommendationBase {
    sinceMinutesAgo: number;
    basedOn: 'MostPurchased' | 'MostViewed';
    fetchProducts(): Promise<ProductRecommendationResponse | undefined>;
    buildRequest(): Promise<PopularProductsRequest>;
}

export declare class ProductCategoryView extends LitElement {
    idPath: string | null;
    connectedCallback(): Promise<void>;
}

export declare abstract class ProductRecommendationBase extends LitElement {
    target: string | null;
    numberOfRecommendations: number;
    displayedAtLocation?: string;
    providedData?: BatchingContextValue;
    products: ProductResult[] | null;
    private user;
    abstract fetchProducts(): Promise<ProductRecommendationResponse | undefined> | undefined;
    abstract buildRequest(): Promise<ProductRecommendationRequest | undefined>;
    fetchAndUpdateProductsBound: () => Promise<void>;
    constructor();
    connectedCallback(): Promise<void>;
    disconnectedCallback(): void;
    fetchAndUpdateProducts(): Promise<void>;
    render(): TemplateResult<1> | undefined;
    static styles: CSSResult;
}

export declare class ProductSearch extends LitElement {
    displayedAtLocation?: string;
    numberOfProducts: number;
    target: string | null;
    searchResult: ProductSearchResponse | null;
    products: ProductResult[];
    page: number;
    rememberScrollPosition: boolean | undefined;
    abortController: AbortController;
    facetLabels: string[];
    private user;
    handleSearchEventBound: () => void;
    handleLoadMoreEventBound: () => void;
    handleScrollEventBound: () => void;
    connectedCallback(): Promise<void>;
    disconnectedCallback(): void;
    handleSearchEvent(): void;
    handleLoadMoreEvent(): void;
    handleScrollEvent(): void;
    search(shouldClearOldResult: boolean): Promise<void>;
    getSelectedValuesForFacet(facet: Facet): void;
    getSelectedRange(facet: Facet): void;
    getSelectedRanges(facet: Facet): void;
    getSelectedStrings(facet: Facet): void;
    setSearchResultOnSlotChilderen(): void;
    setDataOnNodes(nodes: Node[]): void;
    updated(): Promise<void>;
    render(): TemplateResult<1>;
    static styles: CSSResult[];
}

export declare class ProductSearchBar extends LitElement {
    autofocus: boolean;
    term: string | null;
    private debounceTimeoutHandlerId;
    connectedCallback(): void;
    handleKeyDown(event: KeyboardEvent): void;
    debouncedSetSearchTerm(term: string): void;
    setSearchTerm(term: string): void;
    render(): TemplateResult<1>;
    static styles: CSSResult[];
}

export declare class ProductSearchOverlay extends LitElement {
    displayedAtLocation?: string;
    numberOfProducts: number;
    numberOfSearchTermPredictions: number;
    numberOfProductCategories: number;
    searchPageUrl?: string;
    autofocus: boolean;
    results: SearchResult[] | null;
    redirects?: RedirectResult[] | null;
    term: string;
    selectedIndex: number;
    searchBarInFocus: boolean;
    resultBoxIsHovered: boolean;
    hasCompletedSearchRequest: boolean;
    productSearchResultHits: number;
    user: User | null;
    private debounceTimeoutHandlerId;
    private abortController;
    connectedCallback(): Promise<void>;
    setSearchTerm(term: string): void;
    handleKeyDown(event: KeyboardEvent): void;
    redirectToSearchPage(): void;
    handleActionOnResult(result?: SearchResult): void;
    search(searchTerm: string): Promise<void>;
    render(): TemplateResult<1>;
    static styles: CSSResult[];
}

export declare class ProductSearchOverlayProduct extends LitElement {
    user: User | null;
    product: ProductResult | undefined | null;
    connectedCallback(): void;
    render(): TemplateResult<1> | undefined;
    renderTileContent(product: ProductResult): TemplateResult<1>;
    static styles: CSSResult[];
}

export declare class ProductSearchOverlayProductCategory extends LitElement {
    user: User | null;
    productCategory: ProductCategoryResult | undefined | null;
    connectedCallback(): void;
    render(): TemplateResult<1> | undefined;
    renderTileContent(productCategory: ProductCategoryResult): TemplateResult<1>;
    static styles: CSSResult[];
}

export declare class ProductSearchOverlayResults extends LitElement {
    setSearchTerm: (term: string) => void;
    redirectToSearchPage: () => void;
    hits: number;
    noResultsMessage: string | null;
    results: SearchResult[] | null;
    selectedIndex: number;
    setResultOverlayHovered: (hovered: boolean) => void;
    user: User | null;
    connectedCallback(): void;
    render(): TemplateResult<1>;
    static styles: CSSResult[];
}

export declare class ProductSearchResults extends LitElement {
    products: ProductResult[];
    private user;
    showLoadingSpinner: boolean;
    showDimmingOverlay: boolean;
    handleShowLoadingSpinnerEventBound: () => void;
    handleDimPreviousResultEventBound: () => void;
    handleSearchingForProductsCompletedEventBound: () => void;
    connectedCallback(): void;
    disconnectedCallback(): void;
    handleShowLoadingSpinnerEvent(): void;
    handleDimPreviousResultEvent(): void;
    handleSearchingForProductsCompletedEvent(): void;
    render(): TemplateResult<1> | undefined;
    static styles: CSSResult[];
}

export declare class ProductSearchSorting extends LitElement {
    selectedOption: string;
    readSortingFromUrlBound: () => void;
    connectedCallback(): void;
    disconnectedCallback(): void;
    readSortingFromUrl(): void;
    setSelectedValue(event: Event): void;
    getOptionText(sortingValue: string): string;
    render(): TemplateResult<1>;
    static styles: CSSResult[];
}

export declare class ProductSentimentButtons extends LitElement {
    user: User | null;
    product: ProductResult | null;
    trackOnVariant: Boolean;
    private sentiment;
    private isWorking;
    private handleUserEngagementChanged;
    connectedCallback(): void;
    disconnectedCallback(): void;
    protected willUpdate(changed: PropertyValues<this>): void;
    render(): TemplateResult<1> | typeof nothing;
    private onLikeClick;
    private onDislikeClick;
    private submitEngagement;
    private dispatchChangeEvent;
    static styles: CSSResult;
}

export declare class ProductsViewedAfterViewingContent extends ProductRecommendationBase {
    contentId: string | undefined;
    fetchProducts(): Promise<ProductRecommendationResponse | undefined>;
    buildRequest(): Promise<ProductsViewedAfterViewingContentRequest | undefined>;
}

export declare class ProductsViewedAfterViewingProduct extends ProductRecommendationBase {
    productId: string | undefined;
    variantId: string | undefined;
    fetchProducts(): Promise<ProductRecommendationResponse | undefined>;
    buildRequest(): Promise<ProductsViewedAfterViewingProductRequest | undefined>;
}

export declare interface ProductTemplateExtensions {
    html: (strings: TemplateStringsArray, ...values: unknown[]) => TemplateResult_2<1>;
    helpers: CommonTemplateHelpers & {
        formatPrice: (price: string | number | null | undefined) => string | number | null | undefined;
    };
}

export declare class ProductTile extends LitElement {
    product: ProductResult | null;
    private user;
    protected createRenderRoot(): HTMLElement | DocumentFragment;
    connectedCallback(): void;
    render(): TemplateResult<1> | undefined;
    renderTileContent(product: ProductResult): TemplateResult<1>;
    private getProductImageAlt;
    static defaultStyles: CSSResult[];
}

export declare class ProductView extends LitElement {
    productId: string | null;
    variantId: string | undefined;
    connectedCallback(): Promise<void>;
}

export declare class PurchasedWithMultipleProducts extends ProductRecommendationBase {
    private productAndVariantIds;
    connectedCallback(): Promise<void>;
    private parseProductAndVariantIds;
    fetchProducts(): Promise<ProductRecommendationResponse | undefined>;
    buildRequest(): Promise<PurchasedWithMultipleProductsRequest | undefined>;
}

export declare class PurchasedWithProduct extends ProductRecommendationBase {
    productId: string | undefined;
    variantId: string | undefined;
    fetchProducts(): Promise<ProductRecommendationResponse | undefined>;
    buildRequest(): Promise<PurchasedWithProductRequest | undefined>;
}

export declare enum QueryKeys {
    term = "rw-term",
    take = "rw-take",
    sortBy = "rw-sorting",
    facet = "rw-facet-",
    facetUpperbound = "rw-facet-upperbound-",
    facetLowerbound = "rw-facet-lowerbound-"
}

export declare function readCurrentUrlState(queryParamName: string): string | null;

export declare function readCurrentUrlStateValues(queryParamName: string): string[];

export declare class RecentlyViewedProducts extends ProductRecommendationBase {
    fetchProducts(): Promise<ProductRecommendationResponse | undefined>;
    buildRequest(): Promise<ProductRecommendationRequest>;
}

export declare class RecommendationBatcher extends LitElement {
    data: BatchingContextValue;
    timeoutHandler: ReturnType<typeof setTimeout> | undefined;
    batchBound: () => Promise<void>;
    registerEventBound: (e: Event) => void;
    constructor();
    connectedCallback(): Promise<void>;
    disconnectedCallback(): void;
    batch(): Promise<void>;
    registerEvent(e: Event): void;
    render(): TemplateResult<1>;
}

export declare function registerRecommendationTarget(target: string, configuration: TargetedRecommendationConfiguration): void;

export declare function registerSearchTarget(target: string, configuration: TargetedSearchConfiguration): void;

export declare interface RelevanceModifiers {
    product?: (builder: RelevanceModifierBuilder) => void;
    productCategory?: (builder: RelevanceModifierBuilder) => void;
    content?: (builder: RelevanceModifierBuilder) => void;
}

export declare class RelewiseFacetBuilder {
    builder: FacetBuilder;
    private labels;
    constructor(builder: FacetBuilder);
    addFacet(facet: (builder: FacetBuilder) => void, options: {
        heading: string;
    }): this;
    getLabels(): string[];
}

export declare type RelewiseUILocalization = {
    favoriteButton?: FavoriteButtonLocalization;
    sentimentButtons?: SentimentButtonsLocalization;
};

export declare interface RelewiseUIOptions {
    datasetId: string;
    apiKey: string;
    contextSettings: ContextSettings;
    localization?: RelewiseUILocalization;
    selectedPropertiesSettings?: {
        product?: Partial<SelectedProductPropertiesSettings>;
        variant?: Partial<SelectedVariantPropertiesSettings>;
        productCategory?: Partial<SelectedProductCategoryPropertiesSettings>;
        content?: Partial<SelectedContentPropertiesSettings>;
    };
    clientOptions: RelewiseClientOptions;
    templates?: Templates;
    filters?: Filters;
    relevanceModifiers?: RelevanceModifiers;
    targets?: Targets;
    userEngagement?: UserEngagementOptions;
}

export declare interface RelewiseUISearchOptions {
    filters?: SearchFilters;
    templates?: SearchTemplates;
    facets?: SearchFacets;
    localization?: SearchLocalization;
    rememberScrollPosition?: boolean;
    debounceTimeInMs?: number;
    explodedVariants?: number;
}

export declare class SearchBar extends LitElement {
    term: string;
    setSearchTerm: (term: string) => void;
    handleKeyEvent: (event: KeyboardEvent) => void;
    setSearchBarInFocus: (inFocus: boolean) => void;
    placeholder: string | null;
    autofocus: boolean;
    connectedCallback(): void;
    firstUpdated(): void;
    focusSearchInput(): void;
    render(): TemplateResult<1>;
    static styles: CSSResult[];
}

export declare interface SearchBarLocalization {
    search?: string;
    placeholder?: string;
    overlay?: {
        title?: {
            products?: string;
            productCategories?: string;
        };
    };
}

export declare interface SearchFacets {
    product?: (builder: RelewiseFacetBuilder) => void;
}

export declare interface SearchFilters {
    product?: (builder: FilterBuilder) => void;
    productCategory?: (builder: FilterBuilder) => void;
}

export declare class SearchIcon extends LitElement {
    connectedCallback(): void;
    render(): TemplateResult<1>;
    static styles: CSSResult;
}

export declare interface SearchLocalization {
    searchBar?: SearchBarLocalization;
    sortingButton?: SortingLocalization;
    loadMoreButton?: LoadMoreLocalization;
    facets?: FacetLocalization;
    searchResults?: SearchResultLocalization;
}

export declare type SearchResult = {
    title?: string;
    product?: ProductResult;
    searchTermPrediction?: SearchTermPredictionResult;
    productCategory?: ProductCategoryResult;
    redirect?: RedirectResult;
    showAllResults?: boolean;
};

export declare interface SearchResultLocalization {
    noResults?: string;
    showAllResults?: string;
    result?: string;
    results?: string;
}

export declare interface SearchTemplates {
    searchOverlayProductResult?: (product: ProductResult, extensions: ProductTemplateExtensions) => TemplateResult_2<1> | typeof nothing | Promise<TemplateResult_2<1> | typeof nothing>;
    searchOverlayProductCategoryResult?: (productCategory: ProductCategoryResult, extensions: ProductTemplateExtensions) => TemplateResult_2<1> | typeof nothing | Promise<TemplateResult_2<1> | typeof nothing>;
}

export declare interface SentimentButtonsLocalization {
    like?: string;
    removeLike?: string;
    dislike?: string;
    removeDislike?: string;
}

export declare type SentimentChangeDetail = {
    sentiment: 'Like' | 'Dislike' | null;
    entityType?: 'Product' | 'Content';
    productId?: string;
    variantId?: string | null;
    contentId?: string;
};

export declare const SessionVariables: {
    scrollPosition: string;
};

export declare class SortIcon extends LitElement {
    connectedCallback(): void;
    render(): TemplateResult<1>;
    static styles: CSSResult;
}

export declare enum SortingEnum {
    Relevance = "Relevance",
    SalesPriceAsc = "SalesPriceAsc",
    SalesPriceDesc = "SalesPriceDesc",
    AlphabeticallyAsc = "AlphabeticallyAsc",
    AlphabeticallyDesc = "AlphabeticallyDesc"
}

export declare interface SortingLocalization {
    sortBy?: string;
    sorting?: string;
    relevance?: string;
    salesPriceAscending?: string;
    salesPriceDescending?: string;
    alphabeticalAscending?: string;
    alphabeticalDescending?: string;
}

export declare type StringTransformationResult<T> = T extends string ? string : T;

export declare function stripHtmlClientSide<T>(value: T): StringTransformationResult<T>;

export declare type TargetedRecommendationConfiguration = {
    filters?: (builder: FilterBuilder) => void;
    relevanceModifiers?: (builder: RelevanceModifierBuilder) => void;
};

export declare class TargetedRecommendationConfigurations {
    private templates;
    constructor(initialValues?: (builder: TargetedRecommendationConfigurations) => void);
    add(configuration: {
        target: string;
        configuration: TargetedRecommendationConfiguration;
    }): this;
    has(target: string): boolean;
    handle(target: string, builder: RecommendationRequestBuilder): void;
}

export declare type TargetedSearchConfiguration = {
    overwriteFacets?: (builder: RelewiseFacetBuilder) => void;
    filters?: (builder: FilterBuilder) => void;
    relevanceModifiers?: (builder: RelevanceModifierBuilder) => void;
};

export declare class TargetedSearchConfigurations {
    private templates;
    constructor(initialValues?: (builder: TargetedSearchConfigurations) => void);
    add(configuration: {
        target: string;
        configuration: TargetedSearchConfiguration;
    }): this;
    has(target: string): boolean;
    hasOverwrittenFacets(target: string): boolean;
    handle(target: string, builder: ProductSearchBuilder): {
        facetLabels?: string[];
    };
}

export declare interface Targets {
    searchTargets?: (builder: TargetedSearchConfigurations) => void;
    recommendationTargets?: (builder: TargetedRecommendationConfigurations) => void;
}

export declare type TemplateHelpers = typeof templateHelpers;

export declare const templateHelpers: {
    stripHtmlClientSide: typeof stripHtmlClientSide;
};

export declare interface Templates {
    product?: (product: ProductResult, extensions: ProductTemplateExtensions) => TemplateResult_2<1> | typeof nothing | Promise<TemplateResult_2<1> | typeof nothing>;
    content?: (content: ContentResult, extensions: ContentTemplateExtensions) => TemplateResult_2<1> | typeof nothing | Promise<TemplateResult_2<1> | typeof nothing>;
}

export declare const theme: CSSResult;

export declare function updateContextSettings(contextSettings: Partial<ContextSettings>): void;

export declare function updateUrlState(queryParamName: string, value: string | null): void;

export declare function updateUrlStateValues(queryParamName: string, values: string[]): void;

export declare function useBehavioralTracking(): void;

export declare function useRecommendations(): void;

export declare interface UserEngagementEntityOptions {
    sentiment?: boolean;
    favorite?: boolean;
}

export declare interface UserEngagementOptions {
    product?: UserEngagementEntityOptions;
    content?: UserEngagementEntityOptions;
}

export declare function useSearch(options?: RelewiseUISearchOptions): void;

export declare class XIcon extends LitElement {
    connectedCallback(): void;
    render(): TemplateResult<1>;
    static styles: CSSResult;
}

export { }