import { ProductSchema } from '@byondrnd/showroom-schemas';
import { Visualizer } from '../Visualizer';
/** @ignore */
export interface IEventSystem {
    /** every camera zoom or move */
    camera: IEventsTypes.OnCamera;
    /** once, after the visualizer container is injected */
    containerInjected: IEventsTypes.OnContainerInjected;
    /** once, after the visualizer is loaded */
    visualizerLoaded: IEventsTypes.OnVisualizerLoaded;
    /** when scene rendered */
    rendered: IEventsTypes.OnRendered;
    /** when hotspot mouse hovered */
    hoverHotspot: IEventsTypes.onHoverHotspot;
    /** every time a scene is loaded */
    sceneLoaded: IEventsTypes.OnSceneLoaded;
    /** every time a scene is loading */
    sceneLoading: IEventsTypes.OnSceneLoading;
    /** every time a product has be added to the scene and finished display by the user */
    userChangedProduct: IEventsTypes.OnUserChangedProduct;
    /** every time a product started changing */
    productChanging: IEventsTypes.OnProductChanging;
    /** every time a product has be added to the scene and finished display */
    productChanged: IEventsTypes.OnProductChanged;
    /** every time a set finished display */
    favoritesSceneDisplayed: IEventsTypes.onFavoritesSceneDisplayed;
    /** every time an hotspot was clicked on the scene */
    applicationSelected: IEventsTypes.onApplicationSelected;
    /** every time a product was added to favorite */
    productAddedToFavorites: IEventsTypes.onProductAddedToFavorites;
    /** every time a set was added to favorite */
    sceneAddedToFavorites: IEventsTypes.onSceneAddedToFavorites;
    /** every time a product was removed from favorite */
    productRemovedFromFavorites: IEventsTypes.onProductRemovedFromFavorites;
    /** every time a set was removed from favorite */
    sceneRemovedFromFavorites: IEventsTypes.onSceneRemovedFromFavorites;
    /** every time a product was added to cart */
    productAddedToCart: IEventsTypes.onProductAddedToCart;
    /** every time order sample was clicked on scene */
    orderSample: IEventsTypes.onOrderSample;
    /** every time an async operation starts */
    asyncOperationStarted: IEventsTypes.onAsyncOperationStarted;
    /** every time an async operation ends */
    asyncOperationEnded: IEventsTypes.onAsyncOperationEnded;
    /** every time scene is touched */
    sceneTouched: IEventsTypes.onSceneTouched;
    /** every time scene configuration changed */
    sceneConfigurationLabelChanged: IEventsTypes.OnSceneConfigurationLabelChanged;
    /** download scene summary */
    summaryClicked: IEventsTypes.onSummaryClicked;
    /** opened fullscreen */
    fullscreenClicked: IEventsTypes.onFullscreenClicked;
    /** closed fullscreen */
    closeFullscreenClicked: IEventsTypes.onCloseFullscreenClicked;
    /** opened favorites panel */
    favoritesPanelOpened: IEventsTypes.onFavoritesPanelOpened;
    /** closed favorites panel */
    favoritesPanelClosed: IEventsTypes.onFavoritesPanelClosed;
    /** selected favorite scene */
    favoriteSceneClicked: IEventsTypes.onFavoriteSceneClicked;
    /** opened scenes panel  */
    scenesPanelOpened: IEventsTypes.onScenesPanelOpened;
    /** closed scenes panel */
    scenesPanelClosed: IEventsTypes.onScenesPanelClosed;
    /** clicked applications strip button */
    applicationsStripButtonClicked: IEventsTypes.onApplicationsStripButtonClicked;
    /** clicked application point */
    applicationPointClicked: IEventsTypes.onApplicationPointClicked;
    /** clicked applications navigate button */
    applicationsNavigateButtonClicked: IEventsTypes.onApplicationsNavigateButtonClicked;
    /** applications strip opened  */
    applicationsStripOpened: IEventsTypes.onApplicationsStripOpened;
}
/**@ignore */
export declare type EventSystemEventSignature = keyof IEventSystem;
/**@ignore */
export declare type EventSystemEventTypesSignature = IEventSystem[EventSystemEventSignature];
/**@ignore */
export declare type EventSystemEventDataSignature = Parameters<EventSystemEventTypesSignature>;
declare type TAnalyticsEvent = Partial<{
    [key in keyof IEventSystem]: {
        category: string;
        eventParamsPaths: string[];
    };
}>;
/**
 * property names are assigned to **action**
 *
 * evenParamsPaths are serialized into **label** (and delimited with ':')
 */
