Oczyszczacz powietrza SAMSUNG AX90R7080WD/EU

Opis produktu

Czy wiesz, że powietrze w Twoim domu może być dużo bardziej zanieczyszczone niż na zewnątrz?
Kurz, sierść zwierząt to zanieczyszczenia, które dostrzegasz gołym okiem, jednak to nie wszystko. W okresie jesienno-zimowym do Twojego domu przedostaje się smog, pomimo zamkniętych okien. Wiosną i latem jesteśmy szczególnie narażeni na pyłki kwiatów i traw. Roztocza, pleśń, alergeny, chemia, której używamy do sprzątania czy też lotne związki organiczne mogą nas uczulać przez cały rok. Oczyszczacz powietrza Samsung, dzięki zaawansowanym technologiom skutecznie oczyści powietrze w Twoim domu ze wszystkich zanieczyszczeń.


	AX90R7080WD	AX60R5080WD	AX40R3030WM	AX47R9080SS
Kontrola przepływu powietrza	3-kierunkowy przepływ powietrza	3-kierunkowy przepływ powietrza	1-kierunkowy przepływ powietrza	1-kierunkowy przepływ powietrza
System filtracji	3-stopniowa filtracja	3-stopniowa filtracja	3-stopniowa filtracja	3-stopniowa filtracja
Współczynnik CADR	701 m³/h	467 m³/h	311 m³/h	Możliwość połączenia ze sobą dwóch oczyszczaczy (CADR 732 m³/h); CADR dla jednego to 366 m³/h
Prędkości wentylatora	3	3	3	3
Tryb automatyczny /Tryb nocny	✓	✓	✓	✓
Rodzaj filtrów	2x wstępny i 2x 2w1: węglowy i ultradrobnego pyłu	wstępny, 2w1: węglowy i ultradrobnego pyłu	wstępny, 2w1: węglowy i ultradrobnego pyłu	wstępny, 2w1: węglowy i ultradrobnego pyłu
Czujnik przykrych zapachów	✓	✓	✓	✓
Czujnik pyłu	✓	✓	✓	✓
Numeryczny wyświetlacz stężenia cząsteczek PM1.0, PM2.5, PM10	✓	✓	X	✓
Laserowy czujnik PM	✓	✓	X	✓
Wskaźnik zużycia filtra	✓	✓	✓	✓
Sterowanie dotykowe	✓	✓	✓	✓
Połączenie WiFi / aplikacja SmartThings	✓	✓	X	✓
Timer	✓	✓	✓	✓
Blokada ustawień	✓	✓	✓	✓
Wielkość pomieszczenia	do 90 m²	do 60 m²	do 40 m²	do 47 m²
Poziom hałasu max	54 dB(A)	50 dB(A)	48 dB(A)	50 dB(A)
Poziom hałasu w trybie nocnym	20 dB(A)	20 dB(A)	20 dB(A)	18 dB(A)
Wymiary (SxWxG)	360 x 1054 x 284 mm	360 x 783 x 293 mm	350 x 640 x 350 mm	367 x 436 x 380 mm
Kolor	biały	biały	biały	metaliczne srebro
Moc	90 W	60 W	40 W	35 W

Naciśnij odpowiedni przycisk, aby wybrać żądaną prędkość wentylatora.
- W trybie Auto oczyszczacz monitoruje i sam dostosowuje prędkość wentylatora do stopnia zanieczyszczenia powietrza, by zawsze zapewnić odpowiednią czystość powietrza w pomieszczeniu.
- Jeśli oczyszczacz w trybie Auto wykryje, że powietrze jest już oczyszczone, przełączy się w Tryb oszczędzania energii. Powietrze będzie wydmuchiwane tylko z górnego wylotu powietrza. Gdy w powietrzu pojawią się zanieczyszczenia, oczyszczasz powróci do pracy w trybie Auto.
- W Trybie nocnym oczyszczacz będzie działał cicho, ze zmniejszoną prędkością wentylatora. Wyłączone zostaną wskaźniki z wyjątkiem wskaźnika Trybu nocnego.
- Jeśli urządzenie działa w Trybie nocnym, a Ty włączysz inny tryb, wskaźniki uruchomią się i będą wyświetlały informacje po krótkiej chwili.

