import * as i0 from '@angular/core';
import { OnDestroy, EventEmitter, OnInit, ElementRef, ChangeDetectorRef, PipeTransform, TemplateRef } from '@angular/core';
import { Subject, BehaviorSubject, Observable } from 'rxjs';
import { Options } from '@colijnit/ioneconnector/build/model/options';
import { ArticleExtendedRequest } from '@colijnit/articleapi/build/model/article-extended-request';
import { LanguageCode } from '@colijnit/ioneconnector/build/enum/language-code.enum';
import { ArticleCategory } from '@colijnit/articleapi/build/model/article-category';
import { CatalogDefinition } from '@colijnit/articleapi/build/model/catalog-definition.bo';
import { ConfiguratorStatisticsEnvironment } from '@colijnit/articleapi/build/model/configurator-statistics-environment';
import { ArticleSearchFilterSelections } from '@colijnit/articleapi/build/model/article-search-filter-selections';
import { ArticleSearchFilterMaxAndMinPrice } from '@colijnit/articleapi/build/model/article-search-filter-max-and-min-price';
import { ArticlePrice } from '@colijnit/articleapi/build/model/article-price';
import { Articles } from '@colijnit/articleapi/build/articles';
import { RelationApi } from '@colijnit/relationapi';
import { MainApi } from '@colijnit/mainapi';
import { StoreGroup } from '@colijnit/mainapi/build/model/store-group.bo';
import { CoDomainValue } from '@colijnit/mainapi/build/model/co-domain-value.bo';
import { DomainName } from '@colijnit/mainapi/build/enum/domain-name.enum';
import { RelationListObject } from '@colijnit/relationapi/build/model/relation-list-object.bo';
import { CoRVDomainValue } from '@colijnit/mainapi/build/model/co-rv-domain-value.bo';
import { Category as Category$1 } from '@colijnit/mainapi/build/model/category.bo';
import { UserGroup } from '@colijnit/mainapi/build/model/user-group.bo';
import { PriceList } from '@colijnit/transactionapi/build/model/price-list';
import { Transaction } from '@colijnit/transactionapi/build/transaction';
import { ExternalCatalogStartupInfoRequest } from '@colijnit/articleapi/build/model/external-catalog-startup-info-request';
import { ExternalCatalogStartupInfo } from '@colijnit/articleapi/build/model/external-catalog-startup-info';
import { Color } from '@colijnit/mainapi/build/model/color.bo';
import { ArticleStockSearchRequest } from '@colijnit/articleapi/build/model/article-stock-search-request';
import { ArticleExtended } from '@colijnit/articleapi/build/model/article-extended.bo';
import { ArticleStockComparisonSearchRequest } from '@colijnit/articleapi/build/model/article-stock-comparison-search-request';
import { ArticleStockTransferSearchRequest } from '@colijnit/articleapi/build/model/article-stock-transfer-search-request';
import { ObjectConfiguration } from '@colijnit/ioneconnector/build/model/object-configuration';
import { CategoryType } from '@colijnit/articleapi/build/model/category-type.bo';
import { CategoryDesign } from '@colijnit/articleapi/build/model/category-design.bo';
import { CoDocument } from '@colijnit/mainapi/build/model/co-document.bo';
import { ImageContent } from '@colijnit/mainapi/build/model/image-content.bo';
import * as i3 from '@colijnit/corecomponents_v12';
import { FilterItemViewmodel, FilterViewmodel, ContentViewMode, PromptService, BaseModuleScreenConfigService, BaseModuleService, FilterItemMode } from '@colijnit/corecomponents_v12';
import { WarehouseShort } from '@colijnit/mainapi/build/model/warehouse-short.bo';
import { ExternalSourceInfo } from '@colijnit/articleapi/build/model/external-source-info.bo';
import { BusinessObject } from '@colijnit/ioneconnector/build/model/business-object';
import { BusinessObjectIDType } from '@colijnit/ioneconnector/build/type/business-object-id-type';
import { AvaliableCatalogs } from '@colijnit/articleapi/build/model/catalogs-available.bo';
import { TurnoverGroupImage } from '@colijnit/articleapi/build/model/turnover-group-image.bo';
import * as i2 from '@angular/common';
import { SafeHtml, DomSanitizer, SafeResourceUrl } from '@angular/platform-browser';
import * as i9 from '@colijnit/sharedcomponents';
import { ArticleListObjectExtended } from '@colijnit/articleapi/build/model/article-list-object-extended.bo';
import { ExternalSourceArticleClickInterface } from '@colijnit/articleapi/build/interface/external-source-article-click.interface';
import { ExternalSourceArticleAddInterface } from '@colijnit/articleapi/build/interface/external-source-article-add.interface';

declare class Version {
    name: string;
    description: string;
    symVer: string;
    publishDate: string;
}

declare class SettingsOptions {
    showAddToCart: boolean;
    initialCategory: string;
    showPriceFilter: boolean;
    showLookAtArticleButton: boolean;
    showStockIndication: boolean;
    lookAtArticleButtonText: string;
    stockButtonText: string;
    showAddArticleButton: boolean;
    showARButton: boolean;
    maxItemsPerPage: number;
    addArticleButtonText: string;
    sortTurnoverGroupsByAlphabet: boolean;
    searchOnStart: boolean;
    showFilter: boolean;
    showNavigation: boolean;
}

declare class CatalogSettings extends Options {
    additionalTranslationFile: string;
    type: string;
    createWebOrder: boolean;
    catalogParameters: ArticleExtendedRequest;
    options: SettingsOptions;
    useLoginEncryption: boolean;
}

