@colijnit/product 260.1.2 → 261.20.0

package/index.d.ts

@@ -0,0 +1,948 @@
+import * as i0 from '@angular/core';
+import { OnDestroy, OnInit, EventEmitter, AfterViewInit, ElementRef, Renderer2, ChangeDetectorRef, PipeTransform, OnChanges } from '@angular/core';
+import { Subject, BehaviorSubject } from 'rxjs';
+import { ArticleFullObject } from '@colijnit/articleapi/build/model/article-full-object';
+import { SuperArticle } from '@colijnit/articleapi/build/model/super-article';
+import { ConfiguratorStatisticsEnvironment } from '@colijnit/articleapi/build/model/configurator-statistics-environment';
+import { Articles } from '@colijnit/articleapi/build/articles';
+import { Options } from '@colijnit/ioneconnector/build/model/options';
+import { DeliveryPrognosis } from '@colijnit/articleapi/build/model/delivery-prognosis';
+import { DocumentContent } from '@colijnit/articleapi/build/model/document-content';
+import { Transaction } from '@colijnit/transactionapi/build/transaction';
+import { MainApi } from '@colijnit/mainapi';
+import { ArticleListObjectExtended } from '@colijnit/articleapi/build/model/article-list-object-extended.bo';
+import { ArticleListObject } from '@colijnit/articleapi/build/model/article-list-object';
+import { Selection } from '@colijnit/articleapi/build/model/selection';
+import { ArticleQuickSel } from '@colijnit/articleapi/build/model/article-quick-sel';
+import { ValidationMessage } from '@colijnit/ioneconnector/build/model/validation-message';
+import { CoDocument } from '@colijnit/mainapi/build/model/co-document.bo';
+import { ImageContent } from '@colijnit/mainapi/build/model/image-content.bo';
+import * as i2 from '@angular/common';
+import { SafeHtml, DomSanitizer, SafeUrl, SafeResourceUrl } from '@angular/platform-browser';
+import { ExternalSource } from '@colijnit/articleapi/build/model/external-source.bo';
+import * as i3 from '@colijnit/corecomponents_v12';
+import * as i5 from '@colijnit/sharedcomponents';
+import { ExternalSourceParameter } from '@colijnit/articleapi/build/model/external-source-parameter.bo';
+import { CatalogDefinition } from '@colijnit/articleapi/build/model/catalog-definition.bo';
+import { ExternalSourceArticleAddInterface } from '@colijnit/articleapi/build/interface/external-source-article-add.interface';
+import { ExternalCatalogStartupInfo } from '@colijnit/articleapi/build/model/external-catalog-startup-info';
+
+declare class Version {
+    name: string;
+    description: string;
+    symVer: string;
+    publishDate: string;
+}
+
+declare class ProductEventService {
+    onAddToCart: Subject<{
+        article: string | ArticleListObjectExtended;
+        quantity: number;
+    }>;
+    onAlternativeClick: Subject<ArticleListObject>;
+    onAddToQuote: Subject<string>;
+    onForceRenderImage: Subject<void>;
+    onArticleReceived: Subject<ArticleQuickSel>;
+    onSelectionsReceived: Subject<Selection[]>;
+    onImageReceived: Subject<string>;
+    onRenderStarted: Subject<void>;
+    onRenderImageReceived: Subject<string>;
+    onDraftRenderImageReceived: Subject<CustomEvent>;
+    onArticleInfoReceived: Subject<string>;
+    onAnswersAvailable: Subject<boolean>;
+    onReadyToRender: Subject<boolean>;
+    onUpdateProductInfoTab: Subject<number>;
+    errorMessage: Subject<ValidationMessage[]>;
+    onGetRenderForRenderCarousel: Subject<any>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ProductEventService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ProductEventService>;
+}
+
+declare class ProductConnectorAdapterService implements OnDestroy {
+    private _eventService;
+    readonly showLoader: Subject<boolean>;
+    articleConnector?: Articles;
+    transactionConnector: Transaction;
+    mainConnector: MainApi;
+    private _boFactory;
+    private _subs;
+    constructor(_eventService: ProductEventService);
+    ngOnDestroy(): void;
+    initConnector(options: Options): Promise<void>;
+    setInstance(instanceId: string): void;
+    getProductBundleSettings(url: string, upId: number): Promise<string>;
+    convertArticleFullObjectToArticleExtended(article: ArticleFullObject): ArticleListObjectExtended;
+    getDeliveryPrognosis(goodId: number, branchNr?: string): Promise<any>;
+    getSelectorDeliveryDate(): Promise<DeliveryPrognosis>;
+    getArtStockStatus(goodId: number): Promise<number>;
+    getDeliveryDate2(goodId: number): Promise<DeliveryPrognosis>;
+    getJsonConfiguredArticles(configuratorStatistics?: ConfiguratorStatisticsEnvironment): Promise<string>;
+    getJsonArticleFlatTree(goodId: number, goodType: string, quantity: number, externalSource?: boolean, showLoader?: boolean, instanceId?: any, configuratorStatistics?: ConfiguratorStatisticsEnvironment): Promise<string>;
+    getGeneratedArtDirectly(goodId: number, showLoader: boolean): Promise<number>;
+    getGoodIdFromArticleNr(sku: string): Promise<number>;
+    getArticleFullObject(goodId: number, showLoader?: boolean): Promise<ArticleFullObject>;
+    getSuperArticle(id: string, branch?: string): Promise<SuperArticle>;
+    getDocumentContent(docId: number, thumbnail?: boolean): Promise<DocumentContent>;
+    addWebSessionTransactionLine(transactionUuid: string, sku: string, quantity: number): Promise<string>;
+    getImageForCoDocument(document: CoDocument, thumb: boolean): Promise<ImageContent>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ProductConnectorAdapterService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ProductConnectorAdapterService>;
+}
+
+declare class JsonUtilsService {
+    readJsonFile(filePath: string): Promise<any>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<JsonUtilsService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<JsonUtilsService>;
+}
+
+declare class DictionaryService {
+    private _jsonUtils;
+    private readonly dictionaryUrl;
+    get language(): string;
+    set rootUrl(value: string);
+    private _dictBasePath;
+    private _rootUrl;
+    private _dictionaries;
+    private _language;
+    private readonly _placeholder;
+    constructor(_jsonUtils: JsonUtilsService);
+    setDictionary(language: string): Promise<void>;
+    /**
+     * Returns the localized text for the given dictionary key.
+     * @param {string} key
+     * @param {boolean} [upperCaseFirst = true] False for first letter lowercase, true for first letter uppercase for returned dict val
+     * @param {string[]} replacementTexts Rest params for replacement of '|~' in returned dict value
+     * @returns {string} The translated text for given dictionary key
+     */
+    get(key: string, upperCaseFirst?: boolean, ...replacementTexts: string[]): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DictionaryService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DictionaryService>;
+}
+
+declare class SettingsOptions {
+    showStockStatus: boolean;
+    showZoomButton: boolean;
+    showTagFilter: boolean;
+    showAsConfigured: boolean;
+    inlineAnswers: boolean;
+    showArButton: boolean;
+    arEnabled: boolean;
+    vrEnabled: boolean;
+}
+
+declare enum RenderModes {
+    RenderRoom = "render_room",
+    RenderShop = "render_shop",
+    RenderIone = "render_ione"
+}
+
+declare class RenderParameters {
+    host: string;
+    port: number;
+    secure: boolean;
+    renderMode: RenderModes;
+}
+
+declare class ProductSettings extends Options {
+    currency: number;
+    session: any;
+    createWebOrder: boolean;
+    assetPath: string;
+    assetIndex: string;
+    currencySymbol: string;
+    threeDAssetPath: string;
+    lightPresetsIndex: string;
+    additionalTranslationFile: string;
+    gtm: string;
+    client: string;
+    options: SettingsOptions;
+    renderParameters: RenderParameters;
+}
+
+declare class ProductSettingsService {
+    private _jsonUtilsService;
+    private _dictionaryService;
+    set settings(value: ProductSettings);
+    get settings(): ProductSettings;
+    settingsLoaded: BehaviorSubject<boolean>;
+    private _settings;
+    constructor(_jsonUtilsService: JsonUtilsService, _dictionaryService: DictionaryService);
+    initializeSettings(finish?: boolean): Promise<void>;
+    createSettingsFromObject(obj: any): Promise<void>;
+    settingsFinished(): Promise<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ProductSettingsService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ProductSettingsService>;
+}
+
+declare class ProductConnectorService implements OnDestroy {
+    private _adapterService;
+    private _settingsService;
+    get shouldShowLoader(): boolean;
+    controllerInitialized: BehaviorSubject<boolean>;
+    articleLoaded: BehaviorSubject<boolean>;
+    private _shouldShowLoader;
+    private _initializing;
+    private _initialized;
+    private _instanceId;
+    private connectorOptions;
+    private readonly subs;
+    constructor(_adapterService: ProductConnectorAdapterService, _settingsService: ProductSettingsService);
+    ngOnDestroy(): void;
+    initConnection(): Promise<void>;
+    getProductBundleSettings(url: string, upId: number): Promise<string>;
+    setInstance(instanceId: string): void;
+    convertArticleFullObjectToArticleExtended(article: ArticleFullObject): ArticleListObjectExtended;
+    getFullArticle(sku: string): Promise<ArticleFullObject>;
+    getDocumentContent(docId: number, thumbnail?: boolean): Promise<DocumentContent>;
+    getDeliveryPrognosis(goodId: number): Promise<DeliveryPrognosis>;
+    getSelectorDeliveryDate(): Promise<DeliveryPrognosis>;
+    getArtStockStatus(goodId: number): Promise<number>;
+    getDeliveryDate2(goodId: number): Promise<DeliveryPrognosis>;
+    getSuperArticle(id: string): Promise<SuperArticle>;
+    getJsonArticleFlatTree(goodId: number, goodType: string, quantity: number, externalSource?: boolean, showLoader?: boolean, configuratorStatistics?: ConfiguratorStatisticsEnvironment): Promise<string>;
+    getGeneratedArtDirectly(goodId: number, showLoader?: boolean): Promise<number>;
+    addWebSessionTransactionLine(transactionUuid: string, sku: string, quantity: number): Promise<string>;
+    getImageForCoDocument(document: CoDocument, thumb?: boolean): Promise<ImageContent>;
+    onShowLoaderChange(showLoader: boolean): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ProductConnectorService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ProductConnectorService>;
+}
+
+declare class RootStorageObject {
+    id: string;
+}
+declare class LocalStorageService {
+    readonly storage: Storage;
+    protected _appRoot: string;
+    protected _storageObj: RootStorageObject;
+    constructor();
+    save(): void;
+    clear(): void;
+    set id(id: string);
+    get id(): string;
+    protected _initLocalStorageObj(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LocalStorageService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<LocalStorageService>;
+}
+
+declare class IoneProductComponent implements OnInit, OnDestroy {
+    private _appEventService;
+    private _settingsService;
+    private _productConnectorService;
+    private _localStorageService;
+    sku: string;
+    isReturn: boolean;
+    showRelatedProductsPopup: boolean;
+    enableRenderCarousel: boolean;
+    set settings(value: any);
+    get settings(): any;
+    handleAddArticleInternally: boolean;
+    handleAddToCartInternally: boolean;
+    onAddToCart: EventEmitter<{
+        article: string | ArticleListObjectExtended;
+        quantity: number;
+    }>;
+    forceRenderImage: EventEmitter<void>;
+    getRenderForRenderCarousel: EventEmitter<any>;
+    onAlternativeClick: EventEmitter<ArticleListObject>;
+    onArticleInfoReceived: EventEmitter<string>;
+    onArticleReceived: EventEmitter<ArticleQuickSel>;
+    onSelectionsReceived: EventEmitter<Selection[]>;
+    onAddToQuote: EventEmitter<string>;
+    openStockEvent: EventEmitter<void>;
+    onAnswersAvailable: EventEmitter<boolean>;
+    settingsLoaded: boolean;
+    showHD: boolean;
+    private _settings;
+    private _subs;
+    constructor(_appEventService: ProductEventService, _settingsService: ProductSettingsService, _productConnectorService: ProductConnectorService, _localStorageService: LocalStorageService);
+    ngOnInit(): Promise<void>;
+    ngOnDestroy(): void;
+    private _handleAnswerInfoReceived;
+    private _handleAnswersAvailable;
+    private _handleAddToCart;
+    openStock(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<IoneProductComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<IoneProductComponent, "app-ione-product", never, { "sku": { "alias": "sku"; "required": false; }; "isReturn": { "alias": "isReturn"; "required": false; }; "showRelatedProductsPopup": { "alias": "showRelatedProductsPopup"; "required": false; }; "enableRenderCarousel": { "alias": "enableRenderCarousel"; "required": false; }; "settings": { "alias": "settings"; "required": false; }; "handleAddArticleInternally": { "alias": "handleAddArticleInternally"; "required": false; }; "handleAddToCartInternally": { "alias": "handleAddToCartInternally"; "required": false; }; }, { "onAddToCart": "onAddToCart"; "forceRenderImage": "forceRenderImage"; "getRenderForRenderCarousel": "getRenderForRenderCarousel"; "onAlternativeClick": "onAlternativeClick"; "onArticleInfoReceived": "onArticleInfoReceived"; "onArticleReceived": "onArticleReceived"; "onSelectionsReceived": "onSelectionsReceived"; "onAddToQuote": "onAddToQuote"; "openStockEvent": "openStockEvent"; "onAnswersAvailable": "onAnswersAvailable"; }, never, never, false, never>;
+}
+
+declare class StockAndDelivery {
+    stock: number;
+    deliveryDescription: string;
+    constructor(stock?: any, deliveryDescription?: string);
+}
+
+declare enum SelectorType {
+    TwoD = "2D",
+    ThreeD = "3D",
+    Omni = "Omni"
+}
+
+/** AUTO GENERATED FILE. DO NOT CHANGE.. **/
+declare enum IconEnum {
+    AddToCartDrop = "add_to_cart_drop",
+    ArrowPointLeft = "arrow_point_left",
+    ArrowPointRight = "arrow_point_right",
+    CrossSkinny = "cross_skinny",
+    DeliveryTruck = "delivery_truck",
+    Download = "download",
+    FullScreen = "full_screen",
+    LinkSimpleRegular = "link_simple_regular",
+    Location = "location",
+    Logo = "logo",
+    MagicWand = "magic_wand",
+    NormalScreen = "normal_screen",
+    Quote = "quote",
+    Refresh = "refresh",
+    SaveSkinny = "save_skinny",
+    ThreeD = "three_d",
+    Truck = "truck",
+    TwoD = "two_d",
+    Warehouse = "warehouse"
+}
+
+declare class IconCacheService {
+    private _sanitizer;
+    /**
+     * All the icons as a large JSON object, from the all-icons.json file.
+     * The object has property keys that are the icon names, and property values with the data string of the actual svg icon.
+     */
+    get iconCache(): {
+        [iconName: string]: SafeHtml;
+    };
+    private _iconCache;
+    private _allIcons;
+    constructor(_sanitizer: DomSanitizer);
+    getIcon(iconName: IconEnum): SafeHtml;
+    setIconCache(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<IconCacheService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<IconCacheService>;
+}
+
+declare class ProductPageComponent implements OnInit, OnDestroy, AfterViewInit {
+    private _ione;
+    private _renderer;
+    private _changeDetector;
+    iconCache: IconCacheService;
+    settingsService: ProductSettingsService;
+    appEventService: ProductEventService;
+    readonly icon: typeof IconEnum;
+    configurator: ElementRef;
+    selections: ElementRef;
+    fullscreenbutton: ElementRef;
+    set sku(value: string);
+    get sku(): string;
+    set settings(value: any);
+    externalSource: ExternalSource;
+    createFrozenArticle: boolean;
+    isReturn: boolean;
+    showRelatedProductsPopup: boolean;
+    enableRenderCarousel: boolean;
+    openStockEvent: EventEmitter<void>;
+    get settings(): any;
+    set fullScreen(value: boolean);
+    get fullScreen(): boolean;
+    get fullScreenIcon(): IconEnum;
+    set currentView(value: SelectorType);
+    get currentView(): SelectorType;
+    article: ArticleFullObject;
+    stockAndDelivery: StockAndDelivery;
+    configurable: boolean;
+    threeD: boolean;
+    selectorType: SelectorType;
+    show2D: boolean;
+    show3D: boolean;
+    configuring: boolean;
+    showAddToCart: boolean;
+    fullscreenAnimationEnd: boolean;
+    settingsLoaded: boolean;
+    private _sku;
+    private _initializedSub;
+    private _fullScreen;
+    private _currentView;
+    private _subs;
+    private _settings;
+    private _pageLoadedSubscription;
+    constructor(_ione: ProductConnectorService, _renderer: Renderer2, _changeDetector: ChangeDetectorRef, iconCache: IconCacheService, settingsService: ProductSettingsService, appEventService: ProductEventService);
+    ngOnInit(): void;
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    setInstance(event: CustomEvent): void;
+    handleStartConfiguration(): void;
+    showFullScreen(): void;
+    private _handleSettingsLoaded;
+    private _getArticle;
+    openStock(): void;
+    handlePopUpChange(event: boolean): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ProductPageComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ProductPageComponent, "app-product-page", never, { "sku": { "alias": "sku"; "required": false; }; "settings": { "alias": "settings"; "required": false; }; "externalSource": { "alias": "externalSource"; "required": false; }; "createFrozenArticle": { "alias": "createFrozenArticle"; "required": false; }; "isReturn": { "alias": "isReturn"; "required": false; }; "showRelatedProductsPopup": { "alias": "showRelatedProductsPopup"; "required": false; }; "enableRenderCarousel": { "alias": "enableRenderCarousel"; "required": false; }; }, { "openStockEvent": "openStockEvent"; }, never, never, false, never>;
+}
+
+declare class ProductSelectorTypeComponent implements OnInit {
+    private _iconCache;
+    private _changeDetector;
+    readonly type: typeof SelectorType;
+    readonly icons: typeof IconEnum;
+    show2D: boolean;
+    show3D: boolean;
+    showRenderCarousel: boolean;
+    currentType: SelectorType;
+    onIconClick: EventEmitter<SelectorType>;
+    currentTypeChange: EventEmitter<SelectorType>;
+    twoDIcon: SafeHtml | null;
+    threeDIcon: SafeHtml | null;
+    constructor(_iconCache: IconCacheService, _changeDetector: ChangeDetectorRef);
+    ngOnInit(): void;
+    handleIconClick(type: SelectorType): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ProductSelectorTypeComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ProductSelectorTypeComponent, "app-product-selector-type", never, { "show2D": { "alias": "show2D"; "required": false; }; "show3D": { "alias": "show3D"; "required": false; }; "showRenderCarousel": { "alias": "showRenderCarousel"; "required": false; }; "currentType": { "alias": "currentType"; "required": false; }; }, { "onIconClick": "onIconClick"; "currentTypeChange": "currentTypeChange"; }, never, never, false, never>;
+}
+
+declare class LocalizePipe implements PipeTransform {
+    private _dictionaryService;
+    constructor(_dictionaryService: DictionaryService);
+    transform(value: string, upperCaseFirst?: boolean, replace?: string | string[]): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LocalizePipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<LocalizePipe, "localize", false>;
+}
+
+declare class PriceDisplayPipe implements PipeTransform {
+    transform(value: number | string, valutaSymbol: string): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PriceDisplayPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<PriceDisplayPipe, "priceDisplay", false>;
+}
+
+declare class PipeModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<PipeModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<PipeModule, [typeof LocalizePipe, typeof PriceDisplayPipe], never, [typeof LocalizePipe, typeof PriceDisplayPipe]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<PipeModule>;
+}
+
+declare class ProductSelectorTypeModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<ProductSelectorTypeModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<ProductSelectorTypeModule, [typeof ProductSelectorTypeComponent], [typeof i2.CommonModule, typeof PipeModule, typeof i3.IconModule], [typeof ProductSelectorTypeComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<ProductSelectorTypeModule>;
+}
+
+declare class ImageViewModel {
+    image: CoDocument | string;
+    source: SafeUrl;
+    originalSource: string;
+}
+declare class ImageCarouselComponent implements OnDestroy {
+    private _ione;
+    private _appEventService;
+    private _changeDetector;
+    private _domSanitizer;
+    carousel: ElementRef;
+    isPopupOpen: boolean;
+    selectedImage?: ImageViewModel;
+    onEsc(): void;
+    showRefresh: boolean;
+    set images(value: (CoDocument | string)[]);
+    get images(): (CoDocument | string)[];
+    handleWindowResize(): void;
+    gotoNextSlide(): void;
+    gotoPrevSlide(): void;
+    isCurrentIndex(index: number): boolean;
+    get currentIndex(): number;
+    set currentIndex(value: number);
+    resizing: boolean;
+    imageViewModels: ImageViewModel[];
+    showLoader: boolean;
+    private _resizeTimer;
+    private _currentIndex;
+    private _images;
+    private _subs;
+    private _resizeCanvasHeight;
+    constructor(_ione: ProductConnectorService, _appEventService: ProductEventService, _changeDetector: ChangeDetectorRef, _domSanitizer: DomSanitizer);
+    ngOnDestroy(): void;
+    handleThumbClick(index: number): void;
+    onForceRenderImage(): void;
+    handleShowImage(imageViewModel: ImageViewModel): void;
+    closePopup(): void;
+    private _filterValidImages;
+    private _loadAndRescaleImages;
+    private _resizeAndSanitizeSource;
+    private _detectPreferredMime;
+    private _scrollCarouselToIndex;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ImageCarouselComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ImageCarouselComponent, "app-image-carousel", never, { "showRefresh": { "alias": "showRefresh"; "required": false; }; "images": { "alias": "images"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class ImageCarouselModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<ImageCarouselModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<ImageCarouselModule, [typeof ImageCarouselComponent], [typeof i2.CommonModule, typeof i3.LoaderModule, typeof i3.ScrollContainerModule], [typeof ImageCarouselComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<ImageCarouselModule>;
+}
+
+declare class ProductDescriptionComponent implements OnInit {
+    article: ArticleFullObject;
+    constructor();
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ProductDescriptionComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ProductDescriptionComponent, "app-product-description", never, { "article": { "alias": "article"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class ProductDescriptionModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<ProductDescriptionModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<ProductDescriptionModule, [typeof ProductDescriptionComponent], [typeof i2.CommonModule], [typeof ProductDescriptionComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<ProductDescriptionModule>;
+}
+
+declare class ProductAdditionalDescriptionComponent implements OnInit {
+    private _appEventService;
+    set article(value: ArticleFullObject);
+    get article(): ArticleFullObject;
+    description: string;
+    private _article;
+    constructor(_appEventService: ProductEventService);
+    ngOnInit(): void;
+    onReadMore(): void;
+    private _prepareDescription;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ProductAdditionalDescriptionComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ProductAdditionalDescriptionComponent, "app-product-additional-description", never, { "article": { "alias": "article"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class ProductAdditionalDescriptionModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<ProductAdditionalDescriptionModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<ProductAdditionalDescriptionModule, [typeof ProductAdditionalDescriptionComponent], [typeof i2.CommonModule, typeof PipeModule], [typeof ProductAdditionalDescriptionComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<ProductAdditionalDescriptionModule>;
+}
+
+declare class ProductPriceComponent implements OnInit {
+    private _changeDetector;
+    set pricing(value: any);
+    get pricing(): any;
+    set configurable(value: boolean);
+    fromPrice: number;
+    toPrice: number;
+    valutaSign: string;
+    fromLabel: string;
+    toLabel: string;
+    showFromPrice: boolean;
+    private _pricing;
+    private _configurable;
+    constructor(_changeDetector: ChangeDetectorRef);
+    ngOnInit(): void;
+    private _setPrices;
+    private _getSign;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ProductPriceComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ProductPriceComponent, "app-product-price", never, { "pricing": { "alias": "pricing"; "required": false; }; "configurable": { "alias": "configurable"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class ProductPriceModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<ProductPriceModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<ProductPriceModule, [typeof ProductPriceComponent], [typeof i2.CommonModule, typeof PipeModule], [typeof ProductPriceComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<ProductPriceModule>;
+}
+
+declare class ProductAddtocartComponent implements OnInit, OnDestroy {
+    iconCache: IconCacheService;
+    private _ioneControllerService;
+    private _appEventService;
+    private _settingsService;
+    private _productConnectorAdapterService;
+    readonly icon: typeof IconEnum;
+    addToCartButton: ElementRef;
+    article: ArticleFullObject;
+    externalSource: ExternalSource;
+    createFrozenArticle: boolean;
+    configurable: boolean;
+    configuring: boolean;
+    showAddToCart: boolean;
+    isReturn: boolean;
+    fullscreen: boolean;
+    set quantity(value: number);
+    get quantity(): number;
+    startConfiguration: EventEmitter<void>;
+    addToCartClick: EventEmitter<number>;
+    addToQuoteClick: EventEmitter<number>;
+    showRelatedPopup: EventEmitter<boolean>;
+    showQuoteButton: boolean;
+    private _quantity;
+    constructor(iconCache: IconCacheService, _ioneControllerService: ProductConnectorService, _appEventService: ProductEventService, _settingsService: ProductSettingsService, _productConnectorAdapterService: ProductConnectorAdapterService);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    handleAddToCartClick(quantity: number): Promise<void>;
+    handleAddToQuoteClick(quantity: number): Promise<void>;
+    private _getJSONFromArticleObject;
+    private _handleGeneratedArticleDirectly;
+    private _getGeneratedArtDirectly;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ProductAddtocartComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ProductAddtocartComponent, "app-product-addtocart", never, { "article": { "alias": "article"; "required": false; }; "externalSource": { "alias": "externalSource"; "required": false; }; "createFrozenArticle": { "alias": "createFrozenArticle"; "required": false; }; "configurable": { "alias": "configurable"; "required": false; }; "configuring": { "alias": "configuring"; "required": false; }; "showAddToCart": { "alias": "showAddToCart"; "required": false; }; "isReturn": { "alias": "isReturn"; "required": false; }; "fullscreen": { "alias": "fullscreen"; "required": false; }; "quantity": { "alias": "quantity"; "required": false; }; }, { "startConfiguration": "startConfiguration"; "addToCartClick": "addToCartClick"; "addToQuoteClick": "addToQuoteClick"; "showRelatedPopup": "showRelatedPopup"; }, never, never, false, never>;
+}
+
+declare class ProductAddtocartModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<ProductAddtocartModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<ProductAddtocartModule, [typeof ProductAddtocartComponent], [typeof i2.CommonModule, typeof i3.InputNumberPickerModule, typeof i3.ButtonModule, typeof PipeModule, typeof i3.LoaderModule], [typeof ProductAddtocartComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<ProductAddtocartModule>;
+}
+
+declare class ArticleViewModel {
+    article: ArticleListObject;
+    imageData: string;
+    constructor(article: ArticleListObject, imageData?: string);
+}
+declare class ProductRelatedComponent {
+    private _iOne;
+    private _appEventService;
+    private _productConnectorAdapterService;
+    private _settingsService;
+    refType: number;
+    label: string;
+    externalSource: ExternalSource;
+    isSmallModus: boolean;
+    createFrozenArticle: boolean;
+    set articles(value: ArticleListObject[]);
+    get articles(): ArticleListObject[];
+    articleViewModels: ArticleViewModel[];
+    private _articles;
+    constructor(_iOne: ProductConnectorService, _appEventService: ProductEventService, _productConnectorAdapterService: ProductConnectorAdapterService, _settingsService: ProductSettingsService);
+    handleContentClick(article: ArticleListObject): void;
+    handleAddToCartClick(article: ArticleListObject): Promise<void>;
+    handleConfigureButtonClick(article: ArticleListObject): void;
+    handleThreeDButtonClick(article: ArticleListObject): void;
+    private _getJSONFromArticleObject;
+    private _loadImages;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ProductRelatedComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ProductRelatedComponent, "app-product-related", never, { "refType": { "alias": "refType"; "required": false; }; "label": { "alias": "label"; "required": false; }; "externalSource": { "alias": "externalSource"; "required": false; }; "isSmallModus": { "alias": "isSmallModus"; "required": false; }; "createFrozenArticle": { "alias": "createFrozenArticle"; "required": false; }; "articles": { "alias": "articles"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class HeaderComponent implements OnInit {
+    label: string;
+    amount: number;
+    constructor();
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HeaderComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HeaderComponent, "app-header", never, { "label": { "alias": "label"; "required": false; }; "amount": { "alias": "amount"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class HeaderModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<HeaderModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<HeaderModule, [typeof HeaderComponent], [typeof i2.CommonModule], [typeof HeaderComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<HeaderModule>;
+}
+
+declare class ProductRelatedModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<ProductRelatedModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<ProductRelatedModule, [typeof ProductRelatedComponent], [typeof i2.CommonModule, typeof HeaderModule, typeof i3.ScrollContainerModule, typeof i3.ArticleTileModule], [typeof ProductRelatedComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<ProductRelatedModule>;
+}
+
+declare class ProductStockComponent {
+    private _iOne;
+    private _iconCache;
+    readonly icon: typeof IconEnum;
+    set goodId(value: number);
+    get goodId(): number;
+    openStockEvent: EventEmitter<void>;
+    inStock: boolean;
+    stockLabel: string;
+    iconData: SafeHtml;
+    private _goodId;
+    constructor(_iOne: ProductConnectorService, _iconCache: IconCacheService);
+    openStock(): void;
+    private _getStockStatus;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ProductStockComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ProductStockComponent, "app-product-stock", never, { "goodId": { "alias": "goodId"; "required": false; }; }, { "openStockEvent": "openStockEvent"; }, never, never, false, never>;
+}
+
+declare class ProductStockModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<ProductStockModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<ProductStockModule, [typeof ProductStockComponent], [typeof i2.CommonModule, typeof i3.IconModule, typeof PipeModule], [typeof ProductStockComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<ProductStockModule>;
+}
+
+declare class ProductDeliveryComponent implements OnInit {
+    private _localizePipe;
+    private _iOne;
+    private _iconCache;
+    readonly icon: typeof IconEnum;
+    set stockAndDelivery(value: StockAndDelivery);
+    deliveryDescription: string;
+    iconData: SafeHtml;
+    constructor(_localizePipe: LocalizePipe, _iOne: ProductConnectorService, _iconCache: IconCacheService);
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ProductDeliveryComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ProductDeliveryComponent, "app-product-delivery", never, { "stockAndDelivery": { "alias": "stockAndDelivery"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class ProductDeliveryModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<ProductDeliveryModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<ProductDeliveryModule, [typeof ProductDeliveryComponent], [typeof i2.CommonModule, typeof i3.IconModule, typeof PipeModule], [typeof ProductDeliveryComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<ProductDeliveryModule>;
+}
+
+declare class ProductInfoTabsComponent implements OnDestroy {
+    private _appEventService;
+    activeTab: number;
+    activeTabHeight: number;
+    tabContent: ElementRef;
+    tabs: any[];
+    articleObject: ArticleFullObject;
+    set article(value: ArticleFullObject);
+    private _subs;
+    constructor(_appEventService: ProductEventService);
+    ngOnDestroy(): void;
+    updateTab(tabIndex: number): void;
+    updateHeight(tabIndex: number): void;
+    private _setupTabs;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ProductInfoTabsComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ProductInfoTabsComponent, "app-product-info-tabs", never, { "article": { "alias": "article"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class ProductAdditionalInfoComponent implements OnInit {
+    private _sanitizer;
+    private _connectorService;
+    private _changeDetector;
+    set article(value: ArticleFullObject);
+    get article(): ArticleFullObject;
+    showLabel: boolean;
+    textParts: SafeHtml[];
+    info: string;
+    private _article;
+    private _superArticles;
+    constructor(_sanitizer: DomSanitizer, _connectorService: ProductConnectorService, _changeDetector: ChangeDetectorRef);
+    ngOnInit(): void;
+    private _getTextsSuperArticle;
+    private _prepareArticleTexts;
+    private _buildInfo;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ProductAdditionalInfoComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ProductAdditionalInfoComponent, "app-product-additional-info", never, { "article": { "alias": "article"; "required": false; }; "showLabel": { "alias": "showLabel"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class ProductAdditionalInfoModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<ProductAdditionalInfoModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<ProductAdditionalInfoModule, [typeof ProductAdditionalInfoComponent], [typeof i2.CommonModule, typeof PipeModule], [typeof ProductAdditionalInfoComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<ProductAdditionalInfoModule>;
+}
+
+declare class ProductPropertiesComponent implements OnInit {
+    set article(value: ArticleFullObject);
+    get article(): ArticleFullObject;
+    showLabel: boolean;
+    properties: {
+        key: string;
+        value: string;
+    }[];
+    private _article;
+    constructor();
+    ngOnInit(): void;
+    private _prepareProperties;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ProductPropertiesComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ProductPropertiesComponent, "app-product-properties", never, { "article": { "alias": "article"; "required": false; }; "showLabel": { "alias": "showLabel"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class ProductPropertiesModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<ProductPropertiesModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<ProductPropertiesModule, [typeof ProductPropertiesComponent], [typeof i2.CommonModule, typeof PipeModule], [typeof ProductPropertiesComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<ProductPropertiesModule>;
+}
+
+declare class ProductDocumentsComponent {
+    iconCache: IconCacheService;
+    readonly icon: typeof IconEnum;
+    showLabel: boolean;
+    documents: CoDocument[];
+    constructor(iconCache: IconCacheService);
+    static ɵfac: i0.ɵɵFactoryDeclaration<ProductDocumentsComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ProductDocumentsComponent, "app-product-documents", never, { "showLabel": { "alias": "showLabel"; "required": false; }; "documents": { "alias": "documents"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class ProductDocumentModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<ProductDocumentModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<ProductDocumentModule, [typeof ProductDocumentsComponent], [typeof i2.CommonModule, typeof HeaderModule, typeof PipeModule, typeof i5.FilesUploadModule], [typeof ProductDocumentsComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<ProductDocumentModule>;
+}
+
+declare class ProductSymbolsComponent implements OnInit {
+    set symbols(value: any);
+    get symbols(): any;
+    _className: string;
+    symbolStrings: string[];
+    private _symbols;
+    constructor();
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ProductSymbolsComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ProductSymbolsComponent, "app-product-symbols", never, { "symbols": { "alias": "symbols"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class ProductSymbolsModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<ProductSymbolsModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<ProductSymbolsModule, [typeof ProductSymbolsComponent], [typeof i2.CommonModule, typeof HeaderModule, typeof PipeModule, typeof i3.ScrollContainerModule, typeof i3.TileModule], [typeof ProductSymbolsComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<ProductSymbolsModule>;
+}
+
+declare class ProductInfoTabsModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<ProductInfoTabsModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<ProductInfoTabsModule, [typeof ProductInfoTabsComponent], [typeof i2.CommonModule, typeof PipeModule, typeof ProductAdditionalInfoModule, typeof ProductPropertiesModule, typeof ProductDocumentModule, typeof ProductSymbolsModule], [typeof ProductInfoTabsComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<ProductInfoTabsModule>;
+}
+
+declare class ProductDialogComponent implements OnInit {
+    iconCache: IconCacheService;
+    private _sanitizer;
+    private _productConnectorService;
+    private _productConnectorAdapterService;
+    private _appEventService;
+    readonly icon: typeof IconEnum;
+    refType: number;
+    mainArticle: ArticleFullObject;
+    articles: ArticleListObject[];
+    closeRelatedPopup: EventEmitter<boolean>;
+    showClass(): boolean;
+    constructor(iconCache: IconCacheService, _sanitizer: DomSanitizer, _productConnectorService: ProductConnectorService, _productConnectorAdapterService: ProductConnectorAdapterService, _appEventService: ProductEventService);
+    ngOnInit(): void;
+    closeCatalog(): void;
+    protected readonly type: typeof SelectorType;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ProductDialogComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ProductDialogComponent, "co-product-dialog", never, { "refType": { "alias": "refType"; "required": false; }; "mainArticle": { "alias": "mainArticle"; "required": false; }; "articles": { "alias": "articles"; "required": false; }; }, { "closeRelatedPopup": "closeRelatedPopup"; }, never, never, false, never>;
+}
+
+declare class ProductDialogModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<ProductDialogModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<ProductDialogModule, [typeof ProductDialogComponent], [typeof i2.CommonModule, typeof PipeModule, typeof ProductRelatedModule, typeof i3.IconModule], [typeof ProductDialogComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<ProductDialogModule>;
+}
+
+declare class RenderCarouselComponent implements OnDestroy, OnChanges {
+    iconCache: IconCacheService;
+    private _appEventService;
+    private _changeDetector;
+    carousel: ElementRef;
+    showRefresh: boolean;
+    article: ArticleFullObject;
+    handleWindowResize(): void;
+    gotoNextSlide(): void;
+    gotoPrevSlide(): void;
+    resizing: boolean;
+    showLoader: boolean;
+    renderedImage: string;
+    renderedImageLoaded: boolean;
+    renderAngles: any;
+    currentRenderAngleIndex: number;
+    readonly icon: typeof IconEnum;
+    private _resizeTimer;
+    private _subs;
+    constructor(iconCache: IconCacheService, _appEventService: ProductEventService, _changeDetector: ChangeDetectorRef);
+    ngOnDestroy(): void;
+    ngOnChanges(): void;
+    onRenderLoaded(): void;
+    private _getRenderSettings;
+    private _createNewRender;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RenderCarouselComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<RenderCarouselComponent, "app-render-carousel", never, { "showRefresh": { "alias": "showRefresh"; "required": false; }; "article": { "alias": "article"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class RenderCarouselModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<RenderCarouselModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<RenderCarouselModule, [typeof RenderCarouselComponent], [typeof i2.CommonModule, typeof i3.LoaderModule, typeof i3.ScrollContainerModule, typeof i3.IconModule, typeof i3.IconCollapseHandleModule], [typeof RenderCarouselComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<RenderCarouselModule>;
+}
+
+declare class ProductPageModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<ProductPageModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<ProductPageModule, [typeof ProductPageComponent], [typeof i2.CommonModule, typeof ProductSelectorTypeModule, typeof ImageCarouselModule, typeof i3.IconModule, typeof ProductDescriptionModule, typeof ProductAdditionalDescriptionModule, typeof ProductPriceModule, typeof ProductAddtocartModule, typeof ProductRelatedModule, typeof ProductStockModule, typeof ProductDeliveryModule, typeof ProductInfoTabsModule, typeof PipeModule, typeof ProductDialogModule, typeof i3.LoaderModule, typeof RenderCarouselModule], [typeof ProductPageComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<ProductPageModule>;
+}
+
+declare class ProductScriptLoaderService {
+    private platformId;
+    private _scriptsOrLinksElements;
+    constructor(platformId: any);
+    loadScript(url: string, renderer: Renderer2): Promise<void>;
+    unloadScripts(renderer: Renderer2): void;
+    addStyleSheet(url: string, renderer: Renderer2): Promise<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ProductScriptLoaderService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ProductScriptLoaderService>;
+}
+
+declare class ProductHdComponent implements OnDestroy {
+    private _scriptLoader;
+    private _renderer;
+    set content(child: any);
+    set sku(value: string);
+    get sku(): string;
+    token: string;
+    variant: string;
+    urlParams: ExternalSourceParameter[];
+    configuratorFinished: EventEmitter<string>;
+    configurationError: EventEmitter<any>;
+    showClass: boolean;
+    hdeConfigurator: ElementRef;
+    private _sku;
+    constructor(_scriptLoader: ProductScriptLoaderService, _renderer: Renderer2);
+    ngOnDestroy(): void;
+    handleConfigurationFinished(event: CustomEvent): void;
+    handleError(event: CustomEvent): void;
+    private _prepareAttributes;
+    private _prepareConfiguratorUrls;
+    private _loadTheScripts;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ProductHdComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ProductHdComponent, "co-product-hd", never, { "sku": { "alias": "sku"; "required": false; }; "token": { "alias": "token"; "required": false; }; "variant": { "alias": "variant"; "required": false; }; "urlParams": { "alias": "urlParams"; "required": false; }; }, { "configuratorFinished": "configuratorFinished"; "configurationError": "configurationError"; }, never, never, false, never>;
+}
+
+declare class ProductHdModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<ProductHdModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<ProductHdModule, [typeof ProductHdComponent], [typeof i2.CommonModule], [typeof ProductHdComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<ProductHdModule>;
+}
+
+declare class ProductExternalSourceComponent implements OnInit, OnDestroy {
+    private _sanitizer;
+    private _productConnectorService;
+    private _appEventService;
+    sku: string;
+    catalogDefinition: CatalogDefinition;
+    set externalSource(value: ExternalSource);
+    get externalSource(): ExternalSource;
+    set externalCatalogStartupInfo(value: ExternalCatalogStartupInfo);
+    get externalCatalogStartupInfo(): ExternalCatalogStartupInfo;
+    options: {};
+    addToCart: EventEmitter<ExternalSourceArticleAddInterface>;
+    addToQuote: EventEmitter<ExternalSourceArticleAddInterface>;
+    alternativeClick: EventEmitter<ArticleListObject>;
+    configuratorFinished: EventEmitter<string>;
+    showClass(): boolean;
+    showProduct: boolean;
+    showConfigurator: boolean;
+    showSource: boolean;
+    safeUrl: SafeResourceUrl;
+    loaded: boolean;
+    externalUrl: string;
+    externalSettings: any;
+    token: string;
+    variant: string;
+    urlParams: ExternalSourceParameter[];
+    private _externalSource;
+    private _externalCatalogStartupInfo;
+    private _subs;
+    constructor(_sanitizer: DomSanitizer, _productConnectorService: ProductConnectorService, _appEventService: ProductEventService);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    handleConfigurationFinished(variantString: string): void;
+    private _prepareExternalSource;
+    private _prepareCatFarm;
+    private _prepareConfigurator;
+    private _prepareSource;
+    private switchToProduct;
+    private switchToConfigurator;
+    private switchToSource;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ProductExternalSourceComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ProductExternalSourceComponent, "co-product-external-source", never, { "sku": { "alias": "sku"; "required": false; }; "catalogDefinition": { "alias": "catalogDefinition"; "required": false; }; "externalSource": { "alias": "externalSource"; "required": false; }; "externalCatalogStartupInfo": { "alias": "externalCatalogStartupInfo"; "required": false; }; "options": { "alias": "options"; "required": false; }; }, { "addToCart": "addToCart"; "addToQuote": "addToQuote"; "alternativeClick": "alternativeClick"; "configuratorFinished": "configuratorFinished"; }, never, never, false, never>;
+}
+
+declare class ProductExternalSourceModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<ProductExternalSourceModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<ProductExternalSourceModule, [typeof ProductExternalSourceComponent], [typeof i2.CommonModule, typeof ProductPageModule, typeof ProductHdModule], [typeof ProductExternalSourceComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<ProductExternalSourceModule>;
+}
+
+declare class IoneProductModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<IoneProductModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<IoneProductModule, [typeof IoneProductComponent], [typeof i2.CommonModule, typeof ProductPageModule, typeof ProductHdModule, typeof ProductExternalSourceModule, typeof i3.ButtonModule], [typeof IoneProductComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<IoneProductModule>;
+}
+
+export { IoneProductComponent, IoneProductModule, ProductConnectorAdapterService, ProductConnectorService, ProductEventService, ProductExternalSourceComponent, ProductExternalSourceModule, ProductSettingsService, Version };