(function() {

/**
   * Widget script environment runtime
   */

/**
 * This module is responsible for populating window object with proper values.
 */
// setup widget repository object as empty object initially
window.__forge2_widgets = window.__forge2_widgets || {};
window.__forge2_themes = window.__forge2_themes || {};
// create runtime context object with useful methods in runtime
window.__forge2_context = window.__forge2_context || {
    initLazyLoad: function () { },
    /**
     * Returns theme with particular ID from registered themes
     */
    getTheme: function (themeId) {
        // check if theme exists on runtime
        if (!window.__forge2_themes[themeId]) {
            return undefined;
        }
        // get widget runtime class and create its instance
        var themeClass = window.__forge2_themes[themeId];
        return new themeClass();
    },
};
// setup register function for runtime
window.__forge2_widget_register = function (widgetType, widgetClass) {
    if (window.__forge2_widgets[widgetType]) {
        throw new Error("Error: trying to register widget " + widgetType + " more than once!");
    }
    window.__forge2_widgets[widgetType] = widgetClass;
};
// setup theme register function for runtime
window.__forge2_theme_register =
    function (widgetType, themeId, themeClass) {
        if (window.__forge2_themes[themeId]) {
            throw new Error("Error: trying to register theme " + themeId + " more than once!");
        }
        window.__forge2_themes[themeId] = themeClass;
    };

/**
   * Widget scripts
   */

/**
 * Runtime implementation for w-accordion widget
 */
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
    return new (P || (P = Promise))(function (resolve, reject) {
        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
        step((generator = generator.apply(thisArg, _arguments || [])).next());
    });
};
var __generator = (this && this.__generator) || function (thisArg, body) {
    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
    function verb(n) { return function (v) { return step([n, v]); }; }
    function step(op) {
        if (f) throw new TypeError("Generator is already executing.");
        while (_) try {
            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
            if (y = 0, t) op = [op[0] & 2, t.value];
            switch (op[0]) {
                case 0: case 1: t = op; break;
                case 4: _.label++; return { value: op[1], done: false };
                case 5: _.label++; y = op[1]; op = [0]; continue;
                case 7: op = _.ops.pop(); _.trys.pop(); continue;
                default:
                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
                    if (t[2]) _.ops.pop();
                    _.trys.pop(); continue;
            }
            op = body.call(thisArg, _);
        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
    }
};
// runtime widget behaviour class
var WAccordionWidget = /** @class */ (function () {
    function WAccordionWidget() {
        // holds list of possible animations
        this.fAnimateFunctions = new Map();
        // holds if view is currently animating
        this.fIsAnimating = false;
    }
    /**
     * Initializes w-accordion widget behaviour
     */
    WAccordionWidget.prototype.init = function (htmlElement) {
        var _this = this;
        // store html element for later
        this.fHtmlElement = htmlElement;
        // register animation functions
        this.registerAnimationFunctions();
        // parse data of widget stored in html attribute
        this.fData = JSON.parse(atob(htmlElement.getAttribute('data-widget-data')));
        // get element containing cylinder children on export
        var childrenElement = htmlElement;
        // get elements with 'on' and 'off' state
        var onHtmlElement = childrenElement.children.item(0);
        var offHtmlElement = childrenElement.children.item(1);
        // if section should be visible initially
        if (this.fData.initialVisible) {
            // initially hide 'off' element and show 'on' element
            this.changeElementVisibility(offHtmlElement, false);
            this.changeElementVisibility(onHtmlElement, true);
        }
        else {
            // otherwise, show 'off' state, hide 'on' state and hide target element
            if (!this.fData.forceOnState) {
                this.changeElementVisibility(offHtmlElement, true);
                this.changeElementVisibility(onHtmlElement, false);
            }
            else {
                this.changeElementVisibility(offHtmlElement, false);
                this.changeElementVisibility(onHtmlElement, true);
            }
            // query scene element that was set as target
            var targetElement = document.querySelector(".c-" + this.fData.targetId);
            // if target element exists
            if (targetElement) {
                this.changeElementVisibility(targetElement, false);
                targetElement.classList.add('accordion-is-hidden');
            }
        }
        // add click handler
        htmlElement.addEventListener('click', function (evt) { return __awaiter(_this, void 0, void 0, function () {
            var targetElement;
            return __generator(this, function (_a) {
                switch (_a.label) {
                    case 0:
                        // check if its already transitioning
                        if (this.fIsAnimating) {
                            return [2 /*return*/];
                        }
                        // set that we are animating toggle action now to prevent multiple
                        // events and timeouts conflicts
                        this.fIsAnimating = true;
                        // prevent default action, because we are controlling behaviour
                        evt.preventDefault();
                        targetElement = document.querySelector(".c-" + this.fData.targetId);
                        if (!targetElement) return [3 /*break*/, 6];
                        if (!targetElement.classList.contains('accordion-is-hidden')) return [3 /*break*/, 3];
                        // swap on/off displays
                        this.changeElementVisibility(offHtmlElement, false);
                        this.changeElementVisibility(onHtmlElement, true);
                        // toggle out other widgets from same group
                        return [4 /*yield*/, this.toggleOutFromSameGroup()];
                    case 1:
                        // toggle out other widgets from same group
                        _a.sent();
                        // toggle target container
                        return [4 /*yield*/, this.toggleContainer(targetElement, true)];
                    case 2:
                        // toggle target container
                        _a.sent();
                        return [3 /*break*/, 5];
                    case 3:
                        if (!(!this.fData.groupName || this.fData.allowAllClosed)) return [3 /*break*/, 5];
                        // 'off' can be only used for widgets without group name
                        // (eg: checkbox type)
                        // swap on/off displays
                        this.changeElementVisibility(offHtmlElement, true);
                        this.changeElementVisibility(onHtmlElement, false);
                        // toggle target container
                        return [4 /*yield*/, this.toggleContainer(targetElement, false)];
                    case 4:
                        // toggle target container
                        _a.sent();
                        _a.label = 5;
                    case 5:
                        // toggle hidden state
                        targetElement.classList.toggle('accordion-is-hidden');
                        return [3 /*break*/, 7];
                    case 6:
                        console.warn("Warning: No target element for accordion: ' + " + this.fData.targetId);
                        _a.label = 7;
                    case 7:
                        // reset animating flag
                        this.fIsAnimating = false;
                        return [2 /*return*/];
                }
            });
        }); });
    };
    /**
     * Called when widget is no longer needed
     */
    WAccordionWidget.prototype.destroy = function () {
        // no action required here
    };
    /**
     * Fills animation functions map with possible animation types
     */
    WAccordionWidget.prototype.registerAnimationFunctions = function () {
        var _this = this;
        // standard animation
        this.fAnimateFunctions.set('standard', function (element, isVisible) { return __awaiter(_this, void 0, void 0, function () {
            return __generator(this, function (_a) {
                return [2 /*return*/];
            });
        }); });
        // slide type animation
        this.fAnimateFunctions.set('slide', function (element, isVisible) { return __awaiter(_this, void 0, void 0, function () {
            return __generator(this, function (_a) {
                switch (_a.label) {
                    case 0: 
                    // animate slide
                    return [4 /*yield*/, this.animateSlide(element, isVisible)];
                    case 1:
                        // animate slide
                        _a.sent();
                        return [2 /*return*/];
                }
            });
        }); });
    };
    /**
     * Toggles target container with proper state, based on selected animation
     */
    WAccordionWidget.prototype.toggleContainer = function (container, isVisible) {
        return __awaiter(this, void 0, Promise, function () {
            var animationFunction;
            return __generator(this, function (_a) {
                switch (_a.label) {
                    case 0:
                        animationFunction = this.fAnimateFunctions.get(this.fData.animationType);
                        // if it does not exist, throw an error
                        if (!animationFunction) {
                            throw new Error("Error: Animation function of type " + this.fData.animationType + " does not exist.");
                        }
                        // set that we are currently animating
                        this.fIsAnimating = true;
                        // otherwise, use proper animation function and await until its finished
                        return [4 /*yield*/, animationFunction(container, isVisible)];
                    case 1:
                        // otherwise, use proper animation function and await until its finished
                        _a.sent();
                        // and then force display styles on target element
                        if (isVisible) {
                            container.style.removeProperty('display');
                        }
                        else {
                            this.changeElementVisibility(container, false);
                            // this is a hack for video widget that will be hidden, sigh
                            this.videoWidgetHack(container);
                        }
                        return [2 /*return*/];
                }
            });
        });
    };
    /**
     * This hack stops all e-video widgets that are currently playing.
     * This should be done in more nice way but I do not want to implement
     * event system for single case.
     */
    WAccordionWidget.prototype.videoWidgetHack = function (container) {
        // get array of <iframes> with youtube
        var videoElements = Array.from(container.querySelectorAll('.e-video_iframe'));
        // iterate over array
        videoElements.forEach(function (videoElement) {
            // get iframe object from element, TS does not have typings for this
            // so I must cast it as any
            var iframe = videoElement.contentWindow;
            // just safetly check
            if (iframe) {
                // compose msg to youtube iframe
                var msgData = {
                    event: 'command',
                    func: 'pauseVideo',
                    args: '',
                };
                // and post it to pause video
                iframe.postMessage(JSON.stringify(msgData), '*');
            }
        });
    };
    WAccordionWidget.prototype.replaceAll = function (str, find, replace) {
        return str.replace(new RegExp(find, 'g'), replace);
    };
    /**
     * Toggles other accordion widgets from same group name
     */
    WAccordionWidget.prototype.toggleOutFromSameGroup = function () {
        return __awaiter(this, void 0, Promise, function () {
            var group, groupClass, groupedAccordions, promises;
            var _this = this;
            return __generator(this, function (_a) {
                // if this accordion does not have group set, ignore this function
                if (!this.fData.groupName) {
                    return [2 /*return*/, []];
                }
                group = this.replaceAll(this.fData.groupName, ' ', '-');
                groupClass = "group-" + group;
                groupedAccordions = Array.from(document.querySelectorAll(".e-accordion." + groupClass))
                    .filter(function (el) { return el !== _this.fHtmlElement; });
                promises = groupedAccordions.map(function (accordionElement) { return __awaiter(_this, void 0, void 0, function () {
                    var childrenElement, onHtmlElement, offHtmlElement, accordionData, targetElement;
                    return __generator(this, function (_a) {
                        switch (_a.label) {
                            case 0:
                                childrenElement = accordionElement;
                                onHtmlElement = childrenElement.children.item(0);
                                offHtmlElement = childrenElement.children.item(1);
                                accordionData = JSON.parse(atob(accordionElement.getAttribute('data-widget-data')));
                                // "turn off" accordion (if no 'force on' option if present)
                                if (!accordionData.forceOnState) {
                                    this.changeElementVisibility(onHtmlElement, false);
                                    this.changeElementVisibility(offHtmlElement, true);
                                }
                                targetElement = document.querySelector(".c-" + accordionData.targetId);
                                if (!targetElement) return [3 /*break*/, 2];
                                targetElement.classList.add('accordion-is-hidden');
                                return [4 /*yield*/, this.toggleContainer(targetElement, false)];
                            case 1:
                                _a.sent();
                                return [3 /*break*/, 3];
                            case 2:
                                console.warn("Warning: No target element for accordion: ' + " + accordionData.targetId);
                                _a.label = 3;
                            case 3: return [2 /*return*/];
                        }
                    });
                }); });
                return [2 /*return*/, Promise.all(promises)];
            });
        });
    };
    /**
     * Makes 'slide' animation on target element
     */
    WAccordionWidget.prototype.animateSlide = function (element, isVisible) {
        var _this = this;
        var ANIMATION_TIME = 300;
        return new Promise(function (resolve, reject) {
            if (isVisible) {
                _this.slideDown(element, ANIMATION_TIME, resolve);
            }
            else {
                _this.slideUp(element, ANIMATION_TIME, resolve);
            }
        });
    };
    WAccordionWidget.prototype.slideUp = function (el, duration, callback) {
        this.slide(el, duration, callback);
    };
    ;
    WAccordionWidget.prototype.slideDown = function (el, duration, callback) {
        this.slide(el, duration, callback, true);
    };
    ;
    WAccordionWidget.prototype.slide = function (el, duration, callback, isDown) {
        if (typeof isDown === 'undefined') {
            isDown = false;
        }
        el.style.overflow = "hidden";
        if (isDown) {
            el.style.display = "block";
        }
        var elStyles = window.getComputedStyle(el);
        var elHeight = parseFloat(elStyles.getPropertyValue('height'));
        var elPaddingTop = parseFloat(elStyles.getPropertyValue('padding-top'));
        var elPaddingBottom = parseFloat(elStyles.getPropertyValue('padding-bottom'));
        var elMarginTop = parseFloat(elStyles.getPropertyValue('margin-top'));
        var elMarginBottom = parseFloat(elStyles.getPropertyValue('margin-bottom'));
        var stepHeight = elHeight / duration;
        var stepPaddingTop = elPaddingTop / duration;
        var stepPaddingBottom = elPaddingBottom / duration;
        var stepMarginTop = elMarginTop / duration;
        var stepMarginBottom = elMarginBottom / duration;
        var start;
        function step(timestamp) {
            if (start === undefined) {
                start = timestamp;
            }
            var elapsed = timestamp - start;
            if (isDown) {
                el.style.height = (stepHeight * elapsed) + "px";
                el.style.paddingTop = (stepPaddingTop * elapsed) + "px";
                el.style.paddingBottom = (stepPaddingBottom * elapsed) + "px";
                el.style.marginTop = (stepMarginTop * elapsed) + "px";
                el.style.marginBottom = (stepMarginBottom * elapsed) + "px";
            }
            else {
                el.style.height = elHeight - (stepHeight * elapsed) + "px";
                el.style.paddingTop = elPaddingTop - (stepPaddingTop * elapsed) + "px";
                el.style.paddingBottom = elPaddingBottom - (stepPaddingBottom * elapsed) + "px";
                el.style.marginTop = elMarginTop - (stepMarginTop * elapsed) + "px";
                el.style.marginBottom = elMarginBottom - (stepMarginBottom * elapsed) + "px";
            }
            if (elapsed >= duration) {
                el.style.height = "";
                el.style.paddingTop = "";
                el.style.paddingBottom = "";
                el.style.marginTop = "";
                el.style.marginBottom = "";
                el.style.overflow = "";
                if (!isDown) {
                    el.style.display = "none";
                }
                callback();
            }
            else {
                window.requestAnimationFrame(step);
            }
        }
        window.requestAnimationFrame(step);
    };
    /**
     * Helper function that displays/hides target html element.
     * During hiding saves original display of the element, to return it to original value during showing.
     */
    WAccordionWidget.prototype.changeElementVisibility = function (element, value) {
        var currentDisplay = window.getComputedStyle(element).display;
        // If we want to hide element, and it has no saved display value, save it
        if (!value && !element.dataset.display) {
            element.dataset.display = currentDisplay;
        }
        // Hide or show element
        if (!value) {
            element.style.setProperty('display', 'none');
        }
        else if (currentDisplay === 'none') {
            // Toggle visibility "on" only if element is already hidden, default to block
            element.style.setProperty('display', element.dataset.display || 'block');
        }
    };
    return WAccordionWidget;
}());
window.__forge2_widget_register('e-accordion', WAccordionWidget);

/**
   * End of widget scripts
   */

/**
   * Widget themes
   */

/**
   * End of widget themes
   */

/**
   * Basic runtime code
   */
  
  /**
 * This module is responsible for providing support for runtime widgets.
 */
/**
 * Define enableWidget function that will accept widgetType and will inject
 * runtime behaviour to DOM element based on widgetType argument.
 */
// initialize variables
window.__forge2_runner = window.__forge2_runner || 0;
window.__forge2_runner_counter = window.__forge2_runner_counter || 0;
// increment the current runner number
window.__forge2_runner_counter++;
// assign runner number for THIS script
var runnerNumber = window.__forge2_runner_counter;
// assign the global runner value to THIS runner
window.__forge2_runner = runnerNumber;
function enableWidget(widgetType) {
    // if this widget type does not have runtime behaviour class,
    // just skip it
    if (!window.__forge2_widgets[widgetType]) {
        return;
    }
    // get widget runtime class for particular widget type
    var widgetClass = window.__forge2_widgets[widgetType];
    // get all elements with class matching widget type (eg: w-countdown -> .w-countdown)
    var elements = Array.from(document.querySelectorAll("." + widgetType));
    // initialize all widgett elements found
    elements.forEach(function (rootElement) {
        if (!rootElement.hasAttribute('vued-init')) {
            rootElement.setAttribute('vued-init', 'true');
            // create widget class instance for this element
            var widgetClassInstance = new widgetClass();
            // and inject it
            widgetClassInstance.init(rootElement, window.__forge2_context);
        }
    });
}
function initForgeWidgets() {
    // check whether THIS runner is the global runner
    if (!window.__forge2_runner || (runnerNumber === window.__forge2_runner)) {
        // get array of widget types from repository
        var widgetTypes = Array.from(Object.keys(window.__forge2_widgets));
        // enable all widgets
        widgetTypes.forEach(function (widgetType) { return enableWidget(widgetType); });
    }
}
/**
 * Called when window is fully loaded, enables all widgets runtime behaviour.
 */
if (document.readyState === 'complete') {
    initForgeWidgets();
}
else {
    // @ts-ignore
    if (typeof window['_editorApi'] !== 'undefined') {
        // @ts-ignore
        if (window['_editorApi'].isReady) {
            initForgeWidgets();
        }
        else {
            // @ts-ignore
            window['_editorApi'].onReady(function () {
                initForgeWidgets();
            });
        }
    }
    else {
        window.addEventListener('load', function () {
            initForgeWidgets();
        });
    }
}

})();