export declare const analyticsEvents: TAnalyticsEvent;
export declare type IConfigurationFilter = {
    name: string;
    customFieldName?: string;
    operator?: 'not';
    options: string[] | null;
};
export declare type IProductSkuAndApplication = {
    sku: string;
    application: string;
};
export declare type IFavoriteProductSkuAndApplication = {
    product: IProductSkuAndApplication;
};
export declare type IFacet = {
    name: string;
    options: string[] | null;
};
export declare type IProduct = {
    sku: string;
    name?: string;
    title: string;
    description?: string;
    application: string;
    image: string;
    price?: string;
    facets?: IFacet[];
    applications?: string[];
    _id: string;
};
export declare type IFavorite = {
    product: IProduct;
};
export declare type ISceneSubSelection = {
    name: string;
    title?: string;
    previewImage?: string;
};
export declare type IConfigurationSceneCommon = {
    title: string;
    subtitle?: string;
    previewImage?: string;
};
export declare type IConfigurationSceneOutput = IConfigurationSceneCommon & {
    name: string;
    subSelection?: ISceneSubSelection;
};
export declare type IScene = IConfigurationSceneOutput & {
    experienceId: string;
    sceneId: string;
};
export declare type IFavoriteScene = {
    id: string;
    image: string;
    favorites: IFavorite[];
    scene: IScene;
};
export declare type IFavoriteSceneList = IFavoriteScene[];
export declare type IFavoriteProductList = IFavorite[];
export declare type IFavoriteProductSkuAndApplicationList = IFavoriteProductSkuAndApplication[];
export interface IApplication {
    application: string;
    title: string;
    image?: string;
    buttons?: IApplicationButtonsConfiguration;
    fields?: IApplicationFieldsConfiguration;
}
export interface ICatalogFieldsMapping {
    title?: string;
    description?: string;
    price?: string;
    facets?: Array<string>;
}
export interface IConfigurationAlias {
    name: string;
    alias: string;
}
export interface IButtonConfiguration {
    visible?: boolean;
}
export interface IFieldConfiguration {
    visible?: boolean;
}
export interface IApplicationButtonsConfiguration {
    orderSample?: IButtonConfiguration;
    addToCart?: IButtonConfiguration;
}
export interface IApplicationFieldsConfiguration {
    price?: IFieldConfiguration;
    title?: IFieldConfiguration;
    description?: IFieldConfiguration;
}
export interface IConfigurationCatalogFilters {
    products: {
        customFields: Array<IConfigurationFilter>;
        fromDate: {
            customFieldName?: string;
        };
    };
}
export interface IConfigurationAnalyticsPluginsDetailsGDPR {
    type: string;
    cookieIds: string;
}
export interface IConfigurationAnalyticsPluginsDetails {
    trackingId: string;
    GDPR: IConfigurationAnalyticsPluginsDetailsGDPR;
}
export interface IConfigurationAnalyticsPlugins {
    name: string;
    details: IConfigurationAnalyticsPluginsDetails;
}
export interface IConfigurationAnalytics {
    plugins: Array<IConfigurationAnalyticsPlugins>;
}
export interface IPreFilterProducts {
    plugins: Array<IConfigurationAnalyticsPlugins>;
}
export interface IConfigurationSceneRaw extends IConfigurationSceneCommon {
    name?: string;
    names?: string;
    subSelection?: ISceneSubSelection;
}
export interface IConfigurationSceneRawExp extends IConfigurationSceneCommon {
    name: string;
    subSelections?: Array<ISceneSubSelection>;
}
export interface IConfigurationProducts {
    search: {
        fields: {
            title: {
                included: boolean;
            };
            sku: {
                included: boolean;
            };
            filters: {
                values: {
                    included: boolean;
                };
            };
        };
    };
}
export interface ISceneConfigurationUnilevelEntity {
    products?: IConfigurationProducts;
    theme?: Record<string, any>;
    maxFaceSize?: number;
    maxFaceSizeMobile?: number;
    label?: string;
    catalogFieldsMapping?: ICatalogFieldsMapping;
    catalogFilters?: IConfigurationCatalogFilters;
    applications?: Array<IApplication>;
    fieldsAliases?: Array<IConfigurationAlias>;
    /** by creating sceneListFilters (at least only with names) at the exp level - it will determine the order in the ui */
    sceneListFilters?: Array<IConfigurationFilter>;
    analytics?: IConfigurationAnalytics;
}
export interface ISceneConfigurationEntityRaw extends ISceneConfigurationUnilevelEntity {
    scene: IConfigurationSceneRaw;
}
export interface ISceneConfigurationEntityOutput extends ISceneConfigurationUnilevelEntity {
    scene: IConfigurationSceneOutput;
}
export interface IExpConfigurationEntityRaw extends ISceneConfigurationUnilevelEntity {
    scenes?: Array<IConfigurationSceneRawExp>;
}
export interface ISceneConfigurationRaw {
    defaults?: ISceneConfigurationEntityRaw;
    configurations?: Array<ISceneConfigurationEntityRaw>;
}
export interface IExpConfigurationRaw {
    defaults?: IExpConfigurationEntityRaw;
    configurations?: Array<IExpConfigurationEntityRaw>;
}
export declare abstract class IVisualizer {
    /** start and load the visualizer app, will be triggered automatically on [data-role="visualizer"] elements
     * after complete will emit a "visualizerLoaded" event
     */
    abstract initAndLoad(): Promise<void>;
    /** set favorite scenes
     * Accepts array of favorite scenes that was sent previously by Visualizer
     */
    abstract setFavoriteScenes(favoriteScenes: IFavoriteSceneList): any;
    /** set favorite products
     * Accepts array of favorite products that was sent previously by Visualizer or array of product skus and applications
     */
    abstract setFavoriteProducts(favoriteProducts: IFavoriteProductList | IFavoriteProductSkuAndApplicationList): any;
    /** will return the curren scene */
    abstract getCurrentScene(): IScene;
    /** will return the scene list available in this experience */
    abstract getSceneList(): Array<IScene>;
    /** will set the current scene
     * after complete will emit a "sceneLoaded" event
     *
     * @param sceneId - the sceneId to lunch
     */
    abstract setScene(param: {
        sceneId?: string;
        preventDefaultProducts?: boolean;
        preventEvent?: boolean;
        displayDefaultApplication?: boolean;
    }): Promise<void>;
    /** will return products list according to the current application and filters */
    abstract getProductList(): Array<IProduct> | undefined;
    /** will return applications available on this experience */
    abstract getApplicationsList(): Array<IApplication>;
    /** will return the current applications */
    abstract getCurrentApplication(): IApplication | undefined;
    /** will set the current applications
     * @param application - the application to set
     */
    abstract setCurrentApplication(application: IApplication): Promise<IApplication | undefined>;
    /** will return the available filters */
    abstract getFilters(): Array<IConfigurationFilter>;
    /** will return the current filters */
    abstract getCurrentSearchText(): string;
    /** will return the current filters */
    abstract getCurrentFilters(): Array<IConfigurationFilter>;
    /** will set the current filters
     * @param filters - the filters to set
     */
    abstract setFilter(filters: Array<IConfigurationFilter>): Array<IConfigurationFilter> | undefined;
    /** will set a product on a specific application
     * will emit a "productChanged" event after complete
     */
    abstract displayProduct(productSku: string, _applications: IApplication | string[] | string, animateToProduct?: boolean): Promise<void>;
    /** will display product on each of the applications
     * will emit a "productChanged" event after complete of each display
     */
    abstract displayFavoriteProduct({ sku, applications }: {
        sku: string;
        applications: string[];
    }): Promise<void>;
    /** will display a saved scene
     * will emit a "sceneDisplayed" event after complete
     */
    abstract displaySceneFromFavorites(setId: string): Promise<void>;
    /** will return the product displayed on an application in the current scene */
    abstract getDisplayedProduct(application: IApplication): IProduct | undefined;
    /** will return all displayed products in the current scene*/
    abstract getDisplayedProducts(): Array<IProduct>;
    /** will add a product to favorites
     * will emit a "productAddedToFavorites" event
     */
    abstract addProductToFavorites(productSku: string, application: string): IFavoriteProductList;
    /** will remove a product from favorites
     * will emit a "productRemovedFromFavorites" event
     */
    abstract removeProductFromFavorites(productSku: string, application: string): IFavoriteProductList;
    /** will return the favorite products */
    abstract getFavoriteProducts(): IFavoriteProductList;
    /** will add a scene to favorites
     * will emit a "sceneAddedToFavorites" event
     */
    abstract addFavoriteScene(): Promise<IFavoriteSceneList>;
    /** will remove a scene from favorites
     * will emit a "sceneRemovedFromFavorites" event
     */
    abstract removeFavoriteScene(setId: string): IFavoriteSceneList;
    /** will return the favorite set list */
    abstract getFavoriteScenes(): IFavoriteSceneList;
    /** will emit a "productAddedToCart" event */
    abstract addProductToCart(product: IProduct): void;
    /** will emit a "orderSample" event */
    abstract orderSample(product: IProduct): void;
}
/**@ignore */
export declare class VisualizerElement extends Element {
    Visualizer: Visualizer;
}
export declare type ICameraEventType = 'zoom' | 'move';
export declare type THotspotOnRender = {
    application: string;
    title: string;
    position: {
        x: number;
        y: number;
    };
};
/**
 * events when using addEventListener on the visualizer element
 * for example:
 * ```typescript
 * const handleOnSceneLoaded = ({ scene }) => {
 * };
 * visualizerApp.on('sceneLoaded', handleOnSceneLoaded);
 * ```
 */
