import CatalogArticleData from '../../model/Articles/Article/CatalogArticleData';
import { DataCreationError, DecisionDebug, PartlistDebugEntry, PriceDebug } from '../../interface/Articles/ArticleDataType';
import { ConstructionRule } from '../../interface/ArticleOptionStateType';
import ArticleOptionState from './ArticleOptionState';
import ArticleOptionData from '../../model/Options/ArticleOptionData';
import ArticleOptionValueData from '../../model/Options/ArticleOptionValueData';
import PlannerDataType from '../../interface/Planner/PlannerDataType';
import { ArticleInfoType } from '../../interface/Articles/ArticleInfoType';
import { PriceObjectData, JsonConfigPriceData, VariantItemData, Discount, MetaData_locales } from '@crystaldesign/basket-model';
import { ArticleOptionValueView } from '../../interface/OptionTypes/ArticleOptionValueView';
import { AlternativeRendering } from '../../interface/Rendering/AlternativeRendering';
import PartListArticleToLoad from '../../interface/Articles/PartListArticleToLoadType';
import { DivaCatalogData } from '../..';
import DivaSet from '../Set/DivaSet';
import ArticleEngine from './Engine/ArticleEngine';
import PlannerElementData from '../../model/Planner/PlannerElementData';
import { PriceObject } from '../../interface/Articles/PriceObject';
export default class DivaArticle {
    private article;
    private articleOptionStatesData;
    actPlannerData?: PlannerDataType;
    private _engine;
    decisionDebugStacks: {
        variantValues: {
            [opt: string]: string;
        };
        stack: DecisionDebug[];
        prices: PriceDebug[];
    }[];
    partlistDebugEntries: PartlistDebugEntry[];
    /** Obvious data creation errors (only populated when logDecisions is true). */
    dataCreationErrors: DataCreationError[];
    constructor(set: DivaSet, basketId: string, initParams: any, articleData: CatalogArticleData, catalogData: DivaCatalogData);
    initEngine(): void;
    /** Push a data creation error (only when logDecisions is true). */
    pushDataCreationError(error: DataCreationError): void;
    initPlannerData(articleData: CatalogArticleData): void;
    /*************************************************GETTER & SETTER **************************************************************************** */
    get basketId(): string;
    set elementId(elementId: number);
    get elementId(): number;
    get shelfElementId(): string;
    get set(): DivaSet;
    get setId(): string;
    get partlistArticles(): {
        [basketId: string]: DivaArticle;
    };
    get partlistArticleVisibleInTree(): boolean;
    get partlistArticleStandalone(): boolean;
    get partlistGroupPrefix(): string | undefined;
    get partlistArticlesReqursive(): DivaArticle[];
    get hasOptionsThatParentDoesNotHave(): boolean;
    getRecursivePartlistArticles(onlyVisible?: boolean, excludeStandalonePla?: boolean): {
        [basketId: string]: DivaArticle;
    };
    variantValuesForPla(configurationMode?: boolean, previousPartlistArticleVariantValues?: {
        [optCodex: string]: string;
    }, newConfigValues?: {
        [optCodex: string]: string;
    }): {
        [x: string]: string;
    };
    get partlistArticlesAsArray(): DivaArticle[];
    sortPartlistArticles(partlistArticlesToLoad: PartListArticleToLoad[]): void;
    get catalogArticle(): CatalogArticleData;
    get hasCatalogPlannerArticle(): boolean;
    get posNr(): number;
    set posNr(posNr: number);
    get isDockable(): boolean | undefined;
    set deleted(deleted: boolean);
    get deleted(): boolean;
    get toDeleteAfterInit(): boolean;
    set toDeleteAfterInit(val: boolean);
    get actSizeText(): string;
    get quantity(): number;
    set quantity(newQuantity: number);
    get weight(): number | undefined;
    get volume(): number;
    get price(): number;
    set price(val: number);
    get discountPercentage(): number | undefined;
    set discountPercentage(val: number | undefined);
    get bruttoPrice(): number;
    get mainPrice(): number;
    calcPrice(dontCalcDiscount?: boolean): number;
    get mainBruttoPrice(): number;
    get bruttoCalcPrice(): number;
    get getVkPrice(): PriceObjectData;
    get priceType(): any;
    get currency(): any;
    get priceListCodex(): any;
    get noPrice(): boolean;
    set noPrice(noPrice: boolean);
    get initDecisions(): (import("../..").IDMDecision | import("../..").Decision)[] | undefined;
    get getTabgroupsAsString(): string;
    get articleVariantValues(): string;
    get discounts(): Discount[] | undefined;
    get priceRefs(): PriceObject[];
    set priceRefs(val: PriceObject[]);
    get newPossibleAVRFilters(): string[] | undefined;
    set newPossibleAVRFilters(val: string[] | undefined);
    get newPossibleAVLFilters(): string[] | undefined;
    set newPossibleAVLFilters(val: string[] | undefined);
    get doUpdatePlannerSize(): boolean;
    set doUpdatePlannerSize(val: boolean);
    private getCurrentDisountPercentage;
    private getArticleOptionStatesWithOptionsForPrint;
    articleVariantDesc(newLine?: string): string;
    articleVariantDesc_locales(newLine?: string): {
        [lang: string]: string;
    };
    getIsConfigSingle: () => boolean;
    get CatalogData(): DivaCatalogData;
    get isAcc(): boolean;
    get isPartListArticle(): boolean;
    get isShelfAccessoire(): boolean;
    get origName(): string;
    get name(): string;
    addPartlistPostFix(): string;
    private addRuleDesc;
    get name_locales(): {
        [lang: string]: string;
    } | undefined;
    get RetailPrefix(): import("../../interface/Articles/ArticlePrefixesType").ArticlePrefix | undefined;
    get catalogArticleName(): string;
    get catalogArticleOrigName(): string;
    get catalogArticleName_locales(): {
        [lang: string]: string;
    } | undefined;
    get optionsForPrint(): string[];
    get image(): string | undefined;
    get imageUrl(): string | undefined;
    set image(newImage: string | undefined);
    get tabGroup(): string | undefined;
    get tabGroupOption(): string | undefined;
    get retailArticlePrefix(): import("../../interface/Articles/ArticlePrefixesType").ArticlePrefix | undefined;
    get retailTypeNr(): string | undefined;
    get retailArticleNr(): string | undefined;
    get articleCodex(): string;
    get sendToSap(): string | undefined;
    get model3DName(): string | undefined;
    get usePRGasOPVArticleNr(): boolean | undefined;
    get catalogCodex(): string;
    get hasArticleOptionStates(): boolean;
    get articleOptionStates(): Map<string, ArticleOptionState>;
    get articleOptionStatesKeys(): string[];
    get articleOptionStatesWithParents(): ArticleOptionState[];
    private getReqursiveArticleOptionStates;
    getAllArticleOptionsStates(): ArticleOptionState[];
    clearArticleOptionStates(): void;
    get articleGUID(): string;
    get articleEAN(): string | undefined;
    getArticleOptionStateFlat(codex: string): ArticleOptionState | undefined;
    getArticleOptionState(codex: string, from?: string, checkOnAccessoireParent?: boolean): ArticleOptionState | undefined;
    getValueByMeasureKey(measureKey: string): number | undefined;
    getAllOptionsStatesofOption(codex: string): any[];
    uploadOptionState(articleOptionState: ArticleOptionState): void;
    get partlistArticlesRules(): {
        PartListPos: import("../../interface/OptionTypes/DecisionType").PartlistPos[];
    }[] | undefined;
    get groupedPartlists(): {
        [decisionNr: string]: import("../../interface/OptionTypes/DecisionType").PartlistPos[];
    } | undefined;
    get decisionsUsedForPartlist(): number[] | undefined;
    get decisions(): import("../..").Decision[];
    get articleIDMDecisions(): import("../..").IDMDecision[];
    get partlistDecisions(): {
        [decisionNumber: string]: import("../..").Decision;
    } | undefined;
    get hasPartlistArticle(): boolean;
    get hasPartlistArticleInitialized(): boolean;
    set hasPartlistArticleInitialized(hasPartlistArticleInitialized: boolean);
    get catalogArticleOptions(): {
        [optCodex: string]: ArticleOptionData;
    };
    get articleType(): "OPTIONTREE" | "FLAT";
    get typeNr(): string | undefined;
    get articlePrices(): any;
    get relatedToBasketId(): string | undefined;
    set relatedToBasketId(basketId: string | undefined);
    get relatedToSubItem(): string | undefined;
    get subRetailArticleNr(): string | undefined;
    set subRetailArticleNr(subRetailArticleNr: string | undefined);
    get subRetailTypeNr(): string | undefined;
    set subRetailTypeNr(subRetailTypeNr: string | undefined);
    get hasType1Dependencies(): boolean;
    get hasArticleRelations(): boolean;
    get retailMainCategoryNr(): string | undefined;
    get retailSubCategoryNr(): string | undefined;
    get retailPrefix(): import("../../interface/Articles/ArticlePrefixesType").ArticlePrefix | undefined;
    get ruleDesc(): string | undefined;
    get ruleDesc_locales(): {
        [lang: string]: string;
    } | undefined;
    get partlistRule(): {
        [opt: string]: string;
    } | undefined;
    get partlistDecisionNo(): number | undefined;
    get bundleRules(): import("../../interface/Rules/BundleRules").default[] | undefined;
    get hasPartlistArticleVisibleInTree(): boolean;
    get partListParentArticle(): DivaArticle | undefined;
    pushParentId(parents?: string[]): string[];
    get doorPlanner(): import("../ConfigTree/DoorPlanner/DoorPlanner").default | undefined;
    resetShelfPlanner(): void;
    get shelfPlanner(): import("../ConfigTree/Shelfplanner/ShelfPlanner").default | undefined;
    get shelfAccessoires(): {
        [basketId: string]: DivaArticle;
    } | undefined;
    get shelfPlanData(): any;
    set shelfPlanData(val: any);
    get doorPlannerData(): any;
    get j3D(): any;
    set doorPlannerData(val: any);
    /**
     * return the neighbour on AVR or AVL
     */
    dockedOnAV(type: 'R' | 'L' | 'C' | 'U' | 'O'): undefined | DivaArticle;
    set accessoireParentArticle(parent: DivaArticle | undefined);
    get accessoireParentArticle(): DivaArticle | undefined;
    get relatedToShelfGrid(): number | undefined;
    set relatedToShelfGrid(relatedToShelfGrid: number | undefined);
    get relatedToConfigStep(): string | undefined;
    get articleRelations(): import("../..").AccessoireItemType[] | undefined;
    get accessoires(): {
        [basketId: string]: DivaArticle;
    };
    get accessoirePos(): {
        [groupName: string]: {
            [basketId: string]: number[];
        };
    };
    get accessoireList(): string[];
    get groupName(): string | undefined;
    get updatedOPVbyConstructionRules(): any;
    addUpdatedOPVbyConstructionRules(codex: string, newConsRules: any): any;
    get updatedAccbyConstructionRules(): any;
    addUpdatedAccbyConstructionRules(codex: string, newConsRules: any): any;
    get updatedOPVbyDockedOPVConstructionRules(): any;
    addUpdatedOPVbyDockedOPVConstructionRules(codex: string, newConsRules: any): any;
    addAccessoire(accessoire: DivaArticle): void;
    removeAccessoire(basketId: string): void;
    addPlannerDataAccessoire(accessoire: PlannerElementData): void;
    removePlannerDataAccessoire(basketId: string): void;
    curQunatityOfAccessoire(articleCodex: string): number;
    setAccessoirePos(basketId: string, quantity: number, groupName?: string): number[];
    private repairAccessoirePos;
    getAccessoireByArticleCodex(articleCodex?: string, deep?: boolean): DivaArticle[];
    getBaseParent(): DivaArticle;
    checkArtCodexIsAccessoire(articleCodex: string): boolean;
    getMergesToOPG(opt_opv: string, variantValues: string): any;
    addMergesToOPG(opt_opv: string, variantValues: string, visibleOPVs: ArticleOptionValueView[]): void;
    updatePlannerData(): void;
    get width(): number | undefined;
    get calcWidth(): number;
    set calcWidth(newWidth: number);
    get depth(): number | undefined;
    get calcDepth(): number;
    set calcDepth(newDepth: number);
    get height(): number | undefined;
    get incomplete(): ("AVR" | "AVL")[] | undefined;
    get calcHeight(): number;
    set calcHeight(newHeight: number);
    set avl(newAVL: string[]);
    set avr(newAVR: string[]);
    get plannerData(): PlannerDataType | undefined;
    set plannerData(plannerData: PlannerDataType | undefined);
    get updatedOPVbyOPVConstructionRules(): any;
    get updatedOPVbyParentOPVConstructionRules(): any;
    get actDescription(): string;
    get hasDecisionsInitialized(): boolean;
    set hasDecisionsInitialized(initialized: boolean);
    get configArticleCodex(): string | undefined;
    set configArticleCodex(codex: string | undefined);
    get diomexArticleCodex(): string | undefined;
    get supplierOrderCodex(): string | undefined;
    get VariantValues(): {
        [codex: string]: string;
    };
    get snapshot(): {
        [codex: string]: {
            selOPV: string;
            visibleOPVs: string[];
            optName: string;
            invisible: boolean;
        };
    };
    get VisibleVariantValues(): {
        [codex: string]: string;
    };
    get AllVariantValues(): {
        [codex: string]: string;
    };
    get VariantValuesWithoutEmptyFreetext(): {
        [codex: string]: string;
    };
    get VariantValuesParentOption(): {
        [codex: string]: string;
    };
    setDifferentOptions(options: string[]): void;
    get articleHash(): string;
    get articleProductHash(): string;
    get VariantValuesWithoutOPTandOPV(): {
        [codex: string]: string;
    };
    get VariantValuesWithoutOPTandOPVInObject(): {
        OPT: string;
        OPV: string;
    }[];
    getVariantValuesTillOPT(opt: string): {
        [codex: string]: string;
    };
    get areAllOptionsDefined(): boolean;
    optionStatesWithAddToMeasure(opt: string): ArticleOptionState[];
    get requiredUserInputOptions(): string[];
    /**
     * If a Accessoire with SVG is not dockable it should still be loaded as an article but not planned and visualized
     */
    get doNotDeleteAccWhenNotDocked(): boolean | undefined;
    findPartlistEntry(articlecodex: string): PartListArticleToLoad | undefined;
    /******************************************HelperFunktionen vom Article ***********************************************************************/
    addPartlistArticle(newPartlistArticle: DivaArticle): void;
    deletePartlistArticles(): void;
    getPreviousPartlistArticle: (articleCodex: string) => any;
    updateOPVConstruction(opt: string, opv: string, constructionRule: ConstructionRule): ConstructionRule | undefined;
    addUpdatedOPVbyOPVConstructionRules(codex: string, newConsRules: any): any;
    addUpdatedOPVbyParentOPVConstructionRules(codex: string, newConsRules: any): any;
    get MetaData(): {
        [key: string]: string[];
    };
    get MetaData_locales(): MetaData_locales;
    private getMetaData;
    private mergeMetaDatas;
    checkDefaultGlobalOpt(optToChange: {
        [codex: string]: string;
    }, ignoreOPVIsValid?: boolean): {
        variantValues: {
            [codex: string]: string;
        };
        triggerUpdate: boolean;
    };
    getAccessoriesToChangeFromGlobalOption(optToChange: {
        [codex: string]: string;
    }): {
        [basketId: string]: {
            accessoire: DivaArticle;
            variantValues: {
                [codex: string]: string;
            };
        };
    };
    getGlobalOptions(): {
        [codex: string]: string[];
    };
    evalRule(rule: string, ruleActionType?: string): boolean;
    checkOptionAndOptionValue(optionCodex: string, optionValueCodex: string, parentOptionCodex?: string): any;
    private checkOptionSearchOPV;
    getArticleJsonVariantValues(): {
        [key: string]: string;
    };
    parentOptionCodex(key: string): {
        partenOptionCodex: string | undefined;
        optionCodex: string;
    };
    getOptionsByParentOptionCodex(parentOptionCodex: string): ArticleOptionState[];
    handleMultiselect(ops: ArticleOptionState, newConfigValues: {
        [optCodex: string]: string;
    }, key: string): ArticleOptionState;
    handleFreeText(ops: ArticleOptionState, newConfigValues: {
        [optCodex: string]: string;
    }, key: string, freeTextValues: {
        [opt: string]: {
            exactMatchingKey: boolean;
        };
    }): void;
    findFreeTextOpv(ops: ArticleOptionState): ArticleOptionValueData | undefined;
    defineAllOptions(): void;
    defineOP(codex: string): void;
    getDefaultOpv(visibleOptionValues: Map<string, ArticleOptionValueData>): ArticleOptionValueData;
    getVariantValuesInfluencingOptions(filterOptions: string[], opv?: string): {
        [opt: string]: string;
    }[];
    getVariantValuesInfluencingOption(filterOption: string, opv?: string): {
        [opt: string]: string;
    }[];
    updateOptionsWithAddToMeasure(optionCodex: string): void;
    calcAddToMeasure(optionCodex: string, value: number): number;
    private calculateMeasure;
    updateShelfPlannerState(variantValues: {
        [opt: string]: string;
    }): Promise<void>;
    /**
     *
     * @param refLevel 1 = ROOT
  2 = PARENT
  3 = SELF default
     * @returns
     */
    getRefLevelArticle(refLevel?: 1 | 2 | 3): DivaArticle;
    parentHasSameOption(opt: string): boolean;
    afterInit(): {
        [opt: string]: string;
    };
    getValidValues(myValues: {
        [optCodex: string]: string;
    }, mergeOptionToSameOption?: string[][], setConfigDoesOverWrite?: boolean): {
        [optCodex: string]: string;
    };
    /**
     * this function return the config and material info of article. This is used for the planner visualisation
     */
    getPlannerConfigData(accessoireArticles: {
        [basketId: string]: DivaArticle;
    }, alternateRenderInfo?: AlternativeRendering): {
        config: any;
    };
    private addOptionStateFromArticleToPlannerData;
    private addOptionStateToPlannerData;
    private getAccessoireMATData;
    getArticleInfos(isActive: boolean): ArticleInfoType;
    getArticleConstructionRules(): any;
    /********************************************************Artikel speichern*********************************************************/
    /**
     * Diese Funktion liefert zu einem Artikel eine oder mehrere Orderline aus. Diese wird im Basket gespeichert und dient zur wiederherstellung eines Artikels!
     *
     *  Des weiteren kann es ZubehörOrderlines geben Optionsbaum aus und generiert daraus evtl. Zubehöroderlines??
     */
    getVariantBasketData(): VariantItemData[];
    getConfigPriceData(VariantBasketDatas: VariantItemData[]): JsonConfigPriceData;
    validateAndSetNewConfigValues(newConfigValues: {
        [optCodex: string]: string;
    }): {
        [optCodex: string]: string;
    };
    private checkIfSelectableOpvIsFreetext;
    get shelfHeight(): number | undefined;
    get shelfHeightBelow(): number | undefined;
    get shelfHeightAbove(): number | undefined;
    get engine(): ArticleEngine;
    convertTemplateToCodex(codex: string): string;
    private parseOperator;
    cloneArticle(set: DivaSet): DivaArticle;
}
//# sourceMappingURL=DivaArticle.d.ts.map