Charakterystyka

Rodzaj	Oczyszczacz powietrza
Rodzaj filtra	HEPA, Węglowy, Wstępny
Filtracja powietrza	Tak
Technologia oczyszczania	Wielostopniowa
Nawilżanie	Nie
Wskaźnik zanieczyszczenia powietrza	Tak
Wskaźnik wymiany filtra	Nie

Techniczne

Moc [W]	90
Poziom hałasu [dB]	20
Maksymalna powierzchnia pomieszczenia [m2]	90
Sterowanie smartfonem	Tak
Jonizator	Nie
Timer	Tak
Funkcje dodatkowe	Czujnik laserowy, Dezodoryzacja, Możliwość sterowania za pomocą smartfona, Tryb Auto, Tryb nocny, Wyświetlacz LED, Zabezpieczenie przed dziećmi
Wyposażenie dodatkowe	Filtr HEPA, Filtr węglowy, Filtr wstępny
Wysokość [mm]	1054
Szerokość [mm]	360
Głębokość [mm]	285
Tryb pracy	Auto, Nocny
Waga z opakowaniem [kg]	18.40

Parametry

Kolor	Biały
Model producenta	AX90R7080WD/EU
Gwarancja	24 miesiące, Door To Door
Załączona dokumentacja	Instrukcja obsługi w języku polskim, Karta gwarancyjna
Przeznaczenie	Do użytku domowego