declare class CatalogDictionaryService {
    private readonly dictionaryUrl;
    get language(): string;
    set rootUrl(value: string);
    dictionaryLoaded: Subject<void>;
    private _dictBasePath;
    private _rootUrl;
    private _dictionaryPromise;
    private _dictionaries;
    private _language;
    private readonly _placeholder;
    getLanguageCode(lc: string): string;
    setDictionary(language: LanguageCode, additionalTranslationFile?: 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;
    private _dictionaryLoaded;
    static ɵfac: i0.ɵɵFactoryDeclaration<CatalogDictionaryService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<CatalogDictionaryService>;
}

declare class CatalogSettingsService {
    private _dictionaryService;
    set settings(value: CatalogSettings);
    get settings(): CatalogSettings;
    settingsLoaded: BehaviorSubject<boolean>;
    private _settings;
    constructor(_dictionaryService: CatalogDictionaryService);
    initializeSettings(): Promise<void>;
    createSettingsFromObject(obj: any): Promise<void>;
    settingsFinished(): Promise<void>;
    static ɵfac: i0.ɵɵFactoryDeclaration<CatalogSettingsService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<CatalogSettingsService>;
}

declare class ArticleStockSearchTileSelection extends ArticleExtended {
    brandDescription: string;
    quantity: number;
    nowAvailable: number;
}

declare class ArticlesStockSearchTileResult {
    articles: ArticleStockSearchTileSelection[];
    count: number;
}

declare class ArticleStockSearchGridSelection extends ArticleExtended {
    articleDescription: string;
    turnoverGroupNumber: string;
    supplierNumber: string;
    warehouseNumber: number;
    warehouseDescription: string;
    stockLocationNumber: string;
    stockLocationDescription: string;
    quantity: number;
    quantityInOrders: number;
    quantityInPurchaseOrders: number;
    batchNumber: string;
    serialNumber: string;
    nowAvailable: number;
}

declare class ArticlesStockSearchGridResult {
    articles: ArticleStockSearchGridSelection[];
    count: number;
}

declare class ArticleStockTransferSearchGridSelection extends ArticleExtended {
    supplierNumber: string;
    sourceWarehouseNumber: number;
    sourceLocation: string;
    targetWarehouseNumber: number;
    targetLocation: string;
    serialNumber: string;
    batchNumber: string;
    changeDate: Date;
    user: string;
    quantity: number;
}

declare class ArticleStockTransferSearchGridResult {
    articles: ArticleStockTransferSearchGridSelection[];
    count: number;
}

declare class ArticleStockTransferSearchTileSelection extends ArticleExtended {
    brandDescription: string;
    sourceWarehouseNumber: number;
    targetWarehouseNumber: number;
    quantityOverbooked: number;
}

declare class ArticleStockTransferSearchTileResult {
    articles: ArticleStockTransferSearchTileSelection[];
    count: number;
}

declare class ArticleStockComparisonSearchTileSelection extends ArticleExtended {
    brandDescription: string;
    sourceWarehouseQuantity: number;
    targetWarehouseQuantity: number;
}

declare class ArticleStockComparisonSearchTileResult {
    articles: ArticleStockComparisonSearchTileSelection[];
    count: number;
}

declare class ArticleStockComparisonSearchGridSelection extends ArticleExtended {
    supplierNumber: string;
    sourceWarehouseDescription: string;
    sourceWarehouseQuantity: number;
    targetWarehouseDescription: string;
    targetWarehouseQuantity: number;
}

declare class ArticleStockComparisonSearchGridResult {
    articles: ArticleStockComparisonSearchGridSelection[];
    count: number;
}

declare class CatalogRootService {
    set mainUrl(value: string);
    get mainUrl(): string;
    set mainSchema(value: string);
    get mainSchema(): string;
    set mainVersion(value: string);
    get mainVersion(): string;
    private _mainUrl;
    private _mainSchema;
    private _mainVersion;
    static ɵfac: i0.ɵɵFactoryDeclaration<CatalogRootService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<CatalogRootService>;
}

declare class CatalogExternalSourcesService {
    connectorsExternalSources: Articles[];
    addConnector(connector: Articles): void;
    logOutExternalSources(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CatalogExternalSourcesService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<CatalogExternalSourcesService>;
}

declare class CatalogConnectorAdapterService implements OnDestroy {
    private _catalogRootService;
    private _catalogExternalSourcesService;
    get shouldShowLoader(): boolean;
    controllerInitialized: BehaviorSubject<boolean>;
    assetPath: string;
    connector?: Articles;
    relationConnector?: RelationApi;
    mainConnector?: MainApi;
    transactionConnector: Transaction;
    private connectorOptions;
    private _boFactory;
    private _shouldShowLoader;
    private _initializing;
    private _initialized;
    constructor(_catalogRootService: CatalogRootService, _catalogExternalSourcesService: CatalogExternalSourcesService);
    ngOnDestroy(): void;
    initConnector(settings?: any, forceReload?: boolean): Promise<void>;
    getCatalogBundleSettings(url: string, upId: number): Promise<string>;
    getBundleSettings(url: string, upId: number): Promise<any>;
    getArticlesForCatalog(params: ArticleExtendedRequest, showLoader?: boolean): Promise<any>;
    getArticleCategories(publicationCode: number): Promise<ArticleCategory[]>;
    getArticlesForStockSearchTile(params: ArticleStockSearchRequest, showLoader?: boolean): Promise<ArticlesStockSearchTileResult>;
    getArticlesForStockSearchGrid(params: ArticleStockSearchRequest, showLoader?: boolean): Promise<ArticlesStockSearchGridResult>;
    getArticleGridViewExcelFile(params: ArticleStockSearchRequest, showLoader?: boolean): Promise<any[]>;
    getArticlesForStockTransferSearchTile(params: ArticleStockTransferSearchRequest, showLoader?: boolean): Promise<ArticleStockTransferSearchTileResult>;
    getArticlesForStockTransferSearchGrid(params: ArticleStockTransferSearchRequest, showLoader?: boolean): Promise<ArticleStockTransferSearchGridResult>;
    getTransferArticleGridViewExcelFile(params: ArticleStockTransferSearchRequest, showLoader?: boolean): Promise<any[]>;
    getArticlesForStockComparisonSearchTile(params: ArticleStockComparisonSearchRequest, showLoader?: boolean): Promise<ArticleStockComparisonSearchTileResult>;
    getArticlesForStockComparisonSearchGrid(params: ArticleStockComparisonSearchRequest, showLoader?: boolean): Promise<ArticleStockComparisonSearchGridResult>;
    getComparisonArticleGridViewExcelFile(params: ArticleStockComparisonSearchRequest, showLoader?: boolean): Promise<any[]>;
    getCatalogDefinitions(showLoader?: boolean): Promise<CatalogDefinition[]>;
    getExternalSource(externalSourceId: number, showLoader?: boolean): Promise<ExternalSourceInfo>;
    getCatalogFilter(params: ArticleExtendedRequest): Promise<ArticleSearchFilterSelections>;
    getPriceFilter(params: ArticleExtendedRequest): Promise<ArticleSearchFilterMaxAndMinPrice>;
    getArticleGroupsFilter(params: ArticleExtendedRequest): Promise<ArticleSearchFilterSelections>;
    getAtmosphereFilter(params: ArticleExtendedRequest): Promise<ArticleSearchFilterSelections>;
    getColorFilter(params: ArticleExtendedRequest): Promise<ArticleSearchFilterSelections>;
    getConceptFilter(params: ArticleExtendedRequest): Promise<ArticleSearchFilterSelections>;
    getDesignFilter(params: ArticleExtendedRequest): Promise<ArticleSearchFilterSelections>;
    getMainArticleFilter(params: ArticleExtendedRequest): Promise<ArticleSearchFilterSelections>;
    getMaterialFilter(params: ArticleExtendedRequest): Promise<ArticleSearchFilterSelections>;
    getTagsFilter(params: ArticleExtendedRequest): Promise<ArticleSearchFilterSelections>;
    getTurnoverGroupFilter(params: ArticleExtendedRequest): Promise<ArticleSearchFilterSelections>;
    getBrandFilter(params: ArticleExtendedRequest): Promise<ArticleSearchFilterSelections>;
    getStoreGroups(settings?: any): Promise<StoreGroup[]>;
    getCategories(settings?: any): Promise<Category$1[]>;
    getColors(): Promise<Color[]>;
    getDomainCollection(domainName: DomainName): Promise<CoDomainValue[]>;
    getRVDomainCollection(domainName: DomainName): Promise<CoRVDomainValue[]>;
    getPriceLists(): Promise<PriceList[]>;
    getUserGroups(): Promise<UserGroup[]>;
    getSuppliers(): Promise<RelationListObject[]>;
    setSuppliers(text: string): Promise<FilterItemViewmodel[]>;
    getCategoryTypes(): Promise<CategoryType[]>;
    getCategoryDesigns(): Promise<CategoryDesign[]>;
    getAvailabeCatalogsForLoggedInUser(embedded: boolean, overrideBranchId: number): Promise<any>;
    getWebViewStartupInfo(request: ExternalCatalogStartupInfoRequest): Promise<ExternalCatalogStartupInfo>;
    getSelectorArticleThumbnail(documentId: number): Promise<string>;
    getArtStockStatus(goodId: number): Promise<number>;
    getArticleStockInformation(goodId: number): Promise<number>;
    getArticlePrice(goodId: number, type: string): Promise<ArticlePrice>;
    getDocumentContent(docId: number, thumbnail?: boolean): Promise<string>;
    getGoogleTranslation(sourceLang: string, targetLang: string, list: string[]): Promise<string>;
    googleTranslateEnabled(): Promise<boolean>;
    getDefaultLanguage(upId: number): Promise<string>;
    addWebSessionTransactionLine(transactionUuid: string, sku: string, quantity: number): Promise<string>;
    getJsonArticleFlatTree(goodId: number, goodType: string, quantity: number, externalSource?: boolean, showLoader?: boolean, instanceId?: string, configuratorStatistics?: ConfiguratorStatisticsEnvironment): Promise<string>;
    getObjectConfiguration(screenCfgModule: string, params?: string | string[], insertMode?: boolean): Promise<ObjectConfiguration[]>;
    onShowLoaderChange(showLoader: boolean): void;
    getGeneratedArtDirectly(goodId: number, showLoader: boolean): Promise<number>;
    getImageForCoDocument(document: CoDocument, thumb: boolean): Promise<ImageContent>;
    getWarehouses(): Promise<WarehouseShort[]>;
    static ɵfac: i0.ɵɵFactoryDeclaration<CatalogConnectorAdapterService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<CatalogConnectorAdapterService>;
}

declare class CacheField<T> {
    readonly onLoad: EventEmitter<any>;
    get value(): T;
    set value(value: T);
    get isLoaded(): boolean;
    get isLoading(): boolean;
    get loadNeverCalled(): boolean;
    loadFunction: (params?: any) => Promise<T>;
    private _promiseValue;
    private _value;
    private _isLoaded;
    constructor();
    getValue(forceReload?: boolean): Promise<T>;
    setValue(value: any): void;
    /**
     * POSTCONDITION: The .value of this cache field contains the loaded value as fetched by the resolve data of its .loadFunction.
     * Will load only once, consecutive calls will resolve immediately or wait until the first original database fetch was finished.
     * @returns {Promise<any>} Postcondition holds after resolve
     */
    ensureLoaded(forceReload?: boolean): Promise<T>;
    reload(): Promise<T>;
    reset(): void;
    private _load;
}

declare class ParameterCacheField<T> {
    loadFunction: (...params: any[]) => Promise<T>;
    private _paramsToCacheItems;
    constructor();
    getValue(...params: any[]): Promise<T>;
    setValue(value: any, ...params: any[]): void;
    reload(...params: any[]): Promise<T>;
    reset(...params: any[]): void;
    private _getCacheField;
    private _makeNewCacheField;
}

/**
 * App-wide, top-level, 'dumb' BO cache manager service. It stores and returns simple and parameterized business object cache items.
 *
 * Several other services register cache items onto this manager, such as repositories or the more generic SelectMultipleSimpleCacheService.
 *
 * This is a dumb cache manager. It just functions as a point to add and retrieve generic cache items, but does not know how to actually
 * LOAD these cache items from the database, or what exact types the items are.
 *
 * All caches are reset when the user logs out.
 */
declare class CatalogBusinessObjectCacheManagerService {
    readonly reset: Subject<void>;
    private static _NullBoId;
    private _selectMultipleCache;
    private _selectMultipleParameterizedCache;
    private _selectSingleCache;
    private _selectSingleParameterizedCache;
    /**
     * Creates and adds a new simple cache item for the given key with the given load function.
     * @param key
     * @param loadFunction e.g. () => { return this._dataService.selectMultiple(Color); }
     * @param overrideOld Whether to allow an old cache item with the same key to become override by this newly created cache item.
     * @returns The newly created cache item.
     */
    addNewSelectMultipleCacheItem<T extends BusinessObject>(key: any, loadFunction: () => Promise<T[]>, overrideOld?: boolean): CacheField<T[]>;
    addNewSelectSingleCacheItem<T extends BusinessObject>(key: {
        new (): T;
    }, id: BusinessObjectIDType, loadFunction: () => Promise<T>, overrideOld?: boolean): CacheField<T>;
    addNewSelectSingleParameterizedCacheItem<T extends Object>(key: any, loadFunction: (params?: any) => Promise<T>, overrideOld?: boolean): ParameterCacheField<T>;
    /**
     * Creates and adds a new parameterized cache item for the given key with the given load function.
     * @param key
     * @param loadFunction e.g. (category: ArticleCategory) => { return this._dataService.selectMultiple(TurnoverGroupImage, category); }
     * @param overrideOld Whether to allow an old cache item with the same key to become override by this newly created cache item.
     */
    addNewSelectMultipleParameterizedCacheItem<T extends BusinessObject>(key: any, loadFunction: (params?: any) => Promise<T[]>, overrideOld?: boolean): ParameterCacheField<T[]>;
    hasSelectMultipleCacheItem(key: any): boolean;
    hasSingleCacheItem<T extends BusinessObject>(key: {
        new (): T;
    }, id?: BusinessObjectIDType): boolean;
    hasSelectMultipleParameterizedCacheItem(key: any): boolean;
    hasSelectSingleParameterizedCacheItem(key: any): boolean;
    getSelectMultipleCacheItem<T extends BusinessObject>(key: any): CacheField<T[]>;
    getSingleCacheItem<T extends BusinessObject>(key: {
        new (): T;
    }, id?: BusinessObjectIDType): CacheField<T>;
    getSelectMultipleParameterCacheItem<T extends BusinessObject>(key: any): ParameterCacheField<T[]>;
    getSelectSingleParameterCacheItem<T>(key: any): ParameterCacheField<T>;
    private _reset;
    static ɵfac: i0.ɵɵFactoryDeclaration<CatalogBusinessObjectCacheManagerService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<CatalogBusinessObjectCacheManagerService>;
}

declare class CatalogSelectSingleCacheService {
    private _boCacheManager;
    constructor(_boCacheManager: CatalogBusinessObjectCacheManagerService);
    requestCache<T extends BusinessObject>(clazz: {
        new (): T;
    }, sourceId: BusinessObjectIDType, loadFunction: () => Promise<T>): CacheField<T>;
    private _createCacheItem;
    static ɵfac: i0.ɵɵFactoryDeclaration<CatalogSelectSingleCacheService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<CatalogSelectSingleCacheService>;
}

declare class CatalogSelectMultipleCacheService {
    private _boCacheManager;
    private static _NullCache;
    constructor(_boCacheManager: CatalogBusinessObjectCacheManagerService);
    /**
     * Returns the global cache item for the select multiple of the given business object class. Creates a new cache item if not yet exists.
     * @param clazz The BO class, e.g. CustomerFullObject
     * @returns {CacheField<T[]>}
     */
    requestCache<T extends BusinessObject>(clazz: typeof BusinessObject, loadFunction: () => Promise<T[]>): CacheField<T[]>;
    private _createCacheItem;
    static ɵfac: i0.ɵɵFactoryDeclaration<CatalogSelectMultipleCacheService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<CatalogSelectMultipleCacheService>;
}

declare class CatalogSelectMultipleParameterizedCacheService implements OnDestroy {
    private _boCacheManager;
    readonly reset: Subject<void>;
    private _subs;
    constructor(_boCacheManager: CatalogBusinessObjectCacheManagerService);
    ngOnDestroy(): void;
    /**
     * Returns the global cache item for the parameterized select multiple of the given business object class. Creates a new cache item if not yet exists.
     * @param clazz The BO class, used for undeflying dataService.selectMultiple(clazz) call.
     * @returns {CacheField<T[]>}
     */
    requestCache<T extends BusinessObject>(clazz: typeof BusinessObject, loadFunction: (...params: any) => Promise<T[]>): ParameterCacheField<T[]>;
    private _createParameterizedCacheItem;
    static ɵfac: i0.ɵɵFactoryDeclaration<CatalogSelectMultipleParameterizedCacheService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<CatalogSelectMultipleParameterizedCacheService>;
}

declare class CatalogSelectSingleParameterizedCacheService implements OnDestroy {
    private _boCacheManager;
    readonly reset: Subject<void>;
    private _subs;
    constructor(_boCacheManager: CatalogBusinessObjectCacheManagerService);
    ngOnDestroy(): void;
    /**
     * Returns the global cache item for the parameterized select single of the given business object class. Creates a new cache item if not yet exists.
     * @param clazz The BO class, used for undeflying dataService.selectSingle(clazz) call.
     * @returns {CacheField<T>}
     */
    requestCache<T>(clazz: any, loadFunction: (...params: any) => Promise<T>): ParameterCacheField<T>;
    private _createParameterizedCacheItem;
    static ɵfac: i0.ɵɵFactoryDeclaration<CatalogSelectSingleParameterizedCacheService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<CatalogSelectSingleParameterizedCacheService>;
}

declare class CatalogConnectorService {
    private _adapterService;
    private _selectSingleCacheService;
    private _selectMultipleCacheService;
    private _selectMultipleParameterizedCacheService;
    private _selectSingleParameterizedCacheService;
    private _boFactory;
    constructor(_adapterService: CatalogConnectorAdapterService, _selectSingleCacheService: CatalogSelectSingleCacheService, _selectMultipleCacheService: CatalogSelectMultipleCacheService, _selectMultipleParameterizedCacheService: CatalogSelectMultipleParameterizedCacheService, _selectSingleParameterizedCacheService: CatalogSelectSingleParameterizedCacheService);
    initConnector(settings?: any, forceReload?: boolean): Promise<void>;
    getCatalogBundleSettings(url: string, upId: number): Promise<string>;
    getBundleSettings(url: string, upId: number): Promise<any>;
    getArticlesForCatalog(params: ArticleExtendedRequest, showLoader?: boolean): Promise<any>;
    getArticleCategories(publicationCode: number): Promise<ArticleCategory[]>;
    getArticlesForStockSearchTile(params: ArticleStockSearchRequest, showLoader?: boolean): Promise<ArticlesStockSearchTileResult>;
    getArticlesForStockSearchGrid(params: ArticleStockSearchRequest, showLoader?: boolean): Promise<ArticlesStockSearchGridResult>;
    getArticleGridViewExcelFile(params: ArticleStockSearchRequest, showLoader?: boolean): Promise<any[]>;
    getArticlesForStockTransferSearchTile(params: ArticleStockTransferSearchRequest, showLoader?: boolean): Promise<ArticleStockTransferSearchTileResult>;
    getArticlesForStockTransferSearchGrid(params: ArticleStockTransferSearchRequest, showLoader?: boolean): Promise<ArticleStockTransferSearchGridResult>;
    getTransferArticleGridViewExcelFile(params: ArticleStockTransferSearchRequest, showLoader?: boolean): Promise<any[]>;
    getArticlesForStockComparisonSearchTile(params: ArticleStockComparisonSearchRequest, showLoader?: boolean): Promise<ArticleStockComparisonSearchTileResult>;
    getArticlesForStockComparisonSearchGrid(params: ArticleStockComparisonSearchRequest, showLoader?: boolean): Promise<ArticleStockComparisonSearchGridResult>;
    getComparisonArticleGridViewExcelFile(params: ArticleStockComparisonSearchRequest, showLoader?: boolean): Promise<any[]>;
    getCatalogDefinitions(showLoader?: boolean): Promise<CatalogDefinition[]>;
    getExternalSource(externalSourceId: number, showLoader?: boolean): Promise<ExternalSourceInfo>;
    getCatalogFilter(params: ArticleExtendedRequest): Promise<ArticleSearchFilterSelections>;
    getPriceFilter(params: ArticleExtendedRequest): Promise<ArticleSearchFilterMaxAndMinPrice>;
    getArticleGroupsFilter(params: ArticleExtendedRequest): Promise<ArticleSearchFilterSelections>;
    getAtmosphereFilter(params: ArticleExtendedRequest): Promise<ArticleSearchFilterSelections>;
    getColorFilter(params: ArticleExtendedRequest): Promise<ArticleSearchFilterSelections>;
    getConceptFilter(params: ArticleExtendedRequest): Promise<ArticleSearchFilterSelections>;
    getDesignFilter(params: ArticleExtendedRequest): Promise<ArticleSearchFilterSelections>;
    getMainArticleFilter(params: ArticleExtendedRequest): Promise<ArticleSearchFilterSelections>;
    getMaterialFilter(params: ArticleExtendedRequest): Promise<ArticleSearchFilterSelections>;
    getTagsFilter(params: ArticleExtendedRequest): Promise<ArticleSearchFilterSelections>;
    getTurnoverGroupFilter(params: ArticleExtendedRequest): Promise<ArticleSearchFilterSelections>;
    getBrandFilter(params: ArticleExtendedRequest): Promise<ArticleSearchFilterSelections>;
    getArtStockStatus(goodId: number): Promise<number>;
    getArticleStockInformation(goodId: number): Promise<number>;
    getArticlePrice(goodId: number, type: string): Promise<ArticlePrice>;
    getStoreGroups(): Promise<StoreGroup[]>;
    getCategories(): Promise<Category$1[]>;
    getColors(): Promise<Color[]>;
    getDomainCollection(domainName: DomainName): Promise<CoDomainValue[]>;
    getRVDomainCollection(domainName: DomainName): Promise<CoRVDomainValue[]>;
    getPriceLists(): Promise<PriceList[]>;
    getUserGroups(): Promise<UserGroup[]>;
    getSuppliers(): Promise<RelationListObject[]>;
    getCategoryTypes(): Promise<CategoryType[]>;
    getCategoryDesigns(): Promise<CategoryDesign[]>;
    getAvailabeCatalogsForLoggedInUser(embedded: boolean, overrideBranchId: number): Promise<AvaliableCatalogs[]>;
    getWebViewStartupInfo(request: ExternalCatalogStartupInfoRequest): Promise<ExternalCatalogStartupInfo>;
    getDocumentContent(docId: number, thumbnail?: boolean): Promise<string>;
    getGoogleTranslation(sourceLang: string, targetLang: string, list: string[]): Promise<string>;
    googleTranslateEnabled(): Promise<boolean>;
    getDefaultLanguage(upId: number): Promise<string>;
    getJsonArticleFlatTree(goodId: number, goodType: string, quantity: number, externalSource?: boolean, showLoader?: boolean, instanceId?: string, configuratorStatistics?: ConfiguratorStatisticsEnvironment): Promise<string>;
    addWebSessionTransactionLine(transactionUuid: string, sku: string, quantity: number): Promise<string>;
    getGeneratedArtDirectly(goodId: number, showLoader?: boolean): Promise<number>;
    getImageForCoDocument(document: CoDocument, thumb?: boolean): Promise<ImageContent>;
    getWarehouses(): Promise<WarehouseShort[]>;
    static ɵfac: i0.ɵɵFactoryDeclaration<CatalogConnectorService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<CatalogConnectorService>;
}

declare class ExternalSourceViewmodel {
    catalogDefinition: CatalogDefinition;
    externalSource: ExternalSourceInfo;
    constructor(catalog: CatalogDefinition, source: ExternalSourceInfo);
}

declare class CatalogOptionsService implements OnDestroy {
    private _dictionary;
    private _settingsService;
    parametersSet: BehaviorSubject<boolean>;
    brandFilter: number[];
    private _parameters;
    private _subs;
    constructor(_dictionary: CatalogDictionaryService, _settingsService: CatalogSettingsService);
    ngOnDestroy(): void;
    get showBrandFilter(): boolean;
    get showPriceFilter(): boolean;
    get showAddArticleButton(): boolean;
    get showStockIndication(): boolean;
    get showLookAtArticleButton(): boolean;
    get showARButton(): boolean;
    get addArticleButtonText(): string;
    get lookAtArticleButtonText(): string;
    get stockButtonText(): string;
    get sortTurnoverGroupsByAlphabet(): boolean;
    get showFilter(): boolean;
    set parameters(value: ArticleExtendedRequest);
    get parameters(): ArticleExtendedRequest;
    static ɵfac: i0.ɵɵFactoryDeclaration<CatalogOptionsService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<CatalogOptionsService>;
}

declare class CatalogImageService {
    private _iOneController;
    private _articleImages;
    private _externalSourceImages;
    private _categoryImages;
    private _turnoverGroupImages;
    constructor(_iOneController: CatalogConnectorService);
    getExternalSourceImage(catalogDef: CatalogDefinition): Promise<void>;
    getCategoryImage(category: ArticleCategory): Promise<void>;
    getTurnoverGroupImage(turnoverGroup: TurnoverGroupImage): Promise<void>;
    getArticleImage(article: ArticleExtended): Promise<void>;
    static ɵfac: i0.ɵɵFactoryDeclaration<CatalogImageService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<CatalogImageService>;
}

declare class CatalogFilterViewmodel extends FilterViewmodel {
    filterName: string;
    templateFilterName: string;
}

declare class CatalogFilterService {
    private _iOneController;
    priceMinFilter: number;
    priceMaxFilter: number;
    lengthMinFilter: number;
    lengthMaxFilter: number;
    widthMinFilter: number;
    widthMaxFilter: number;
    heightMinFilter: number;
    heightMaxFilter: number;
    depthMinFilter: number;
    depthMaxFilter: number;
    filters: CatalogFilterViewmodel[];
    readonly filterItemMap: Map<string, string>;
    readonly filterItemConfigMap: Map<string, string>;
    constructor(_iOneController: CatalogConnectorService);
    getFilters(filters: ArticleExtendedRequest): void;
    createNewFiltersAndCopySelections(filter: ArticleSearchFilterSelections, key: string): CatalogFilterViewmodel;
    getFilterItemMap(key: string): string;
    getFilterItemConfigMap(key: string): string;
    createFilterSelectionsCollection(collection: any[], id: string, description: string): FilterItemViewmodel[];
    createFilterSelectionsSupplierCollection(collection: RelationListObject[]): FilterItemViewmodel[];
    static ɵfac: i0.ɵɵFactoryDeclaration<CatalogFilterService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<CatalogFilterService>;
}

declare class CatalogSearchService implements OnDestroy {
    private _filterService;
    private _catalogConnectorService;
    private _catalogConnectorAdapterService;
    private _settingsService;
    private _optionService;
    private _promptService;
    searchRequest: ArticleExtendedRequest;
    activeContentViewMode: ContentViewMode;
    showFilterSidebar: boolean;
    articles: ArticleExtended[];
    set clearCacheObservable(value: Observable<any>);
    set general(value: string);
    get general(): string;
    set turnoverGroup(value: string);
    get turnoverGroup(): string;
    set category(value: string);
    get category(): string;
    articlesPerPage: number;
    resultCount: number;
    get currentPage(): number;
    set currentPage(value: number);
    private _clearCacheObservable;
    private _clearCacheSubscription;
    private _currentPage;
    private _category;
    private _turnoverGroup;
    private _subs;
    constructor(_filterService: CatalogFilterService, _catalogConnectorService: CatalogConnectorService, _catalogConnectorAdapterService: CatalogConnectorAdapterService, _settingsService: CatalogSettingsService, _optionService: CatalogOptionsService, _promptService: PromptService);
    ngOnDestroy(): void;
    searchArticles(resetPaging?: boolean): void;
    resetFilters(search?: boolean): void;
    toggleFilter(): void;
    handleHideFilter(): void;
    handleResetFilter(): void;
    private _clearCache;
    private _resetRequest;
    private _setRequestParametersAndProps;
    private _resetRequestParametersAndProps;
    static ɵfac: i0.ɵɵFactoryDeclaration<CatalogSearchService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<CatalogSearchService>;
}

declare class CatalogScreenConfigurationService extends BaseModuleScreenConfigService {
    private _catalogAdapterService;
    readonly screenModuleName: string;
    private _screenConfigurationObjectCache;
    constructor(_catalogAdapterService: CatalogConnectorAdapterService);
    clear(): void;
    protected loadConfigForModule(params: string[], insertRights?: boolean): Promise<ObjectConfiguration[]>;
    private _setScreenConfigurationObjectCache;
    private _screenConfigurationLoaded;
    static ɵfac: i0.ɵɵFactoryDeclaration<CatalogScreenConfigurationService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<CatalogScreenConfigurationService>;
}

declare class CatalogService extends BaseModuleService {
    protected connector: CatalogConnectorService;
    protected connectorAdapter: CatalogConnectorAdapterService;
    protected screenConfigService: CatalogScreenConfigurationService;
    settingsService: CatalogSettingsService;
    private optionsService;
    private _imageService;
    private _filterService;
    private _catalogSearchService;
    private _catalogRootService;
    externalSourceChanged: BehaviorSubject<boolean>;
    controllerInitialized: BehaviorSubject<boolean>;
    set externalSourceUrl(url: string);
    set ioneSourceUrl(url: string);
    get externalSourceUrl(): string;
    articleSearchFilters: ArticleExtendedRequest;
    articlesOnShowcase: ArticleExtended[];
    showcaseTitle: string;
    articlesPerPage: number;
    showExternalSource: boolean;
    showCatOrTurnoverGroupArticles: boolean;
    showIoneSource: boolean;
    listMode: boolean;
    webMode: boolean;
    get catalogShown(): boolean;
    set catalogShown(value: boolean);
    filteredArticlesOnShowcase: ArticleExtended[];
    externalSourceViewModels: ExternalSourceViewmodel[];
    get itemsFiltered(): boolean;
    categoryChanged: Subject<string>;
    turnoverGroupChanged: Subject<string>;
    searchTextChanged: Subject<string[]>;
    showPageChanged: Subject<number>;
    onResetFilters: Subject<void>;
    activeStockViewSubject: BehaviorSubject<StockView>;
    activeStockView: any;
    resultCount: number;
    get currentPage(): number;
    protected _readonly: boolean;
    private _currentPage;
    private _filterText;
    private _category;
    private _turnoverGroup;
    private _externalSourceUrl;
    private _filterTimeout;
    private _searchTimer;
    private doArticleSearchThrottledFunc;
    private readonly minMillisBetweenArticleSearches;
    private _catalogShown;
    private _controllerInitialized;
    private _subs;
    private _currentOrderBy;
    constructor(connector: CatalogConnectorService, connectorAdapter: CatalogConnectorAdapterService, screenConfigService: CatalogScreenConfigurationService, settingsService: CatalogSettingsService, optionsService: CatalogOptionsService, _imageService: CatalogImageService, _filterService: CatalogFilterService, _catalogSearchService: CatalogSearchService, _catalogRootService: CatalogRootService);
    ngOnDestroy(): void;
    init(settings: any, forceReload?: boolean): Promise<void>;
    initConnector(settings: any, forceReload?: boolean): Promise<void>;
    getCategories(): Promise<ArticleCategory[]>;
    prepareTurnoverGroupImage(group: TurnoverGroupImage): Promise<void>;
    reset(): void;
    setActiveStockView(value: StockView): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CatalogService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<CatalogService>;
}
declare enum StockView {
    PriceCards = "PriceCards",
    StockOverview = "StockOverview",
    WarehouseTransfers = "WarehouseTransfers",
    StockComparison = "StockComparison"
}

declare class CatalogCategoriesComponent implements OnInit, OnDestroy {
    private _catalogService;
    private _adapterService;
    showTurnoverGroups: boolean;
    categoryClick: EventEmitter<string>;
    turnoverGroupClick: EventEmitter<string>;
    parentForOverlay: ElementRef;
    showClass(): boolean;
    categories: ArticleCategory[];
    turnoverGroups: TurnoverGroupImage[];
    private _subs;
    constructor(_catalogService: CatalogService, _adapterService: CatalogConnectorAdapterService);
    ngOnInit(): void;
    ngOnDestroy(): void;
    getCategories(): Promise<void>;
    prepareTurnoverGroups(): void;
    handleCategoryClick(event: MouseEvent, category: string): void;
    handleTurnoverGroupClick(event: MouseEvent, turnovergroupNr: string): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CatalogCategoriesComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CatalogCategoriesComponent, "co-catalog-categories", never, { "showTurnoverGroups": { "alias": "showTurnoverGroups"; "required": false; }; "parentForOverlay": { "alias": "parentForOverlay"; "required": false; }; }, { "categoryClick": "categoryClick"; "turnoverGroupClick": "turnoverGroupClick"; }, never, never, false, never>;
}

/** AUTO GENERATED FILE. DO NOT CHANGE.. **/
declare enum IconEnum {
    AddToCartDrop = "add_to_cart_drop",
    Ar = "ar",
    ArrowScrollDown = "arrow_scroll_down",
    ArrowScrollLeft = "arrow_scroll_left",
    BarsFilter = "bars_filter",
    BarsRegularFull = "bars_regular_full",
    BarsSolidFull = "bars_solid_full",
    Camera = "camera",
    Cancel = "cancel",
    Check = "check",
    ChevronRightRegular = "chevron_right_regular",
    Close = "close",
    CloudLightFull = "cloud_light_full",
    CloudSolidFull = "cloud_solid_full",
    Eye = "eye",
    Filter = "filter",
    FilterCircleLarge = "filter_circle_large",
    GridView = "grid_view",
    Hamburger = "hamburger",
    ListView = "list_view",
    MagicWand = "magic_wand",
    Refresh = "refresh",
    Search = "search",
    SyncAlt = "sync_alt",
    ThickLines = "thick_lines",
    ThinLines = "thin_lines",
    ThreeD = "three_d",
    TileView = "tile_view",
    Truck = "truck",
    WandMagicSparklesLight = "wand_magic_sparkles_light",
    WebCatalog = "web_catalog",
    WirelessSolidFull = "wireless_solid_full"
}

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 enum ConfigNameEnum {
    GeneralHeader = "generalHeader",
    PurchaseHeader = "purchaseHeader",
    LogisticsHeader = "logisticsHeader",
    ArticleNumberFilter = "articleNumberFilter",
    BarcodeFilter = "barcodeFilter",
    PriceFilter = "priceFilter",
    LengthFilter = "lengthFilter",
    WidthFilter = "widthFilter",
    HeightFilter = "heightFilter",
    DepthFilter = "depthFilter",
    ArticleTypeFilter = "articleTypeFilter",
    ArticleGroupFilter = "articleGroupFilter",
    ColorFilter = "colorFilter",
    DeliveryDateFilter = "deliveryDateFilter",
    RetailFormulaFilter = "retailFormulaFilter",
    InOutFilter = "inOutFilter",
    PublishFilter = "publishFilter",
    SellViaFilter = "sellViaFilter",
    CategoryFilter = "categoryFilter",
    CategoryTypeFilter = "categoryTypeFilter",
    CategoryDesignFilter = "categoryDesignFilter",
    SupplierFilter = "supplierFilter",
    ArtNrSupplierFilter = "artNrSupplierFilter",
    ReferenceFilter = "referenceFilter",
    PricelistPurchaseFilter = "pricelistPurchaseFilter",
    SerialNumberFilter = "serialNumberFilter",
    BatchNumberFilter = "batchNumberFilter",
    DateModifiedFilter = "dateModifiedFilter",
    UpdateDateFilter = "updateDateFilter",
    StockMutationFilter = "stockMutationFilter",
    WarehouseFilter = "warehouseFilter",
    StockStateFilter = "stockStateFilter",
    SourceWarehouseFilter = "sourceWarehouseFilter",
    TargetWarehouseFilter = "targetWarehouseFilter",
    PricelistSalesFilter = "pricelistSalesFilter",
    ArticleKindFilter = "articleKindFilter",
    ActiveFilter = "activeFilter",
    InStockFilter = "inStockFilter",
    SphereCodeFilter = "sphereCodeFilter",
    ConceptFilter = "conceptFilter",
    DesignCodeFilter = "designCodeFilter",
    MaterialFilter = "materialFilter",
    TagFilter = "tagFilter",
    TurnoverGroupFilter = "turnoverGroupFilter",
    BrandFilter = "brandFilter",
    GoodKindFilter = "goodKindFilter",
    ResultTiles = "resultSetting",
    PurchaseDescriptionFilter = "purchaseDescriptionFilter"
}

interface Category {
    name: string;
    cfgName: ConfigNameEnum;
}

interface FilterOrder {
    name: string;
    order: number;
}

declare class CatalogFilterComponent implements OnInit, OnDestroy {
    iconCache: IconCacheService;
    catalogService: CatalogService;
    searchService: CatalogSearchService;
    private _settingsService;
    private changeDetector;
    private _catalogConnectorService;
    private _adapterService;
    readonly icons: typeof IconEnum;
    filterItems: ElementRef;
    generalFilter: ElementRef;
    purchaseFilter: ElementRef;
    logisticsFilter: ElementRef;
    generalFilterOrders: FilterOrder[];
    purchaseFilterOrders: FilterOrder[];
    logisticsFilterOrders: FilterOrder[];
    showResetFilter: boolean;
    showSavePopup: boolean;
    showClass(): boolean;
    filterCategories: Category[];
    userGroupsChosen: UserGroup[];
    activeStockView: StockView;
    userGroupCollection: UserGroup[];
    updatePreset: boolean;
    private _subs;
    private _destroyed;
    constructor(iconCache: IconCacheService, catalogService: CatalogService, searchService: CatalogSearchService, _settingsService: CatalogSettingsService, changeDetector: ChangeDetectorRef, _catalogConnectorService: CatalogConnectorService, _adapterService: CatalogConnectorAdapterService);
    ngOnInit(): void;
    ngOnDestroy(): void;
    handleCategoryClick(cat: Category): void;
    private getUserGroups;
    private _showActiveCategory;
    private detectChanges;
    static ɵfac: i0.ɵɵFactoryDeclaration<CatalogFilterComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CatalogFilterComponent, "co-catalog-filter", never, { "generalFilterOrders": { "alias": "generalFilterOrders"; "required": false; }; "purchaseFilterOrders": { "alias": "purchaseFilterOrders"; "required": false; }; "logisticsFilterOrders": { "alias": "logisticsFilterOrders"; "required": false; }; "showResetFilter": { "alias": "showResetFilter"; "required": false; }; }, {}, never, never, false, never>;
}

declare class CatalogFilterCategoriesComponent {
    set categories(value: Category[]);
    get categories(): Category[];
    categoryClick: EventEmitter<Category>;
    showClass(): boolean;
    activeCategory: Category;
    private _categories;
    handleCategoryClick(category: Category): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CatalogFilterCategoriesComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CatalogFilterCategoriesComponent, "co-catalog-filter-categories", never, { "categories": { "alias": "categories"; "required": false; }; }, { "categoryClick": "categoryClick"; }, never, never, false, never>;
}

declare class CatalogLocalizePipe implements PipeTransform {
    private _dictionaryService;
    constructor(_dictionaryService: CatalogDictionaryService);
    transform(value: string, upperCaseFirst?: boolean, replace?: string | string[]): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<CatalogLocalizePipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<CatalogLocalizePipe, "caLocalize", 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 GreaterThanZeroPipe implements PipeTransform {
    transform(items: any[], field: string): any;
    static ɵfac: i0.ɵɵFactoryDeclaration<GreaterThanZeroPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<GreaterThanZeroPipe, "greaterThanZero", false>;
}

declare class GoogleTranslateService implements OnDestroy {
    private _settingsService;
    private _connectorService;
    private _connectorAdapterService;
    private _clientLanguage;
    private _defaultLanguage;
    private _translations;
    private _initialized;
    private _initializedSubject;
    private _connectionSubject;
    protected googleApiEnabled: boolean;
    constructor(_settingsService: CatalogSettingsService, _connectorService: CatalogConnectorService, _connectorAdapterService: CatalogConnectorAdapterService);
    ngOnDestroy(): void;
    getTranslation(input: string): Promise<string>;
    static ɵfac: i0.ɵɵFactoryDeclaration<GoogleTranslateService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<GoogleTranslateService>;
}

declare class GoogleTranslatePipe implements PipeTransform {
    private _googleTranslateService;
    constructor(_googleTranslateService: GoogleTranslateService);
    transform(value: string): Observable<string>;
    static ɵfac: i0.ɵɵFactoryDeclaration<GoogleTranslatePipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<GoogleTranslatePipe, "googleTranslate", false>;
}

declare class CatalogPipeModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<CatalogPipeModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<CatalogPipeModule, [typeof CatalogLocalizePipe, typeof PriceDisplayPipe, typeof GreaterThanZeroPipe, typeof GoogleTranslatePipe], [typeof i2.CommonModule], [typeof CatalogLocalizePipe, typeof PriceDisplayPipe, typeof GreaterThanZeroPipe, typeof GoogleTranslatePipe]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<CatalogPipeModule>;
}

declare class CatalogFilterCategoriesModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<CatalogFilterCategoriesModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<CatalogFilterCategoriesModule, [typeof CatalogFilterCategoriesComponent], [typeof i2.CommonModule, typeof CatalogPipeModule, typeof i3.ScreenConfigurationModule], [typeof CatalogFilterCategoriesComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<CatalogFilterCategoriesModule>;
}

declare class CatalogFilterContentGeneralComponent implements OnInit, OnDestroy {
    iconCache: IconCacheService;
    filterService: CatalogFilterService;
    catalogSearchService: CatalogSearchService;
    private _catalogConnectorService;
    private _adapterService;
    filterOrders: FilterOrder[];
    showClass(): boolean;
    readonly icons: typeof IconEnum;
    readonly cfgName: typeof ConfigNameEnum;
    readonly modes: typeof FilterItemMode;
    private _subs;
    storeGroupCollection: FilterItemViewmodel[];
    inOutCollectionCollection: FilterItemViewmodel[];
    articleTypeCollection: FilterItemViewmodel[];
    artPublicationCollection: FilterItemViewmodel[];
    artPublicationSalesCollection: FilterItemViewmodel[];
    priceListsSalesCollection: FilterItemViewmodel[];
    categoryCollection: FilterItemViewmodel[];
    colorCollection: FilterItemViewmodel[];
    doSyncCollection: FilterItemViewmodel[];
    categoryTypes: FilterItemViewmodel[];
    categoryDesigns: FilterItemViewmodel[];
    articleGroupCollection: FilterItemViewmodel[];
    sphereCollection: FilterItemViewmodel[];
    conceptCollection: FilterItemViewmodel[];
    designCollection: FilterItemViewmodel[];
    materialCollection: FilterItemViewmodel[];
    tagCollection: FilterItemViewmodel[];
    turnoverGroupCollection: FilterItemViewmodel[];
    brandCollection: FilterItemViewmodel[];
    constructor(iconCache: IconCacheService, filterService: CatalogFilterService, catalogSearchService: CatalogSearchService, _catalogConnectorService: CatalogConnectorService, _adapterService: CatalogConnectorAdapterService);
    ngOnInit(): void;
    ngOnDestroy(): void;
    handleAllChanged(value: boolean): void;
    onRangePriceChanged(priceRange: string): void;
    private _setCollections;
    private _setStoreGroups;
    private _setInOutCollection;
    private _setArticleTypes;
    private _setCategories;
    private _setDoSyncValues;
    private _setColors;
    private _setPublicationCodes;
    private _setPublicationCodesSales;
    private _setCategoryTypes;
    private _setCategoryDesigns;
    private _setPriceList;
    _setProductGroupOptions(): void;
    _setSphereOptions(): void;
    _setConceptOptions(): void;
    _setDesignOptions(): void;
    _setMaterialOptions(): void;
    _setTagOptions(): void;
    _setTurnoverGroupOptions(): void;
    _setBrandOptions(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CatalogFilterContentGeneralComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CatalogFilterContentGeneralComponent, "co-catalog-filter-content-general", never, { "filterOrders": { "alias": "filterOrders"; "required": false; }; }, {}, never, never, false, never>;
}

declare class CatalogEventService {
    lookAtArticleButtonClick: Subject<ArticleExtended>;
    addArticleButtonClick: Subject<string | ArticleExtended>;
    arButtonClick: Subject<ArticleExtended>;
    articleClick: Subject<ArticleExtended>;
    stockDetailsClick: Subject<ArticleExtended>;
    onArticleCheckboxClicked: Subject<{
        article: ArticleExtended;
        selected: boolean;
    }>;
    scrollToTopRequested: Subject<void>;
    static ɵfac: i0.ɵɵFactoryDeclaration<CatalogEventService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<CatalogEventService>;
}

declare class CatalogFilterItemComponent implements OnInit, OnDestroy {
    searchService: CatalogSearchService;
    private _screenConfigService;
    private _eventService;
    filterOrders: FilterOrder[];
    model: any;
    mode: FilterItemMode;
    collection: any[];
    placeholder: string;
    customContent: boolean;
    singleSelect: boolean;
    expanded: boolean;
    minSearchCharsToLoadCollection: number;
    initialLimit: number;
    sliderDefaultMin: number;
    sliderDefaultMax: number;
    searchCollectionPlaceholder: string;
    collectionLoadFn: Function;
    stockViewFilter: boolean;
    modelChange: EventEmitter<any>;
    collectionChange: EventEmitter<any>;
    filterButtonClicked: EventEmitter<void>;
    screenConfigurationObjectName: string;
    order: number;
    searchPlaceholder: string;
    noResultsLabel: string;
    showMoreLabel: string;
    showLessLabel: string;
    filterButtonLabel: string;
    private _subs;
    constructor(searchService: CatalogSearchService, _screenConfigService: CatalogScreenConfigurationService, _eventService: CatalogEventService);
    ngOnInit(): void;
    ngOnDestroy(): void;
    onFilterButtonClicked(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CatalogFilterItemComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CatalogFilterItemComponent, "co-catalog-filter-item", never, { "filterOrders": { "alias": "filterOrders"; "required": false; }; "model": { "alias": "model"; "required": false; }; "mode": { "alias": "mode"; "required": false; }; "collection": { "alias": "collection"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "customContent": { "alias": "customContent"; "required": false; }; "singleSelect": { "alias": "singleSelect"; "required": false; }; "expanded": { "alias": "expanded"; "required": false; }; "minSearchCharsToLoadCollection": { "alias": "minSearchCharsToLoadCollection"; "required": false; }; "initialLimit": { "alias": "initialLimit"; "required": false; }; "sliderDefaultMin": { "alias": "sliderDefaultMin"; "required": false; }; "sliderDefaultMax": { "alias": "sliderDefaultMax"; "required": false; }; "searchCollectionPlaceholder": { "alias": "searchCollectionPlaceholder"; "required": false; }; "collectionLoadFn": { "alias": "collectionLoadFn"; "required": false; }; "stockViewFilter": { "alias": "stockViewFilter"; "required": false; }; "screenConfigurationObjectName": { "alias": "screenConfigurationObjectName"; "required": false; }; }, { "modelChange": "modelChange"; "collectionChange": "collectionChange"; "filterButtonClicked": "filterButtonClicked"; }, never, ["*"], false, never>;
}

declare class CatalogFilterItemModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<CatalogFilterItemModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<CatalogFilterItemModule, [typeof CatalogFilterItemComponent], [typeof i2.CommonModule, typeof i3.FilterItemModule, typeof CatalogPipeModule, typeof i3.ScreenConfigurationModule], [typeof CatalogFilterItemComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<CatalogFilterItemModule>;
}

declare class CatalogFilterContentGeneralModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<CatalogFilterContentGeneralModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<CatalogFilterContentGeneralModule, [typeof CatalogFilterContentGeneralComponent], [typeof i2.CommonModule, typeof i3.FilterItemModule, typeof i3.InputTextModule, typeof i3.ButtonModule, typeof i3.IconModule, typeof i3.InputCheckboxModule, typeof CatalogPipeModule, typeof CatalogFilterItemModule, typeof i3.ScreenConfigurationModule], [typeof CatalogFilterContentGeneralComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<CatalogFilterContentGeneralModule>;
}

declare class CatalogFilterContentPurchaseComponent implements OnInit, OnDestroy {
    catalogSearchService: CatalogSearchService;
    iconCache: IconCacheService;
    filterService: CatalogFilterService;
    private _catalogConnectorService;
    private _adapterService;
    readonly icons: typeof IconEnum;
    readonly cfgName: typeof ConfigNameEnum;
    readonly modes: typeof FilterItemMode;
    filterOrders: FilterOrder[];
    showClass(): boolean;
    priceListsPurchCollection: FilterItemViewmodel[];
    private _subs;
    constructor(catalogSearchService: CatalogSearchService, iconCache: IconCacheService, filterService: CatalogFilterService, _catalogConnectorService: CatalogConnectorService, _adapterService: CatalogConnectorAdapterService);
    ngOnInit(): void;
    ngOnDestroy(): void;
    private _setCollections;
    setSuppliers: (text: string) => Promise<FilterItemViewmodel[]>;
    private _setPriceList;
    static ɵfac: i0.ɵɵFactoryDeclaration<CatalogFilterContentPurchaseComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CatalogFilterContentPurchaseComponent, "co-catalog-filter-content-purchase", never, { "filterOrders": { "alias": "filterOrders"; "required": false; }; }, {}, never, never, false, never>;
}

declare class CatalogFilterContentPurchaseModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<CatalogFilterContentPurchaseModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<CatalogFilterContentPurchaseModule, [typeof CatalogFilterContentPurchaseComponent], [typeof i2.CommonModule, typeof i3.FilterItemModule, typeof i3.InputTextModule, typeof i3.ButtonModule, typeof CatalogPipeModule, typeof CatalogFilterItemModule], [typeof CatalogFilterContentPurchaseComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<CatalogFilterContentPurchaseModule>;
}

declare class CatalogStockTransferService implements OnDestroy {
    private _filterService;
    private _catalogConnectorService;
    private _optionService;
    searchRequest: ArticleExtendedRequest;
    stockSearchRequest: ArticleStockTransferSearchRequest;
    articlesPerPage: number;
    resultCount: number;
    transferTileArticles: ArticleStockTransferSearchTileSelection[];
    transferGridArticles: ArticleStockTransferSearchGridSelection[];
    get currentPage(): number;
    set currentPage(value: number);
    private _currentPage;
    private _subs;
    constructor(_filterService: CatalogFilterService, _catalogConnectorService: CatalogConnectorService, _optionService: CatalogOptionsService);
    ngOnDestroy(): void;
    searchArticlesForTileView(resetPaging?: boolean, resetRequestParameters?: boolean): void;
    searchArticlesForGridView(resetPaging?: boolean, resetRequestParameters?: boolean): void;
    getArticleGridViewExcelFile(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CatalogStockTransferService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<CatalogStockTransferService>;
}

declare class CatalogStockComparisonService implements OnDestroy {
    private _filterService;
    private _catalogConnectorService;
    private _optionService;
    searchRequest: ArticleExtendedRequest;
    stockSearchRequest: ArticleStockComparisonSearchRequest;
    articlesPerPage: number;
    resultCount: number;
    comparisonTileArticles: ArticleStockComparisonSearchTileSelection[];
    comparisonGridArticles: ArticleStockComparisonSearchGridSelection[];
    get currentPage(): number;
    set currentPage(value: number);
    private _currentPage;
    private _subs;
    constructor(_filterService: CatalogFilterService, _catalogConnectorService: CatalogConnectorService, _optionService: CatalogOptionsService);
    ngOnDestroy(): void;
    searchArticlesForTileView(resetPaging?: boolean, resetRequestParameters?: boolean): void;
    searchArticlesForGridView(resetPaging?: boolean, resetRequestParameters?: boolean): void;
    getArticleGridViewExcelFile(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CatalogStockComparisonService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<CatalogStockComparisonService>;
}

declare class CatalogStockService implements OnDestroy {
    private _filterService;
    private _catalogConnectorService;
    private _optionService;
    searchRequest: ArticleExtendedRequest;
    stockSearchRequest: ArticleStockSearchRequest;
    articlesPerPage: number;
    resultCount: number;
    tileArticles: ArticleStockSearchTileSelection[];
    gridArticles: ArticleStockSearchGridSelection[];
    get currentPage(): number;
    set currentPage(value: number);
    private _currentPage;
    private _subs;
    constructor(_filterService: CatalogFilterService, _catalogConnectorService: CatalogConnectorService, _optionService: CatalogOptionsService);
    ngOnDestroy(): void;
    searchArticlesForTileView(resetPaging?: boolean, resetRequestParameters?: boolean): void;
    searchArticlesForGridView(resetPaging?: boolean, resetRequestParameters?: boolean): void;
    getArticleGridViewExcelFile(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CatalogStockService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<CatalogStockService>;
}

declare class CatalogFilterContentLogisticsComponent implements OnInit, OnDestroy {
    catalogSearchService: CatalogSearchService;
    iconCache: IconCacheService;
    catalogService: CatalogService;
    catalogStockService: CatalogStockService;
    catalogStockTransferService: CatalogStockTransferService;
    catalogStockComparisonService: CatalogStockComparisonService;
    private _filterService;
    private _catalogConnectorService;
    private _adapterService;
    private _dictionaryService;
    readonly cfgName: typeof ConfigNameEnum;
    filterOrders: FilterOrder[];
    showClass(): boolean;
    readonly modes: typeof FilterItemMode;
    readonly icons: typeof IconEnum;
    activeStockView: StockView;
    readonly StockView: typeof StockView;
    stockStatuses: FilterItemViewmodel[];
    warehouses: FilterItemViewmodel[];
    sourceWarehouses: FilterItemViewmodel[];
    targetWarehouses: FilterItemViewmodel[];
    stockStatusCollection: {
        code: number;
        description: string;
    }[];
    private _subs;
    constructor(catalogSearchService: CatalogSearchService, iconCache: IconCacheService, catalogService: CatalogService, catalogStockService: CatalogStockService, catalogStockTransferService: CatalogStockTransferService, catalogStockComparisonService: CatalogStockComparisonService, _filterService: CatalogFilterService, _catalogConnectorService: CatalogConnectorService, _adapterService: CatalogConnectorAdapterService, _dictionaryService: CatalogDictionaryService);
    ngOnInit(): Promise<void>;
    ngOnDestroy(): void;
    handleStockSearch(): void;
    handleWarehouseTransfersSearch(): void;
    handleStockComparisonSearch(): void;
    private _setWarehouses;
    private _setStockStatuses;
    static ɵfac: i0.ɵɵFactoryDeclaration<CatalogFilterContentLogisticsComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CatalogFilterContentLogisticsComponent, "co-catalog-filter-content-logistics", never, { "filterOrders": { "alias": "filterOrders"; "required": false; }; }, {}, never, never, false, never>;
}

declare class CatalogFilterContentLogisticsModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<CatalogFilterContentLogisticsModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<CatalogFilterContentLogisticsModule, [typeof CatalogFilterContentLogisticsComponent], [typeof i2.CommonModule, typeof i3.FilterItemModule, typeof i3.InputTextModule, typeof i3.ButtonModule, typeof i3.InputCheckboxModule, typeof i3.InputDatePickerModule, typeof CatalogPipeModule, typeof CatalogFilterItemModule], [typeof CatalogFilterContentLogisticsComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<CatalogFilterContentLogisticsModule>;
}

declare class CatalogFilterModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<CatalogFilterModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<CatalogFilterModule, [typeof CatalogFilterComponent], [typeof i2.CommonModule, typeof i3.IconModule, typeof i3.InputTextModule, typeof i3.FilterItemModule, typeof i3.InputDatePickerModule, typeof i3.IconCollapseHandleModule, typeof i3.InputCheckboxModule, typeof CatalogFilterCategoriesModule, typeof CatalogFilterContentGeneralModule, typeof CatalogFilterContentPurchaseModule, typeof CatalogFilterContentLogisticsModule, typeof CatalogPipeModule, typeof i3.ButtonModule, typeof i3.CoDialogModule, typeof i3.ListOfValuesModule, typeof i9.SearchPresetOverviewModule], [typeof CatalogFilterComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<CatalogFilterModule>;
}

declare class ResponsiveTextComponent {
    text: string;
    showClass(): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<ResponsiveTextComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ResponsiveTextComponent, "co-responsive-text", never, { "text": { "alias": "text"; "required": false; }; }, {}, never, never, false, never>;
}

declare class ResponsiveTextModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<ResponsiveTextModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<ResponsiveTextModule, [typeof ResponsiveTextComponent], [typeof i2.CommonModule], [typeof ResponsiveTextComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<ResponsiveTextModule>;
}

declare class CatalogCategoriesModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<CatalogCategoriesModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<CatalogCategoriesModule, [typeof CatalogCategoriesComponent], [typeof i2.CommonModule, typeof i3.ImageModule, typeof i3.IconModule, typeof CatalogFilterModule, typeof ResponsiveTextModule, typeof CatalogPipeModule, typeof i3.OverlayModule], [typeof CatalogCategoriesComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<CatalogCategoriesModule>;
}

declare class CatalogNavigationComponent {
    iconCache: IconCacheService;
    catalogService: CatalogService;
    private _appEventService;
    private _adapterService;
    readonly icons: typeof IconEnum;
    homeLabel: string;
    collectionLabel: string;
    externalSourcesLabel: string;
    showTurnoverGroups: boolean;
    currentTransactionBranchId: number;
    view: HTMLElement;
    homeClick: EventEmitter<void>;
    categoryClick: EventEmitter<string>;
    turnoverGroupClick: EventEmitter<string>;
    externalSourceClick: EventEmitter<ExternalSourceViewmodel>;
    minified: boolean;
    showClass: boolean;
    mobileMenuToggle: boolean;
    popupTop: number;
    popupHeight: number;
    popupWidth: number;
    popupLeft: number;
    categories: ArticleCategory[];
    externalSources: CatalogDefinition[];
    turnoverGroups: TurnoverGroupImage[];
    showCollectionOverlay: boolean;
    showExternalOverlay: boolean;
    get internalList(): any[];
    get externalList(): any[];
    private _subs;
    constructor(iconCache: IconCacheService, catalogService: CatalogService, _appEventService: CatalogEventService, _adapterService: CatalogConnectorAdapterService);
    ngOnInit(): void;
    ngOnDestroy(): void;
    getCategories(): Promise<void>;
    getExternalSources(): Promise<void>;
    prepareTurnoverGroups(): void;
    handleCategoryClick(event: MouseEvent, category: string): void;
    handleTurnoverGroupClick(event: MouseEvent, turnovergroupNr: string): void;
    handleExternalSourceClick(externalSource: ExternalSourceViewmodel): void;
    onToggleMobileMenu(): void;
    onSubMenuToggle(event: any): void;
    onOpenSubMenu(event: MouseEvent): void;
    onSetCategory(event: any, category: string): void;
    onSetTurnoverGroup(event: any, turnoverGroup: string): void;
    onOpenExternalCatalog(event: any, webviewUrl: string): void;
    onOpenIoneCatalog(event: any, webviewUrl: string, ioneUrl: string, upId: string, userName: string, passWord: string): void;
    handleHomeClick(event: MouseEvent): void;
    handleShowCollectionOverlay(): void;
    handleShowExternalOverlay(): void;
    handleHideCollectionOverlay(): void;
    handleHideExternalOverlay(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CatalogNavigationComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CatalogNavigationComponent, "co-catalog-navigation", never, { "homeLabel": { "alias": "homeLabel"; "required": false; }; "collectionLabel": { "alias": "collectionLabel"; "required": false; }; "externalSourcesLabel": { "alias": "externalSourcesLabel"; "required": false; }; "showTurnoverGroups": { "alias": "showTurnoverGroups"; "required": false; }; "currentTransactionBranchId": { "alias": "currentTransactionBranchId"; "required": false; }; "view": { "alias": "view"; "required": false; }; "minified": { "alias": "minified"; "required": false; }; }, { "homeClick": "homeClick"; "categoryClick": "categoryClick"; "turnoverGroupClick": "turnoverGroupClick"; "externalSourceClick": "externalSourceClick"; }, never, never, false, never>;
}

declare class CatalogExternalSourcesComponent implements OnInit, OnDestroy {
    private _catalogConnectorService;
    private _imageService;
    private _adapterService;
    isStandalone: boolean;
    embedded: boolean;
    currentTransactionBranchId: number;
    externalSourceClick: EventEmitter<ExternalSourceViewmodel>;
    catalogsLoaded: EventEmitter<boolean>;
    showClass(): boolean;
    pinnedExternalSourceViewModels: ExternalSourceViewmodel[];
    externalSourceViewModels: ExternalSourceViewmodel[];
    unavailableCatalogs: CatalogDefinition[];
    private _subs;
    constructor(_catalogConnectorService: CatalogConnectorService, _imageService: CatalogImageService, _adapterService: CatalogConnectorAdapterService);
    ngOnInit(): Promise<void>;
    ngOnDestroy(): void;
    private _getCatalogs;
    private _sortAndLoadAvailableCatalogs;
    private _loadCatalogs;
    private _loadUnavailableCatalogs;
    static ɵfac: i0.ɵɵFactoryDeclaration<CatalogExternalSourcesComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CatalogExternalSourcesComponent, "co-catalog-external-sources", never, { "isStandalone": { "alias": "isStandalone"; "required": false; }; "embedded": { "alias": "embedded"; "required": false; }; "currentTransactionBranchId": { "alias": "currentTransactionBranchId"; "required": false; }; }, { "externalSourceClick": "externalSourceClick"; "catalogsLoaded": "catalogsLoaded"; }, never, never, false, never>;
}

declare class CatalogExternalSourcesModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<CatalogExternalSourcesModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<CatalogExternalSourcesModule, [typeof CatalogExternalSourcesComponent], [typeof i2.CommonModule, typeof CatalogFilterModule, typeof i3.ImageModule, typeof ResponsiveTextModule, typeof CatalogPipeModule], [typeof CatalogExternalSourcesComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<CatalogExternalSourcesModule>;
}

declare class CatalogNavigationModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<CatalogNavigationModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<CatalogNavigationModule, [typeof CatalogNavigationComponent], [typeof i2.CommonModule, typeof CatalogFilterModule, typeof CatalogExternalSourcesModule, typeof i3.OverlayModule, typeof i3.IconModule, typeof CatalogPipeModule], [typeof CatalogNavigationComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<CatalogNavigationModule>;
}

declare class CatalogSearchComponent implements OnInit, OnDestroy {
    private _settingsService;
    private _catalogService;
    private _catalogSearchService;
    private _catalogEventService;
    private _catalogAdapterService;
    iconCacheService: IconCacheService;
    private _cfgService;
    options: CatalogOptionsService;
    readonly icons: typeof IconEnum;
    set settings(value: any);
    title: string;
    subTitle: string;
    searchPlaceholder: string;
    createFrozenArticle: boolean;
    showNavigation: boolean;
    showLandingPage: boolean;
    tempFilter: boolean;
    popupFilter: boolean;
    showViewModes: boolean;
    embedded: boolean;
    externalSource: ExternalSourceInfo;
    isReturn: boolean;
    currentTransactionBranchId: number;
    searchPresetTemplate: TemplateRef<any>;
    /**
     * Defaults
     * {name: 'CATEGORY', order: 1},
     * {name: 'TURNOVER_GROUP', order: 2},
     * {name: 'PRODUCT_GROUP', order: 3},
     * {name: 'BRANDS', order: 4},
     * {name: 'COLOR', order: 5},
     * {name: 'COLOUR', order: 5},
     * {name: 'CONCEPT', order: 6},
     * {name: 'TAG', order: 7},
     * {name: 'ATMOSPHERE', order: 8}
     */
    generalFilterOrders: FilterOrder[];
    purchaseFilterOrders: FilterOrder[];
    logisticsFilterOrders: FilterOrder[];
    settingsChange: EventEmitter<any>;
    onLookAtArticleButtonClick: EventEmitter<ArticleExtended>;
    onArButtonClick: EventEmitter<ArticleExtended>;
    onAddArticleButtonClick: EventEmitter<string | ArticleExtended>;
    onArticleClick: EventEmitter<ArticleExtended>;
    onStockDetailsClick: EventEmitter<ArticleExtended>;
    onExternalSourceClick: EventEmitter<ExternalSourceViewmodel>;
    showClass(): boolean;
    mode: string;
    showCategories: boolean;
    configLoaded: boolean;
    showFilter: boolean;
    private _subs;
    private _settings;
    constructor(_settingsService: CatalogSettingsService, _catalogService: CatalogService, _catalogSearchService: CatalogSearchService, _catalogEventService: CatalogEventService, _catalogAdapterService: CatalogConnectorAdapterService, iconCacheService: IconCacheService, _cfgService: CatalogScreenConfigurationService, options: CatalogOptionsService);
    ngOnInit(): Promise<void>;
    ngOnDestroy(): void;
    handleHomeClick($event: any): void;
    handleCategoryClick(category: string): void;
    handleTurnoverGroupClick(turnoverGroup: string): void;
    handleResetButtonClick(event: MouseEvent): void;
    /**
     * Applies the given searchRequest and searches for articles based on that request
     */
    applySearchRequest(searchRequest: ArticleExtendedRequest): void;
    search(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CatalogSearchComponent, [{ host: true; }, { host: true; }, { host: true; }, null, null, null, null, null]>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CatalogSearchComponent, "co-catalog-search", never, { "settings": { "alias": "settings"; "required": false; }; "title": { "alias": "title"; "required": false; }; "subTitle": { "alias": "subTitle"; "required": false; }; "searchPlaceholder": { "alias": "searchPlaceholder"; "required": false; }; "createFrozenArticle": { "alias": "createFrozenArticle"; "required": false; }; "showNavigation": { "alias": "showNavigation"; "required": false; }; "showLandingPage": { "alias": "showLandingPage"; "required": false; }; "tempFilter": { "alias": "tempFilter"; "required": false; }; "popupFilter": { "alias": "popupFilter"; "required": false; }; "showViewModes": { "alias": "showViewModes"; "required": false; }; "embedded": { "alias": "embedded"; "required": false; }; "externalSource": { "alias": "externalSource"; "required": false; }; "isReturn": { "alias": "isReturn"; "required": false; }; "currentTransactionBranchId": { "alias": "currentTransactionBranchId"; "required": false; }; "searchPresetTemplate": { "alias": "searchPresetTemplate"; "required": false; }; "generalFilterOrders": { "alias": "generalFilterOrders"; "required": false; }; "purchaseFilterOrders": { "alias": "purchaseFilterOrders"; "required": false; }; "logisticsFilterOrders": { "alias": "logisticsFilterOrders"; "required": false; }; }, { "settingsChange": "settingsChange"; "onLookAtArticleButtonClick": "onLookAtArticleButtonClick"; "onArButtonClick": "onArButtonClick"; "onAddArticleButtonClick": "onAddArticleButtonClick"; "onArticleClick": "onArticleClick"; "onStockDetailsClick": "onStockDetailsClick"; "onExternalSourceClick": "onExternalSourceClick"; }, never, never, false, never>;
}

declare class CatalogSearchHeaderComponent {
    catalogSearchService: CatalogSearchService;
    iconCacheService: IconCacheService;
    readonly icons: typeof IconEnum;
    placeholder: string;
    filterIconClick: EventEmitter<void>;
    showClass(): boolean;
    constructor(catalogSearchService: CatalogSearchService, iconCacheService: IconCacheService);
    static ɵfac: i0.ɵɵFactoryDeclaration<CatalogSearchHeaderComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CatalogSearchHeaderComponent, "co-catalog-search-header", never, { "placeholder": { "alias": "placeholder"; "required": false; }; }, { "filterIconClick": "filterIconClick"; }, never, never, false, never>;
}

declare class CatalogSearchHeaderModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<CatalogSearchHeaderModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<CatalogSearchHeaderModule, [typeof CatalogSearchHeaderComponent], [typeof i2.CommonModule, typeof i3.InputSearchModule, typeof i3.IconModule], [typeof CatalogSearchHeaderComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<CatalogSearchHeaderModule>;
}

declare abstract class CatalogSearchBaseComponent {
    catalogSearchService: CatalogSearchService;
    createFrozenArticle: boolean;
    externalSource: ExternalSourceInfo;
    onLookAtArticleButtonClick: EventEmitter<ArticleExtended>;
    onArButtonClick: EventEmitter<ArticleExtended>;
    onAddArticleButtonClick: EventEmitter<string | ArticleExtended>;
    onArticleClick: EventEmitter<ArticleExtended>;
    onStockDetailsClick: EventEmitter<ArticleExtended>;
    onArticleCheckboxClicked: EventEmitter<{
        article: ArticleExtended;
        selected: boolean;
    }>;
    elements: ElementRef[];
    constructor(catalogSearchService: CatalogSearchService);
    onPreviousClick(): void;
    onNextClick(): void;
    onPageClick(pageNr: number): void;
    private _scrollIntoView;
    private _getScrollableParent;
    static ɵfac: i0.ɵɵFactoryDeclaration<CatalogSearchBaseComponent, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<CatalogSearchBaseComponent, never, never, { "createFrozenArticle": { "alias": "createFrozenArticle"; "required": false; }; "externalSource": { "alias": "externalSource"; "required": false; }; }, { "onLookAtArticleButtonClick": "onLookAtArticleButtonClick"; "onArButtonClick": "onArButtonClick"; "onAddArticleButtonClick": "onAddArticleButtonClick"; "onArticleClick": "onArticleClick"; "onStockDetailsClick": "onStockDetailsClick"; "onArticleCheckboxClicked": "onArticleCheckboxClicked"; }, never, never, true, never>;
}

declare class CatalogSearchResultTileComponent extends CatalogSearchBaseComponent {
    set viewChildren(children: any);
    showClass: boolean;
    smallScrollbar: boolean;
    embedded: boolean;
    isReturn: boolean;
    showSelectionCheckbox: boolean;
    selectedArticles: number[];
    static ɵfac: i0.ɵɵFactoryDeclaration<CatalogSearchResultTileComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CatalogSearchResultTileComponent, "co-catalog-search-result-tile", never, { "embedded": { "alias": "embedded"; "required": false; }; "isReturn": { "alias": "isReturn"; "required": false; }; "showSelectionCheckbox": { "alias": "showSelectionCheckbox"; "required": false; }; "selectedArticles": { "alias": "selectedArticles"; "required": false; }; }, {}, never, never, false, never>;
}

declare abstract class ArticleBaseComponent implements OnInit {
    iconCache: IconCacheService;
    catalogService: CatalogService;
    options: CatalogOptionsService;
    private _iOne;
    private _changeDetector;
    private _appEventService;
    private _imageService;
    private _settingsService;
    private _dictionaryService;
    readonly icons: typeof IconEnum;
    set article(value: ArticleExtended);
    get article(): ArticleExtended;
    set showing(value: boolean);
    imageData: string;
    createFrozenArticle: boolean;
    price: number | string;
    isSelected: boolean;
    isSmallModus: boolean;
    hasMagnifierButton: boolean;
    hasInfoButton: boolean;
    externalSource: ExternalSourceInfo;
    onLookAtArticleButtonClick: EventEmitter<ArticleExtended>;
    onArButtonClick: EventEmitter<ArticleExtended>;
    onArticleCheckboxClicked: EventEmitter<{
        article: ArticleExtended;
        selected: boolean;
    }>;
    onAddArticleButtonClick: EventEmitter<string | ArticleExtended>;
    onArticleClick: EventEmitter<ArticleExtended>;
    onStockDetailsClick: EventEmitter<ArticleExtended>;
    readonly contentClick: EventEmitter<MouseEvent>;
    readonly infoButtonClick: EventEmitter<MouseEvent>;
    readonly magnifierButtonClick: EventEmitter<MouseEvent>;
    readonly threeDButtonClick: EventEmitter<MouseEvent>;
    showClass(): boolean;
    onHostClick(event: MouseEvent): void;
    configurable: boolean;
    threeD: boolean;
    description: string;
    added_description: string;
    stock_available: any;
    name: string;
    valutaSymbol: string;
    turnover: string;
    stockLabel: string;
    deliveryTimeLabel: string;
    inStock: boolean;
    stockAmount: string;
    private _article;
    constructor(iconCache: IconCacheService, catalogService: CatalogService, options: CatalogOptionsService, _iOne: CatalogConnectorService, _changeDetector: ChangeDetectorRef, _appEventService: CatalogEventService, _imageService: CatalogImageService, _settingsService: CatalogSettingsService, _dictionaryService: CatalogDictionaryService);
    ngOnInit(): void;
    handleLookAtArticleButtonClick(event: MouseEvent): void;
    handleAddArticleButtonClick(event: MouseEvent, isRetour?: boolean): Promise<void>;
    handleStockDetailsButtonClick(event: MouseEvent): void;
    handleStockArticleDetailsButtonClick(article: ArticleStockSearchTileSelection | ArticleStockTransferSearchTileSelection | ArticleStockComparisonSearchTileSelection, event: MouseEvent): void;
    handleArButtonClick(event: MouseEvent): void;
    handleCheckboxClicked(checked: boolean): void;
    removeHtmlTags(desc: string): string;
    private _getJSONFromArticleObject;
    private _detectChanges;
    private _getThumbNailImagesPriceAndStock;
    private _getGeneratedArtDirectly;
    static ɵfac: i0.ɵɵFactoryDeclaration<ArticleBaseComponent, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<ArticleBaseComponent, never, never, { "article": { "alias": "article"; "required": false; }; "showing": { "alias": "showing"; "required": false; }; "imageData": { "alias": "imageData"; "required": false; }; "createFrozenArticle": { "alias": "createFrozenArticle"; "required": false; }; "price": { "alias": "price"; "required": false; }; "isSelected": { "alias": "isSelected"; "required": false; }; "isSmallModus": { "alias": "isSmallModus"; "required": false; }; "hasMagnifierButton": { "alias": "hasMagnifierButton"; "required": false; }; "hasInfoButton": { "alias": "hasInfoButton"; "required": false; }; "externalSource": { "alias": "externalSource"; "required": false; }; }, { "onLookAtArticleButtonClick": "onLookAtArticleButtonClick"; "onArButtonClick": "onArButtonClick"; "onArticleCheckboxClicked": "onArticleCheckboxClicked"; "onAddArticleButtonClick": "onAddArticleButtonClick"; "onArticleClick": "onArticleClick"; "onStockDetailsClick": "onStockDetailsClick"; "contentClick": "contentClick"; "infoButtonClick": "infoButtonClick"; "magnifierButtonClick": "magnifierButtonClick"; "threeDButtonClick": "threeDButtonClick"; }, never, never, true, never>;
}

declare class CatalogArticleTileComponent extends ArticleBaseComponent {
    showClass(): boolean;
    embedded: boolean;
    showSelectionCheckbox: boolean;
    isReturn: boolean;
    selectedArticles: number[];
    set article(value: ArticleExtended);
    get article(): ArticleExtended;
    selected: boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<CatalogArticleTileComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CatalogArticleTileComponent, "co-catalog-article-tile", never, { "embedded": { "alias": "embedded"; "required": false; }; "showSelectionCheckbox": { "alias": "showSelectionCheckbox"; "required": false; }; "isReturn": { "alias": "isReturn"; "required": false; }; "selectedArticles": { "alias": "selectedArticles"; "required": false; }; "article": { "alias": "article"; "required": false; }; }, {}, never, never, false, never>;
}

declare class CatalogArticleTileModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<CatalogArticleTileModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<CatalogArticleTileModule, [typeof CatalogArticleTileComponent], [typeof i2.CommonModule, typeof i3.IconModule, typeof CatalogFilterModule, typeof i3.ButtonModule, typeof i3.ImageModule, typeof CatalogPipeModule, typeof i3.InputCheckboxModule], [typeof CatalogArticleTileComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<CatalogArticleTileModule>;
}

declare class VisibilityObserverMasterDirective implements OnDestroy {
    private _mapping;
    private _observer;
    constructor();
    ngOnDestroy(): void;
    add(element: HTMLElement, callback: Function): void;
    remove(element: HTMLElement): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<VisibilityObserverMasterDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<VisibilityObserverMasterDirective, "[visibilityObserverMaster]", never, {}, {}, never, never, false, never>;
}

declare class VisibilityObserverDirective implements OnDestroy, OnInit {
    observerEnabled: boolean;
    isIntersecting: boolean;
    IS_INTERSECTING: boolean;
    IS_NOT_INTERSECTING: boolean;
    private _elementRef;
    private _parent;
    constructor(parent: VisibilityObserverMasterDirective, elementRef: ElementRef);
    ngOnDestroy(): void;
    ngOnInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<VisibilityObserverDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<VisibilityObserverDirective, "[visibilityObserver]", ["intersection"], { "observerEnabled": { "alias": "observerEnabled"; "required": false; }; }, {}, never, never, false, never>;
}

declare class VisibilityObserverModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<VisibilityObserverModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<VisibilityObserverModule, [typeof VisibilityObserverMasterDirective, typeof VisibilityObserverDirective], never, [typeof VisibilityObserverMasterDirective, typeof VisibilityObserverDirective]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<VisibilityObserverModule>;
}

declare class CatalogSearchResultTileModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<CatalogSearchResultTileModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<CatalogSearchResultTileModule, [typeof CatalogSearchResultTileComponent], [typeof i2.CommonModule, typeof CatalogArticleTileModule, typeof VisibilityObserverModule, typeof i3.PaginationBarModule, typeof CatalogFilterModule, typeof CatalogPipeModule], [typeof CatalogSearchResultTileComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<CatalogSearchResultTileModule>;
}

declare class CatalogSearchResultListComponent extends CatalogSearchBaseComponent {
    set viewChildren(children: any);
    embedded: boolean;
    isReturn: boolean;
    showClass(): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<CatalogSearchResultListComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CatalogSearchResultListComponent, "co-catalog-search-result-list", never, { "embedded": { "alias": "embedded"; "required": false; }; "isReturn": { "alias": "isReturn"; "required": false; }; }, {}, never, never, false, never>;
}

declare class CatalogArticleListComponent extends ArticleBaseComponent {
    embedded: boolean;
    isReturn: boolean;
    showClass(): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<CatalogArticleListComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CatalogArticleListComponent, "co-catalog-article-list", never, { "embedded": { "alias": "embedded"; "required": false; }; "isReturn": { "alias": "isReturn"; "required": false; }; }, {}, never, never, false, never>;
}

declare class CatalogArticleListModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<CatalogArticleListModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<CatalogArticleListModule, [typeof CatalogArticleListComponent], [typeof i2.CommonModule, typeof i3.ImageModule, typeof i3.IconModule, typeof CatalogFilterModule, typeof i3.ButtonModule, typeof CatalogPipeModule], [typeof CatalogArticleListComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<CatalogArticleListModule>;
}

declare class CatalogSearchResultListModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<CatalogSearchResultListModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<CatalogSearchResultListModule, [typeof CatalogSearchResultListComponent], [typeof i2.CommonModule, typeof VisibilityObserverModule, typeof CatalogArticleListModule, typeof i3.PaginationBarModule, typeof CatalogFilterModule, typeof CatalogPipeModule], [typeof CatalogSearchResultListComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<CatalogSearchResultListModule>;
}

declare class CatalogSearchResultGridComponent extends CatalogSearchBaseComponent {
    catalogSearchService: CatalogSearchService;
    showClass(): boolean;
    constructor(catalogSearchService: CatalogSearchService);
    static ɵfac: i0.ɵɵFactoryDeclaration<CatalogSearchResultGridComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CatalogSearchResultGridComponent, "co-catalog-search-result-grid", never, {}, {}, never, never, false, never>;
}

declare class CatalogSearchResultGridModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<CatalogSearchResultGridModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<CatalogSearchResultGridModule, [typeof CatalogSearchResultGridComponent], [typeof i2.CommonModule, typeof i3.InputSearchModule, typeof i3.IconModule, typeof i3.SimpleGridModule, typeof CatalogPipeModule, typeof i3.PaginationBarModule], [typeof CatalogSearchResultGridComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<CatalogSearchResultGridModule>;
}

declare class CatalogSearchModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<CatalogSearchModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<CatalogSearchModule, [typeof CatalogSearchComponent], [typeof i2.CommonModule, typeof CatalogFilterModule, typeof CatalogSearchHeaderModule, typeof CatalogSearchResultTileModule, typeof CatalogSearchResultListModule, typeof CatalogSearchResultGridModule, typeof CatalogCategoriesModule, typeof CatalogExternalSourcesModule, typeof CatalogNavigationModule, typeof i3.IconModule, typeof i3.ButtonModule, typeof CatalogPipeModule, typeof i9.SearchPresetOverviewModule], [typeof CatalogSearchComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<CatalogSearchModule>;
}

declare class CatalogExternalSourceComponent implements OnInit {
    private _sanitizer;
    private _catalogConnectorService;
    private _appEventService;
    set container(content: any);
    catalogDefinition: CatalogDefinition;
    user: number;
    set externalCatalogStartupInfo(value: ExternalCatalogStartupInfo);
    get externalCatalogStartupInfo(): ExternalCatalogStartupInfo;
    title: string;
    subTitle: string;
    searchPlaceholder: string;
    tempFilter: boolean;
    showNavigation: boolean;
    options: {};
    embedded: boolean;
    languageCode: string;
    /**
     * The name of the external source
     */
    name: string;
    articleClick: EventEmitter<ExternalSourceArticleClickInterface>;
    addArticleClick: EventEmitter<ExternalSourceArticleAddInterface>;
    lookAtArticleClick: EventEmitter<ExternalSourceArticleAddInterface>;
    iFrameFeedbackReceived: EventEmitter<string>;
    showClass: boolean;
    catalogFrame: ElementRef;
    showCatalog: boolean;
    safeUrl: SafeResourceUrl;
    password: string;
    username: string;
    externalOrderNr: string;
    vadainCounter: number;
    loaded: boolean;
    externalUrl: string;
    externalSettings: any;
    externalSource: ExternalSourceInfo;
    private _externalCatalogStartupInfo;
    private _subs;
    constructor(_sanitizer: DomSanitizer, _catalogConnectorService: CatalogConnectorService, _appEventService: CatalogEventService);
    ngOnInit(): void;
    handleArticleClick(article: ArticleListObjectExtended | ArticleExtended): void;
    receiveMessage(event: any): void;
    fetchAndCombineThreeDimerseData(hash: string): Promise<void>;
    create3DimerseFeedback(configurationData: any, priceData: any): void;
    fetchJsonFile(url: string): Promise<Response>;
    iframeLoaded(event: any): void;
    private _prepareExternalSource;
    static ɵfac: i0.ɵɵFactoryDeclaration<CatalogExternalSourceComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CatalogExternalSourceComponent, "co-catalog-external-source", never, { "catalogDefinition": { "alias": "catalogDefinition"; "required": false; }; "user": { "alias": "user"; "required": false; }; "externalCatalogStartupInfo": { "alias": "externalCatalogStartupInfo"; "required": false; }; "title": { "alias": "title"; "required": false; }; "subTitle": { "alias": "subTitle"; "required": false; }; "searchPlaceholder": { "alias": "searchPlaceholder"; "required": false; }; "tempFilter": { "alias": "tempFilter"; "required": false; }; "showNavigation": { "alias": "showNavigation"; "required": false; }; "options": { "alias": "options"; "required": false; }; "embedded": { "alias": "embedded"; "required": false; }; "languageCode": { "alias": "languageCode"; "required": false; }; "name": { "alias": "name"; "required": false; }; }, { "articleClick": "articleClick"; "addArticleClick": "addArticleClick"; "lookAtArticleClick": "lookAtArticleClick"; "iFrameFeedbackReceived": "iFrameFeedbackReceived"; }, never, never, false, never>;
}

declare class CatalogExternalSourceModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<CatalogExternalSourceModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<CatalogExternalSourceModule, [typeof CatalogExternalSourceComponent], [typeof i2.CommonModule, typeof CatalogSearchModule], [typeof CatalogExternalSourceComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<CatalogExternalSourceModule>;
}

declare class CatalogStockOverviewTileComponent extends ArticleBaseComponent implements OnInit {
    catalogStockService: CatalogStockService;
    iconCache: IconCacheService;
    catalogService: CatalogService;
    options: CatalogOptionsService;
    appEventService: CatalogEventService;
    showClass(): boolean;
    readonly icons: typeof IconEnum;
    valutaSymbol: string;
    protected readonly ArticleExtended: typeof ArticleExtended;
    constructor(catalogStockService: CatalogStockService, iconCache: IconCacheService, catalogService: CatalogService, options: CatalogOptionsService, appEventService: CatalogEventService);
    ngOnInit(): void;
    onPreviousClick(): void;
    onNextClick(): void;
    onPageClick(pageNr: number): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CatalogStockOverviewTileComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CatalogStockOverviewTileComponent, "co-catalog-stock-overview-tile", never, {}, {}, never, never, false, never>;
}

declare class CatalogStockOverviewTileModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<CatalogStockOverviewTileModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<CatalogStockOverviewTileModule, [typeof CatalogStockOverviewTileComponent], [typeof i2.CommonModule, typeof CatalogPipeModule, typeof i3.IconModule, typeof i3.ImageModule, typeof i3.PaginationBarModule], [typeof CatalogStockOverviewTileComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<CatalogStockOverviewTileModule>;
}

declare class CatalogStockOverviewListComponent implements OnInit {
    catalogStockService: CatalogStockService;
    showClass: boolean;
    constructor(catalogStockService: CatalogStockService);
    ngOnInit(): void;
    onPreviousClick(): void;
    onNextClick(): void;
    onPageClick(pageNr: number): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CatalogStockOverviewListComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CatalogStockOverviewListComponent, "co-catalog-stock-overview-list", never, {}, {}, never, never, false, never>;
}

declare class CatalogStockOverviewListModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<CatalogStockOverviewListModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<CatalogStockOverviewListModule, [typeof CatalogStockOverviewListComponent], [typeof i2.CommonModule, typeof CatalogPipeModule, typeof i3.SimpleGridModule, typeof i3.PaginationBarModule], [typeof CatalogStockOverviewListComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<CatalogStockOverviewListModule>;
}

declare class CatalogStockComparisonTileComponent extends ArticleBaseComponent implements OnInit {
    catalogStockComparisonService: CatalogStockComparisonService;
    iconCache: IconCacheService;
    catalogService: CatalogService;
    options: CatalogOptionsService;
    appEventService: CatalogEventService;
    showClass(): boolean;
    readonly icons: typeof IconEnum;
    valutaSymbol: string;
    constructor(catalogStockComparisonService: CatalogStockComparisonService, iconCache: IconCacheService, catalogService: CatalogService, options: CatalogOptionsService, appEventService: CatalogEventService);
    ngOnInit(): void;
    onPreviousClick(): void;
    onNextClick(): void;
    onPageClick(pageNr: number): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CatalogStockComparisonTileComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CatalogStockComparisonTileComponent, "co-catalog-stock-comparison-tile", never, {}, {}, never, never, false, never>;
}

declare class CatalogStockComparisonTileModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<CatalogStockComparisonTileModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<CatalogStockComparisonTileModule, [typeof CatalogStockComparisonTileComponent], [typeof i2.CommonModule, typeof CatalogPipeModule, typeof i3.IconModule, typeof i3.ImageModule, typeof i3.PaginationBarModule], [typeof CatalogStockComparisonTileComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<CatalogStockComparisonTileModule>;
}

declare class CatalogStockComparisonListComponent implements OnInit {
    catalogStockComparisonService: CatalogStockComparisonService;
    showClass: boolean;
    constructor(catalogStockComparisonService: CatalogStockComparisonService);
    ngOnInit(): void;
    onPreviousClick(): void;
    onNextClick(): void;
    onPageClick(pageNr: number): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CatalogStockComparisonListComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CatalogStockComparisonListComponent, "co-catalog-stock-comparison-list", never, {}, {}, never, never, false, never>;
}

declare class CatalogStockComparisonListModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<CatalogStockComparisonListModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<CatalogStockComparisonListModule, [typeof CatalogStockComparisonListComponent], [typeof i2.CommonModule, typeof CatalogPipeModule, typeof i3.SimpleGridModule, typeof i3.PaginationBarModule], [typeof CatalogStockComparisonListComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<CatalogStockComparisonListModule>;
}

declare class CatalogWarehouseTransfersTileComponent extends ArticleBaseComponent implements OnInit {
    catalogStockTransferService: CatalogStockTransferService;
    iconCache: IconCacheService;
    catalogService: CatalogService;
    options: CatalogOptionsService;
    appEventService: CatalogEventService;
    showClass(): boolean;
    readonly icons: typeof IconEnum;
    valutaSymbol: string;
    constructor(catalogStockTransferService: CatalogStockTransferService, iconCache: IconCacheService, catalogService: CatalogService, options: CatalogOptionsService, appEventService: CatalogEventService);
    ngOnInit(): void;
    onPreviousClick(): void;
    onNextClick(): void;
    onPageClick(pageNr: number): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CatalogWarehouseTransfersTileComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CatalogWarehouseTransfersTileComponent, "co-catalog-warehouse-transfers-tile", never, {}, {}, never, never, false, never>;
}

declare class CatalogWarehouseTransfersTileModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<CatalogWarehouseTransfersTileModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<CatalogWarehouseTransfersTileModule, [typeof CatalogWarehouseTransfersTileComponent], [typeof i2.CommonModule, typeof CatalogPipeModule, typeof i3.IconModule, typeof i3.ImageModule, typeof i3.PaginationBarModule], [typeof CatalogWarehouseTransfersTileComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<CatalogWarehouseTransfersTileModule>;
}

declare class CatalogWarehouseTransfersListComponent implements OnInit {
    catalogStockTransferService: CatalogStockTransferService;
    showClass: boolean;
    constructor(catalogStockTransferService: CatalogStockTransferService);
    ngOnInit(): void;
    onPreviousClick(): void;
    onNextClick(): void;
    onPageClick(pageNr: number): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CatalogWarehouseTransfersListComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CatalogWarehouseTransfersListComponent, "co-catalog-warehouse-transfers-list", never, {}, {}, never, never, false, never>;
}

declare class CatalogWarehouseTransfersListModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<CatalogWarehouseTransfersListModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<CatalogWarehouseTransfersListModule, [typeof CatalogWarehouseTransfersListComponent], [typeof i2.CommonModule, typeof CatalogPipeModule, typeof i3.SimpleGridModule, typeof i3.PaginationBarModule], [typeof CatalogWarehouseTransfersListComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<CatalogWarehouseTransfersListModule>;
}

interface OrderByInterface {
    id: number;
    name: string;
}

interface FilterItem {
    count: number;
    active: boolean;
    activeColor?: string;
    inActiveColor?: string;
    checkMarkColor?: string;
}

declare class ArticlesSearchResult {
    articles: ArticleExtended[];
    count: number;
}

/** AUTO GENERATED FILE. DO NOT CHANGE.. **/
declare const IconSvg: {
    [iconName: string]: string;
};

declare class CatalogNavigationService implements OnDestroy {
    private _catalog;
    private _iOne;
    private _optionsService;
    private _imageService;
    private _subs;
    private _connectionMade;
    private _optionsSet;
    navigationCategories: ArticleCategory[];
    allTurnoverGroups: TurnoverGroupImage[];
    constructor(_catalog: CatalogService, _iOne: CatalogConnectorService, _optionsService: CatalogOptionsService, _imageService: CatalogImageService);
    ngOnDestroy(): void;
    setCategory(category: string): void;
    setTurnoverGroup(turnoverGroup: string): void;
    setExternalSourceUrl(url: string): void;
    setIoneSourceUrl(url: string, ioneUrl: string, id: string, username: string, password: string): void;
    navigateToHome(): void;
    getCategories(): Promise<void>;
    getTurnoverGroupList(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CatalogNavigationService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<CatalogNavigationService>;
}

export { ArticleStockComparisonSearchGridResult, ArticleStockComparisonSearchGridSelection, ArticleStockComparisonSearchTileResult, ArticleStockComparisonSearchTileSelection, ArticleStockSearchGridSelection, ArticleStockSearchTileSelection, ArticleStockTransferSearchGridResult, ArticleStockTransferSearchGridSelection, ArticleStockTransferSearchTileResult, ArticleStockTransferSearchTileSelection, ArticlesSearchResult, ArticlesStockSearchGridResult, ArticlesStockSearchTileResult, CatalogArticleListComponent, CatalogArticleListModule, CatalogArticleTileComponent, CatalogArticleTileModule, CatalogBusinessObjectCacheManagerService, CatalogCategoriesComponent, CatalogCategoriesModule, CatalogConnectorAdapterService, CatalogConnectorService, CatalogDictionaryService, CatalogEventService, CatalogExternalSourceComponent, CatalogExternalSourceModule, CatalogExternalSourcesComponent, CatalogExternalSourcesModule, CatalogExternalSourcesService, CatalogFilterComponent, CatalogFilterModule, CatalogFilterService, CatalogFilterViewmodel, CatalogImageService, CatalogNavigationComponent, CatalogNavigationModule, CatalogNavigationService, CatalogOptionsService, CatalogScreenConfigurationService, CatalogSearchComponent, CatalogSearchHeaderComponent, CatalogSearchHeaderModule, CatalogSearchModule, CatalogSearchResultListComponent, CatalogSearchResultListModule, CatalogSearchResultTileComponent, CatalogSearchResultTileModule, CatalogSearchService, CatalogSelectMultipleCacheService, CatalogSelectMultipleParameterizedCacheService, CatalogSelectSingleCacheService, CatalogSelectSingleParameterizedCacheService, CatalogService, CatalogSettings, CatalogSettingsService, CatalogStockComparisonListComponent, CatalogStockComparisonListModule, CatalogStockComparisonService, CatalogStockComparisonTileComponent, CatalogStockComparisonTileModule, CatalogStockOverviewListComponent, CatalogStockOverviewListModule, CatalogStockOverviewTileComponent, CatalogStockOverviewTileModule, CatalogStockService, CatalogStockTransferService, CatalogWarehouseTransfersListComponent, CatalogWarehouseTransfersListModule, CatalogWarehouseTransfersTileComponent, CatalogWarehouseTransfersTileModule, ConfigNameEnum, ExternalSourceViewmodel, IconSvg, SettingsOptions, StockView, Version };
export type { Category, FilterItem, FilterOrder, OrderByInterface };