export declare namespace IEventsTypes {
    /**@event */
    type OnCamera = (eventData: {
        eventType: ICameraEventType;
    }) => void;
    /**@event */
    type OnContainerInjected = (eventData: {
        visualizer: Visualizer;
    }) => void;
    /**@event */
    type OnVisualizerLoaded = (eventData: {
        visualizer: Visualizer;
        experienceConfiguration: ISceneConfigurationEntityOutput;
    }) => void;
    /**@event */
    type OnRendered = (eventData: {
        hotspots: THotspotOnRender[];
        visibleHotspots: THotspotOnRender[];
    }) => void;
    /**@event */
    type onHoverHotspot = (eventData: {
        hotspot: {
            application: string;
            title: string;
            isHover: boolean;
        };
    }) => void;
    /**@event */
    type OnSceneLoaded = (eventData: {
        scene: IScene | undefined;
    }) => void;
    type OnSceneLoading = (eventData: {
        scene: IScene;
        sceneConfiguration: ISceneConfigurationEntityOutput;
    }) => void;
    /**@event */
    type OnProductChanging = (eventData: {
        product: ProductSchema.IProduct;
        fromFavorites?: boolean;
    }) => void;
    /**@event */
    type OnProductChanged = (eventData: {
        product: ProductSchema.IProduct;
        fromFavorites?: boolean;
    }) => void;
    /**@event */
    type OnUserChangedProduct = (eventData: {
        product: ProductSchema.IProduct;
    }) => void;
    /**@event */
    type onFavoritesSceneDisplayed = (eventData: {
        scene: IFavoriteScene;
    }) => void;
    /**@event */
    type onApplicationSelected = (eventData: {
        application: IApplication;
    }) => void;
    /**@event */
    type onProductAddedToFavorites = (eventData: {
        favorites: IFavoriteProductList;
        product?: IProduct;
    }) => void;
    /**@event */
    type onSceneAddedToFavorites = (eventData: {
        favoriteScenes: IFavoriteSceneList;
        scene?: IFavoriteScene;
    }) => void;
    /**@event */
    type onProductRemovedFromFavorites = (eventData: {
        favorites: IFavoriteProductList;
        product: IProduct;
    }) => void;
    /**@event */
    type onSceneRemovedFromFavorites = (eventData: {
        favoriteScenes: IFavoriteSceneList;
        scene: IFavoriteScene;
    }) => void;
    /**@event */
    type onProductAddedToCart = (eventData: {
        product: IProduct;
    }) => void;
    /**@event */
    type onOrderSample = (eventData: {
        product: IProduct;
    }) => void;
    /**@event */
    type onAsyncOperationStarted = (eventData: {
        processId?: string;
        progress: {
            percent: number;
        };
    }) => void;
    /**@event */
    type onAsyncOperationEnded = (eventData: {
        processId?: string;
    }) => void;
    /**@event */
    type onSceneTouched = (eventData: {
        scene: IScene;
    }) => void;
    /**@event */
    type OnSceneConfigurationLabelChanged = () => void;
    /**@event */
    type onSummaryClicked = () => void;
    /**@event */
    type onFullscreenClicked = () => void;
    /**@event */
    type onCloseFullscreenClicked = () => void;
    /**@event */
    type onFavoritesPanelOpened = () => void;
    /**@event */
    type onFavoritesPanelClosed = () => void;
    /**@event */
    type onFavoriteSceneClicked = () => void;
    /**@event */
    type onScenesPanelOpened = () => void;
    /**@event */
    type onScenesPanelClosed = () => void;
    /**@event */
    type onApplicationsStripButtonClicked = () => void;
    /**@event */
    type onApplicationPointClicked = () => void;
    /**@event */
    type onApplicationsNavigateButtonClicked = () => void;
    /**@event */
    type onApplicationsStripOpened = () => void;
}
/**
 * events when using on/off on the visualizer instance
 * for example:
 * ```typescript
 * const onVisualizerLoaded = ({ detail }) => {
 *  const visualizerApp: Visualizer = detail.visualizer;
 *  const applications = visualizerApp.GetApplicationsList();
 *  console.log(applications);
 * };
 * const containerElement = document.querySelector('.visualizer');
 * containerElement.addEventListener('visualizerLoaded', onVisualizerLoaded);
 * ```
 */