Dokumenty do pobrania

Szczegółowe warunki gwarancji	Pobierz
Instrukcja obsługi	Pobierz

Producent

Nazwa producenta/importera

Samsung Electronics Polska sp. z o.o.

Akcesoria

Opinie

Gwarancje

Oczyszczacz powietrza SAMSUNG AX90R7080WD/EU	Gwarancja Plus Pełna Ochrona	Gwarancja Plus	STANDARDOWA GWARANCJA PRODUCENTA
Urządzenie nie włącza się? Naprawa awarii możliwa nawet do 5 lat od zakupu.
Naprawa po gwarancji producenta okaże się niemożliwa? Wymienimy sprzęt na nowy.
Awaria sprzętu o wartości do 300 PLN? Otrzymasz nowy sprzęt bez próby naprawy.
Urządzenie przestało działać w wyniku przepięcia prądu? Naprawimy lub wymienimy, jeśli naprawa okaże się niemożliwa.
Urządzenie uszkodzone w wyniku nieszczęśliwego wypadku? Nic straconego, zgłoś i opisz szkodę, a naprawimy Twój sprzęt.
Zalanie sprzętu w wyniku nieszczęśliwego wypadku? Nie martw się, ochrona przed zalaniem działa już od dnia sprzedaży.
Ilość lat pakietu gwarancyjnego Warunki ubezpieczenia	Do 3 lat 504,00 14 złco miesiąc/mc Do 5 lat 728,00 12 złco miesiąc/mc	Do 3 lat 280,00 8 złco miesiąc/mc Do 5 lat 560,00 9 złco miesiąc/mc	Standardowa gwarancja

Warunki ubezpieczenia

Raty

Funkcje	Filtracja powietrza, Wskaźnik zanieczyszczenia powietrza, Sterowanie smartfonem, Timer	Rodzaj filtra	HEPA, Węglowy, Wstępny
Technologia oczyszczania	Wielostopniowa	Wskaźnik wymiany filtra	Nie
Moc [W]	90	Poziom hałasu [dB]	20
Maksymalna powierzchnia pomieszczenia [m2]	90	Kolor	Biały
Kod produktu	555419	Atest Polskiego Towarzystwa AlergologicznegoWyjątkowo cichy tryb nocny - 20 dB

Oczyszczacz powietrza SAMSUNG AX90R7080WD/EU

Rodzaj filtra

Moc [W]

Poziom hałasu [dB]

Maksymalna powierzchnia pomieszczenia [m2]

Rodzaj filtra

Wskaźnik zanieczyszczenia powietrza

Moc [W]

Poziom hałasu [dB]

Maksymalna powierzchnia pomieszczenia [m2]

Sterowanie smartfonem