export declare namespace IEventsTypesListeners {
    /**@event */
    type OnCamera = (event: CustomEvent & {
        detail: {
            eventType: ICameraEventType;
        };
    }) => void;
    /**@event */
    type OnContainerInjected = (event: CustomEvent & {
        detail: {
            visualizer: Visualizer;
        };
    }) => void;
    /**@event */
    type OnVisualizerLoaded = (event: CustomEvent & {
        detail: {
            visualizer: Visualizer;
            experienceConfiguration: ISceneConfigurationEntityOutput;
        };
    }) => void;
    /**@event */
    type OnRendered = (event: CustomEvent & {
        detail: {
            hotspots: THotspotOnRender[];
            visibleHotspots: THotspotOnRender[];
        };
    }) => void;
    /**@event */
    type onHoverHotspot = (event: CustomEvent & {
        detail: {
            hotspot: {
                application: string;
                title: string;
                isHover: boolean;
            };
        };
    }) => void;
    /**@event */
    type OnSceneLoaded = (event: CustomEvent & {
        detail: {
            scene: IScene | undefined;
            sceneConfiguration: ISceneConfigurationEntityOutput;
        };
    }) => void;
    type OnSceneLoading = (event: CustomEvent & {
        detail: {
            scene: IScene;
            sceneConfiguration: ISceneConfigurationEntityOutput;
        };
    }) => void;
    /**@event */
    type OnUserChangedProduct = (event: CustomEvent & {
        detail: {
            product: ProductSchema.IProduct;
        };
    }) => void;
    /**@event */
    type OnProductChanging = (event: CustomEvent & {
        detail: {
            product: ProductSchema.IProduct;
            fromFavorites?: boolean;
        };
    }) => void;
    /**@event */
    type OnProductChanged = (event: CustomEvent & {
        detail: {
            product: ProductSchema.IProduct;
            fromFavorites?: boolean;
        };
    }) => void;
    /**@event */
    type onFavoritesSceneDisplayed = (event: CustomEvent & {
        detail: {
            scene: IFavoriteScene;
        };
    }) => void;
    /**@event */
    type onApplicationSelected = (event: CustomEvent & {
        detail: {
            application: IApplication;
        };
    }) => void;
    /**@event */
    type onProductAddedToFavorites = (event: CustomEvent & {
        detail: {
            favorites: IFavoriteProductList;
            product?: IProduct;
        };
    }) => void;
    /**@event */
    type onSceneAddedToFavorites = (event: CustomEvent & {
        detail: {
            favoriteScenes: IFavoriteSceneList;
            scene?: IFavoriteScene;
        };
    }) => void;
    /**@event */
    type onProductRemovedFromFavorites = (event: CustomEvent & {
        detail: {
            favorites: IFavoriteProductList;
            product: IProduct;
        };
    }) => void;
    /**@event */
    type onSceneRemovedFromFavorites = (event: CustomEvent & {
        detail: {
            favoriteScenes: IFavoriteSceneList;
            scene: IFavoriteScene;
        };
    }) => void;
    /**@event */
    type onProductAddedToCart = (event: CustomEvent & {
        detail: {
            product: IProduct;
        };
    }) => void;
    /**@event */
    type onOrderSample = (event: CustomEvent & {
        detail: {
            product: IProduct;
        };
    }) => void;
    /**@event */
    type onAsyncOperationStarted = (event: CustomEvent & {
        detail: {
            processId?: string;
            progress: {
                percent: number;
            };
        };
    }) => void;
    /**@event */
    type onAsyncOperationEnded = (event: CustomEvent & {
        detail: {
            processId?: string;
        };
    }) => void;
    /**@event */
    type onSceneTouched = (event: CustomEvent & {
        detail: {
            scene: IScene;
        };
    }) => void;
    /**@event */
    type OnSceneConfigurationLabelChanged = () => void;
    /**@event */
    type onSummaryClicked = () => void;
    /**@event */
    type onFullscreenClicked = () => void;
    /**@event */
    type onCloseFullscreenClicked = () => void;
    /**@event */
    type onFavoritesPanelOpened = () => void;
    /**@event */
    type onFavoritesPanelClosed = () => void;
    /**@event */
    type onFavoriteSceneClicked = () => void;
    /**@event */
    type onScenesPanelOpened = () => void;
    /**@event */
    type onScenesPanelClosed = () => void;
    /**@event */
    type onApplicationsStripButtonClicked = () => void;
    /**@event */
    type onApplicationsNavigateButtonClicked = () => void;
    /**@event */
    type onApplicationPointClicked = () => void;
    /**@event */
    type onApplicationsStripOpened = () => void;
}
export {};
