iobroker.miele-local 0.2.0

package/lib/enums_de.js

@@ -0,0 +1,237 @@
+'use strict';
+
+// Deutsche Übersetzungen der Miele-Enums (an mielecloudservice-Begriffe angelehnt:
+// in_use→"In Betrieb", off→"Aus", main_wash→"Waschen"). Fallback = englischer Schlüssel.
+
+const StateStatusDe = {
+    0: 'Reserviert', 1: 'Aus', 2: 'Ein', 3: 'Programmiert', 4: 'Warten auf Start',
+    5: 'In Betrieb', 6: 'Pause', 7: 'Programm beendet', 8: 'Fehler', 9: 'Programm unterbrochen',
+    10: 'Bereit', 11: 'Spülstopp', 12: 'Service', 13: 'SuperFrost', 14: 'SuperKühlen',
+    15: 'Aufheizen', 146: 'SuperKühlen/SuperFrost', 147: 'Selbstreinigung', 255: 'Nicht verbunden',
+};
+
+const StateProgramTypeDe = {
+    0: 'Normalbetrieb', 1: 'Eigenes Programm', 2: 'Automatikprogramm', 3: 'Automatikprogramm', 4: 'Wartungsprogramm',
+};
+
+const StateDryingStepDe = {
+    0: 'Extra trocken', 1: 'Normal plus', 2: 'Normal', 3: 'Leicht trocken', 4: 'Handtuchtrocken',
+    5: 'Bügeltrocken', 6: 'Schranktrocken', 7: 'Schranktrocken plus',
+};
+
+const ProgramPhaseWashingMachineDe = {
+    0: '', 256: '', 257: 'Vorwäsche', 258: 'Einweichen', 259: 'Vorwäsche', 260: 'Waschen',
+    261: 'Spülen', 262: 'Spülstopp', 263: 'Reinigung', 264: 'Abkühlen', 265: 'Abpumpen',
+    266: 'Schleudern', 267: 'Knitterschutz', 268: 'Ende', 269: 'Belüften', 270: 'Stärkestopp',
+    271: 'Auffrischen/Befeuchten', 272: 'Dampfglätten', 279: 'Hygiene', 280: 'Trocknen',
+    285: 'Desinfizieren', 295: 'Dampfglätten', 11004: 'Waschen', 11005: 'Spülen', 11010: 'Schleudern',
+    11012: 'Ende', 11029: 'Knitterschutz', 11044: 'Automatikstart', 11047: 'FlexLoad aktiv', 65535: '',
+};
+
+const ProgramPhaseDishwasherDe = {
+    0: '', 1792: '', 1793: 'Regenerieren', 1794: 'Vorspülen', 1795: 'Reinigen', 1796: 'Spülen',
+    1797: 'Zwischenspülen', 1798: 'Klarspülen', 1799: 'Trocknen', 1800: 'Ende', 1801: 'Vorspülen', 65535: '',
+};
+
+const ProgramPhaseOvenDe = {
+    0: '', 3073: 'Aufheizen', 3074: 'In Betrieb', 3078: 'Beendet', 3080: 'Anbraten',
+    3081: 'Braten', 3084: 'Energiesparen', 3099: 'Vorheizen', 65535: '',
+};
+
+// Programmnamen (Schlüssel = englischer Enum-Wert aus enums.js → Deutsch).
+const ProgramNameDe = {
+    // gemeinsame
+    no_program: '',
+    // Waschmaschine
+    cottons: 'Baumwolle', minimum_iron: 'Pflegeleicht', easy_care: 'Pflegeleicht',
+    delicates: 'Feinwäsche', woollens: 'Wolle', silks: 'Seide', starch: 'Stärken',
+    rinse: 'Spülen', drain_spin: 'Abpumpen/Schleudern', curtains: 'Gardinen',
+    shirts: 'Oberhemden', denim: 'Jeans', proofing: 'Imprägnieren', sportswear: 'Sportbekleidung',
+    automatic_plus: 'Automatic Plus', outerwear: 'Outdoor', pillows: 'Kopfkissen',
+    dark_garments: 'Dunkles/Jeans', dark_jeans: 'Dunkles/Jeans', separate_rinse_starch: 'Separates Spülen/Stärken',
+    first_wash: 'Erstwäsche', cottons_hygiene: 'Baumwolle Hygiene', cottons_eco: 'Baumwolle Eco',
+    trainers: 'Sportschuhe', trainers_refresh: 'Sportschuhe auffrischen', clean_machine: 'Maschine reinigen',
+    down_duvets: 'Daunen', down_filled_items: 'Daunen', express_20: 'Express 20',
+    quick_power_wash: 'QuickPowerWash', eco_40_60: 'Eco 40-60', bed_linen: 'Bettwäsche',
+    outdoor_garments: 'Outdoor', pre_ironing: 'Vorbügeln', cottonrepair: 'CottonRepair',
+    smartmatic: 'SmartMatic', stuffed_toys: 'Kuscheltiere', game_pieces: 'Spielsachen', powerfresh: 'PowerFresh',
+    // Spülmaschine
+    intensive: 'Intensiv', maintenance: 'Maschinenpflege', eco: 'Eco', automatic: 'Automatic',
+    solar_save: 'Solarspar', gentle: 'Schonen', extra_quiet: 'Extra leise', hygiene: 'Hygiene',
+    pasta_paela: 'Pasta/Paella', tall_items: 'Große Teile', glasses_warm: 'Gläser warm',
+    normal: 'Normal', comfort_wash: 'ComfortWash', comfort_wash_plus: 'ComfortWash Plus',
+    power_wash: 'PowerWash', rinse_salt: 'Spülen/Salz',
+    // Backofen – Betriebsarten
+    conventional_heat: 'Ober-/Unterhitze', top_heat: 'Oberhitze', bottom_heat: 'Unterhitze',
+    fan_plus: 'Umluft', eco_fan_heat: 'Eco Umluft', fan_grill: 'Umluftgrill', grill: 'Grill',
+    full_grill: 'Großflächengrill', economy_grill: 'Spargrill', intensive_bake: 'Intensivbacken',
+    auto_roast: 'Automatikbraten', low_temperature_cooking: 'Niedertemperaturgaren',
+    moisture_plus_conventional_heat: 'Feuchtigkeit plus – Ober-/Unterhitze',
+    moisture_plus_fan_plus: 'Feuchtigkeit plus – Umluft',
+    moisture_plus_auto_roast: 'Feuchtigkeit plus – Automatikbraten',
+    moisture_plus_intensive_bake: 'Feuchtigkeit plus – Intensivbacken',
+    microwave: 'Mikrowelle', microwave_fan_plus: 'Mikrowelle – Umluft',
+    microwave_grill: 'Mikrowelle – Grill', microwave_fan_grill: 'Mikrowelle – Umluftgrill',
+    microwave_auto_roast: 'Mikrowelle – Automatikbraten', quick_microwave: 'Schnell-Mikrowelle',
+    steam_cooking: 'Dampfgaren', steam_bake: 'Dampfbacken', defrost: 'Auftauen',
+    defrost_meat: 'Fleisch auftauen', defrost_vegetables: 'Gemüse auftauen',
+    keeping_warm: 'Warmhalten', heat_crockery: 'Geschirr wärmen',
+    heating_bakes_gratins: 'Aufläufe/Gratins', heating_vegetables: 'Gemüse erwärmen',
+    evaporate_water: 'Wasser verdampfen', descale: 'Entkalken', pyrolytic: 'Pyrolyse',
+    drying: 'Trocknen', prove_dough: 'Teig gehen lassen', prove_15_min: 'Teig gehen (15 min)',
+    prove_30_min: 'Teig gehen (30 min)', prove_45_min: 'Teig gehen (45 min)', popcorn: 'Popcorn',
+    shabbat_program: 'Schabbat-Programm', yom_tov: 'Jom Tov',
+    // Backofen – eigene Programme
+    custom_program_1: 'Eigenes Programm 1', custom_program_2: 'Eigenes Programm 2',
+    custom_program_3: 'Eigenes Programm 3', custom_program_4: 'Eigenes Programm 4',
+    custom_program_5: 'Eigenes Programm 5', custom_program_6: 'Eigenes Programm 6',
+    custom_program_7: 'Eigenes Programm 7', custom_program_8: 'Eigenes Programm 8',
+    custom_program_9: 'Eigenes Programm 9', custom_program_10: 'Eigenes Programm 10',
+    custom_program_11: 'Eigenes Programm 11', custom_program_12: 'Eigenes Programm 12',
+    custom_program_13: 'Eigenes Programm 13', custom_program_14: 'Eigenes Programm 14',
+    custom_program_15: 'Eigenes Programm 15', custom_program_16: 'Eigenes Programm 16',
+    custom_program_17: 'Eigenes Programm 17', custom_program_18: 'Eigenes Programm 18',
+    custom_program_19: 'Eigenes Programm 19', custom_program_20: 'Eigenes Programm 20',
+    // Backofen – Brot & Brötchen
+    white_bread_baking_tin: 'Weißbrot (Kastenform)', white_bread_on_tray: 'Weißbrot (Blech)',
+    white_rolls: 'Weiße Brötchen', multigrain_rolls: 'Mehrkornbrötchen', rye_rolls: 'Roggenbrötchen',
+    mixed_rye_bread: 'Roggenmischbrot', dark_mixed_grain_bread: 'Dunkles Mehrkornbrot',
+    spelt_bread: 'Dinkelbrot', walnut_bread: 'Walnussbrot', seeded_loaf: 'Saatenbrot',
+    flat_bread: 'Fladenbrot', baguettes: 'Baguette', plaited_loaf: 'Hefezopf',
+    plaited_swiss_loaf: 'Schweizer Zopf', swiss_farmhouse_bread: 'Schweizer Bauernbrot',
+    tiger_bread: 'Tigerbrot', ginger_loaf: 'Ingwerkuchen', stollen: 'Stollen',
+    // Backofen – Kuchen & Gebäck
+    apple_pie: 'Apfelkuchen', apple_sponge: 'Apfel-Biskuit', butter_cake: 'Butterkuchen',
+    marble_cake: 'Marmorkuchen', madeira_cake: 'Sandkuchen', belgian_sponge_cake: 'Belgischer Biskuit',
+    swiss_roll: 'Biskuitrolle', sponge_base: 'Biskuitboden', sachertorte: 'Sachertorte',
+    fruit_streusel_cake: 'Obst-Streuselkuchen', fruit_flan_puff_pastry: 'Obstkuchen (Blätterteig)',
+    fruit_flan_short_crust_pastry: 'Obstkuchen (Mürbeteig)',
+    savoury_flan_puff_pastry: 'Herzhafter Kuchen (Blätterteig)',
+    savoury_flan_short_crust_pastry: 'Herzhafter Kuchen (Mürbeteig)',
+    chocolate_hazlenut_cake_one_large: 'Schoko-Nuss-Kuchen (groß)',
+    chocolate_hazlenut_cake_several_small: 'Schoko-Nuss-Kuchen (klein)',
+    viennese_apple_strudel: 'Wiener Apfelstrudel', lemon_meringue_pie: 'Zitronen-Baiser-Torte',
+    quiche_lorraine: 'Quiche Lorraine', cheese_souffle: 'Käsesoufflé', choux_buns: 'Windbeutel',
+    springform_tin_15cm: 'Springform 15 cm', springform_tin_20cm: 'Springform 20 cm',
+    springform_tin_25cm: 'Springform 25 cm',
+    // Backofen – Kekse & Kleingebäck
+    vanilla_biscuits_1_tray: 'Vanillekipferl (1 Blech)', vanilla_biscuits_2_trays: 'Vanillekipferl (2 Bleche)',
+    almond_macaroons_1_tray: 'Mandelmakronen (1 Blech)', almond_macaroons_2_trays: 'Mandelmakronen (2 Bleche)',
+    biscuits_short_crust_pastry_1_tray: 'Mürbeteigplätzchen (1 Blech)',
+    biscuits_short_crust_pastry_2_trays: 'Mürbeteigplätzchen (2 Bleche)',
+    drop_cookies_1_tray: 'Spritzgebäck (1 Blech)', drop_cookies_2_trays: 'Spritzgebäck (2 Bleche)',
+    linzer_augen_1_tray: 'Linzer Augen (1 Blech)', linzer_augen_2_trays: 'Linzer Augen (2 Bleche)',
+    baiser_one_large: 'Baiser (groß)', baiser_several_small: 'Baiser (mehrere kleine)',
+    blueberry_muffins: 'Blaubeer-Muffins', walnut_muffins: 'Walnuss-Muffins',
+    // Backofen – Pizza & Flammkuchen
+    pizza_yeast_dough_baking_tray: 'Pizza Hefeteig (Blech)', pizza_yeast_dough_round_baking_tine: 'Pizza Hefeteig (rund)',
+    pizza_oil_cheese_dough_baking_tray: 'Pizza Öl-Käse-Teig (Blech)',
+    pizza_oil_cheese_dough_round_baking_tine: 'Pizza Öl-Käse-Teig (rund)', tart_flambe: 'Flammkuchen',
+    // Backofen – Fleisch (Rind/Kalb)
+    roast_beef_roast: 'Roastbeef braten', roast_beef_low_temperature_cooking: 'Roastbeef (Niedertemperatur)',
+    beef_fillet_roast: 'Rinderfilet braten', beef_fillet_low_temperature_cooking: 'Rinderfilet (Niedertemperatur)',
+    braised_beef: 'Schmorbraten (Rind)', beef_wellington: 'Beef Wellington', beef_hash: 'Rinderhackgericht',
+    meat_loaf: 'Hackbraten', braised_veal: 'Schmorbraten (Kalb)', veal_fillet_roast: 'Kalbsfilet braten',
+    veal_fillet_low_temperature_cooking: 'Kalbsfilet (Niedertemperatur)', saddle_of_veal_roast: 'Kalbsrücken braten',
+    saddle_of_veal_low_temperature_cooking: 'Kalbsrücken (Niedertemperatur)', veal_knuckle: 'Kalbshaxe',
+    // Backofen – Fleisch (Schwein/Lamm/Wild)
+    pork_fillet_roast: 'Schweinefilet braten', pork_fillet_low_temperature_cooking: 'Schweinefilet (Niedertemperatur)',
+    pork_belly: 'Schweinebauch', pork_with_crackling: 'Krustenbraten', ham_roast: 'Schinkenbraten',
+    pork_smoked_ribs_roast: 'Kasseler braten', pork_smoked_ribs_low_temperature_cooking: 'Kasseler (Niedertemperatur)',
+    leg_of_lamb: 'Lammkeule', saddle_of_lamb_roast: 'Lammrücken braten',
+    saddle_of_lamb_low_temperature_cooking: 'Lammrücken (Niedertemperatur)',
+    rack_of_lamb_with_vegetables: 'Lammkarree mit Gemüse', saddle_of_roebuck: 'Rehrücken',
+    saddle_of_venison: 'Hirschrücken', osso_buco: 'Osso Buco', rabbit: 'Kaninchen',
+    // Backofen – Geflügel
+    chicken_whole: 'Hähnchen (ganz)', chicken_thighs: 'Hähnchenschenkel', duck: 'Ente',
+    goose_stuffed: 'Gans (gefüllt)', goose_unstuffed: 'Gans (ungefüllt)', turkey_whole: 'Pute (ganz)',
+    turkey_drumsticks: 'Putenkeulen',
+    // Backofen – Fisch
+    salmon_fillet: 'Lachsfilet', salmon_trout: 'Lachsforelle', trout: 'Forelle', carp: 'Karpfen',
+    pikeperch_fillet_with_vegetables: 'Zanderfilet mit Gemüse',
+    // Backofen – Beilagen & Sonstiges
+    potato_gratin: 'Kartoffelgratin', potato_cheese_gratin: 'Kartoffel-Käse-Gratin',
+    yorkshire_pudding: 'Yorkshire Pudding',
+    // Trockner
+    basket_program: 'Korbprogramm', cool_air: 'Kaltluft', downs_duvets: 'Daunen', express: 'Express',
+    gentle_denim: 'Schonend Jeans', gentle_smoothing: 'Schonend Glätten', large_pillows: 'Große Kopfkissen',
+    pillows_sanitize: 'Kopfkissen Hygiene', quick_hygiene: 'Schnell Hygiene', quick_power_dry: 'QuickPowerDry',
+    silks_handcare: 'Seide Handpflege', smoothing: 'Glätten', standard_pillows: 'Kopfkissen',
+    steam_smoothing: 'Dampfglätten', warm_air: 'Warmluft', woollens_handcare: 'Wolle Handpflege',
+    // Kaffeevollautomat
+    appliance_rinse: 'Gerätespülung', automatic_maintenance: 'Automatische Pflege', barista_assistant: 'Barista-Assistent',
+    black_tea: 'Schwarzer Tee', brewing_unit_degrease: 'Brüheinheit entfetten', cafe_au_lait: 'Café au Lait',
+    caffe_latte: 'Caffè Latte', cappuccino: 'Cappuccino', cappuccino_italiano: 'Cappuccino Italiano',
+    check_appliance: 'Gerät prüfen', coffee: 'Kaffee', coffee_pot: 'Kaffeekanne', descaling: 'Entkalken',
+    espresso: 'Espresso', espresso_macchiato: 'Espresso Macchiato', flat_white: 'Flat White',
+    fruit_tea: 'Früchtetee', green_tea: 'Grüner Tee', herbal_tea: 'Kräutertee', hot_milk: 'Heiße Milch',
+    hot_water: 'Heißwasser', intermediate_rinsing: 'Zwischenspülung', japanese_tea: 'Japanischer Tee',
+    latte_macchiato: 'Latte Macchiato', long_coffee: 'Langer Kaffee', milk_foam: 'Milchschaum',
+    milk_pipework_clean: 'Milchleitung reinigen', milk_pipework_rinse: 'Milchleitung spülen',
+    ristretto: 'Ristretto', very_hot_water: 'Sehr heißes Wasser', white_tea: 'Weißer Tee',
+    // Wärmeschublade
+    keep_warm: 'Warmhalten', slow_roasting: 'Niedertemperaturgaren',
+    warm_cups_glasses: 'Tassen/Gläser wärmen', warm_dishes_plates: 'Geschirr/Teller wärmen',
+};
+
+/**
+ * Deutsche Phasennamen, keyed nach ENGLISCHEM Enum-Wert (wie ProgramNameDe) - deckt so alle
+ * Gerätetypen auf einmal ab. Wird als Fallback nach den numerischen BY_TYPE_DE-Tabellen genutzt
+ * (siehe objects.js phaseTextDe), sodass bestehende Übersetzungen unveraendert bleiben.
+ */
+const PhaseNameDe = {
+    not_running: '', program_running: 'In Betrieb', process_running: 'In Betrieb',
+    drying: 'Trocknen', finished: 'Ende', process_finished: 'Beendet', cooling_down: 'Abkühlen',
+    comfort_cooling: 'Komfortabkühlen', safety_cooling: 'Sicherheitsabkühlung', anti_crease: 'Knitterschutz',
+    normal: 'Normal', normal_plus: 'Normal plus', extra_dry: 'Extratrocken', slightly_dry: 'Leicht trocken',
+    hand_iron: 'Bügelfeucht', hand_iron_1: 'Handbügelfeucht 1', hand_iron_2: 'Handbügelfeucht 2',
+    machine_iron: 'Maschinenbügelfeucht', moisten: 'Befeuchten', thermo_spin: 'Thermoschleudern',
+    timed_drying: 'Zeitprogramm', warm_air: 'Warmluft', steam_smoothing: 'Dampfglätten', smoothing: 'Glätten',
+    rinse_out_lint: 'Flusen ausspülen', rinses: 'Spülen', rinse: 'Spülen', automatic_start: 'Automatikstart',
+    perfect_dry_active: 'PerfectDry aktiv',
+    // Kaffeevollautomat
+    heating_up: 'Aufheizen', espresso: 'Espresso', hot_milk: 'Heiße Milch', milk_foam: 'Milchschaum',
+    dispensing: 'Ausgabe', pre_brewing: 'Vorbrühen', grinding: 'Mahlen', second_espresso: 'Zweiter Espresso',
+    second_pre_brewing: 'Zweites Vorbrühen', second_grinding: 'Zweites Mahlen',
+    // Dampfgarer / Dampfbackofen
+    steam_reduction: 'Dampfreduktion', waiting_for_start: 'Warten auf Start', heating_up_phase: 'Aufheizphase',
+    searing: 'Anbraten', roasting: 'Braten', energy_save: 'Energiesparen', pre_heating: 'Vorheizen',
+    // Wärmeschublade
+    door_open: 'Tür offen', keeping_warm: 'Warmhalten',
+};
+
+/** Deutscher Phasenname aus englischem Enum-Wert; null wenn unbekannt (Fallback engl.). */
+function phaseNameDe(enText) {
+    if (enText == null) return null;
+    return PhaseNameDe[enText] != null ? PhaseNameDe[enText] : null;
+}
+
+/** Deutscher Programmname aus englischem Enum-Wert; null wenn unbekannt (Fallback engl.). */
+function programNameDe(enText) {
+    if (enText == null) return null;
+    return ProgramNameDe[enText] != null ? ProgramNameDe[enText] : null;
+}
+
+// deviceType → { statusDe, phaseDe, programDe? }
+const BY_TYPE_DE = {
+    1: { phase: ProgramPhaseWashingMachineDe },   // Waschmaschine
+    2: { phase: ProgramPhaseWashingMachineDe },   // Trockner (nutzt DryingStep separat)
+    24: { phase: ProgramPhaseWashingMachineDe },  // Waschtrockner
+    7: { phase: ProgramPhaseDishwasherDe },       // Spülmaschine
+    12: { phase: ProgramPhaseOvenDe },            // Backofen
+    13: { phase: ProgramPhaseOvenDe },
+};
+
+function statusDe(v) { return StateStatusDe[v] != null ? StateStatusDe[v] : null; }
+function programTypeDe(v) { return StateProgramTypeDe[v] != null ? StateProgramTypeDe[v] : null; }
+function dryingStepDe(v) { return StateDryingStepDe[v] != null ? StateDryingStepDe[v] : null; }
+function phaseDe(deviceType, v) {
+    const m = BY_TYPE_DE[deviceType];
+    if (m && m.phase && m.phase[v] != null) return m.phase[v];
+    return null;
+}
+
+module.exports = {
+    StateStatusDe, StateProgramTypeDe, StateDryingStepDe, ProgramNameDe, PhaseNameDe,
+    statusDe, programTypeDe, dryingStepDe, phaseDe, programNameDe, phaseNameDe,
+};

package/lib/objects.js

@@ -0,0 +1,285 @@
+'use strict';
+
+/**
+ * Deklaratives Objektmodell: /State- und /Ident-Felder → ioBroker-States.
+ * Enthält Rollen, Typen, Einheiten und Dekodierfunktionen.
+ */
+
+const enums = require('./enums');
+const de = require('./enums_de');
+
+const TEMP_SENTINEL = -32768; // "nicht verfügbar"
+
+/** [h, min] → Gesamtminuten (null bei fehlend). */
+function timeToMinutes(arr) {
+    if (!Array.isArray(arr) || arr.length < 2) return null;
+    return arr[0] * 60 + arr[1];
+}
+
+/** [h, min] → "H:MM"-String (wie mielecloudservice), null bei fehlend. */
+function timeToHHMM(arr) {
+    if (!Array.isArray(arr) || arr.length < 2) return null;
+    return `${arr[0]}:${String(arr[1]).padStart(2, '0')}`;
+}
+
+// Deutsch mit englischem Fallback
+function statusTextDe(v) { return de.statusDe(v) || enums.statusText(v); }
+function programTypeTextDe(v) { return de.programTypeDe(v) || enums.programTypeText(v); }
+function dryingStepTextDe(v) { return de.dryingStepDe(v) || enums.dryingStepText(v); }
+function programTextDe(dt, v) { const en = enums.programText(dt, v); return de.programNameDe(en) || en; }
+// Phase: erst numerische DE-Tabelle (Waschen/Spülen/Backofen), dann englisch-basierte DE-Map
+// (deckt alle uebrigen Gerätetypen ab), sonst englischer Klartext.
+function phaseTextDe(dt, v) { const en = enums.phaseText(dt, v); return de.phaseDe(dt, v) || de.phaseNameDe(en) || en; }
+
+/** Miele-Temperatur (Hundertstel °C) → °C, Sentinel → null. */
+function temp(v) {
+    if (v == null || v === TEMP_SENTINEL) return null;
+    return v / 100;
+}
+
+/**
+ * Zustands-Kanäle (Rohwert + optionaler Klartext) je /State-Feld.
+ * decode(value, ctx) → { states: [{sub, val}] }
+ * ctx = { deviceType }
+ */
+const STATE_FIELDS = {
+    Status: {
+        states: [
+            { sub: 'status', role: 'value', type: 'number', name: 'Status (raw)' },
+            { sub: 'statusText', role: 'text', type: 'string', name: 'Status' },
+        ],
+        decode: (v) => [{ sub: 'status', val: v }, { sub: 'statusText', val: statusTextDe(v) }],
+    },
+    ProgramType: {
+        states: [
+            { sub: 'programType', role: 'value', type: 'number', name: 'Program type (raw)' },
+            { sub: 'programTypeText', role: 'text', type: 'string', name: 'Program type' },
+        ],
+        decode: (v) => [{ sub: 'programType', val: v }, { sub: 'programTypeText', val: programTypeTextDe(v) }],
+    },
+    ProgramID: {
+        states: [
+            { sub: 'programId', role: 'value', type: 'number', name: 'Program (raw)' },
+            { sub: 'programText', role: 'text', type: 'string', name: 'Program' },
+        ],
+        decode: (v, ctx) => [{ sub: 'programId', val: v }, { sub: 'programText', val: programTextDe(ctx.deviceType, v) }],
+    },
+    ProgramPhase: {
+        states: [
+            { sub: 'programPhase', role: 'value', type: 'number', name: 'Phase (raw)' },
+            { sub: 'programPhaseText', role: 'text', type: 'string', name: 'Phase' },
+        ],
+        decode: (v, ctx) => [{ sub: 'programPhase', val: v }, { sub: 'programPhaseText', val: phaseTextDe(ctx.deviceType, v) }],
+    },
+    RemainingTime: {
+        states: [
+            { sub: 'remainingMinutes', role: 'value.interval', type: 'number', unit: 'min', name: 'Remaining time' },
+            { sub: 'remainingHHMM', role: 'text', type: 'string', name: 'Remaining time (H:MM)' },
+            // Voraussichtliches Programmende (wie mielecloudservice.estimatedEndTime). Der Wert wird
+            // NICHT hier dekodiert (die Rohantwort kennt keine Uhrzeit), sondern in main.js aus
+            // "jetzt + Restzeit" berechnet - hier nur die Objektanlage.
+            { sub: 'estimatedEndTime', role: 'value.time', type: 'number', name: 'Estimated end time' },
+            { sub: 'estimatedEndTimeText', role: 'text', type: 'string', name: 'Estimated end time (HH:MM)' },
+        ],
+        decode: (v) => [{ sub: 'remainingMinutes', val: timeToMinutes(v) }, { sub: 'remainingHHMM', val: timeToHHMM(v) }],
+    },
+    ElapsedTime: {
+        states: [
+            { sub: 'elapsedMinutes', role: 'value.interval', type: 'number', unit: 'min', name: 'Elapsed time' },
+            { sub: 'elapsedHHMM', role: 'text', type: 'string', name: 'Elapsed time (H:MM)' },
+        ],
+        decode: (v) => [{ sub: 'elapsedMinutes', val: timeToMinutes(v) }, { sub: 'elapsedHHMM', val: timeToHHMM(v) }],
+    },
+    StartTime: {
+        states: [
+            { sub: 'startInMinutes', role: 'value.interval', type: 'number', unit: 'min', name: 'Start delay' },
+            { sub: 'startHHMM', role: 'text', type: 'string', name: 'Start delay (H:MM)' },
+        ],
+        decode: (v) => [{ sub: 'startInMinutes', val: timeToMinutes(v) }, { sub: 'startHHMM', val: timeToHHMM(v) }],
+    },
+    TargetTemperature: {
+        states: [
+            { sub: 'targetTemperature', role: 'value.temperature', type: 'number', unit: '°C', name: 'Target temperature' },
+            { sub: 'targetTemperatureZone2', role: 'value.temperature', type: 'number', unit: '°C', name: 'Target temperature zone 2' },
+            { sub: 'targetTemperatureZone3', role: 'value.temperature', type: 'number', unit: '°C', name: 'Target temperature zone 3' },
+        ],
+        decode: (v) => [
+            { sub: 'targetTemperature', val: temp(v && v[0]) },
+            { sub: 'targetTemperatureZone2', val: temp(v && v[1]) },
+            { sub: 'targetTemperatureZone3', val: temp(v && v[2]) },
+        ],
+    },
+    Temperature: {
+        states: [
+            { sub: 'temperature', role: 'value.temperature', type: 'number', unit: '°C', name: 'Temperature' },
+            { sub: 'temperatureZone2', role: 'value.temperature', type: 'number', unit: '°C', name: 'Temperature zone 2' },
+            { sub: 'temperatureZone3', role: 'value.temperature', type: 'number', unit: '°C', name: 'Temperature zone 3' },
+        ],
+        decode: (v) => [
+            { sub: 'temperature', val: temp(v && v[0]) },
+            { sub: 'temperatureZone2', val: temp(v && v[1]) },
+            { sub: 'temperatureZone3', val: temp(v && v[2]) },
+        ],
+    },
+    SignalInfo: {
+        states: [{ sub: 'signalInfo', role: 'indicator', type: 'boolean', name: 'Info signal' }],
+        decode: (v) => [{ sub: 'signalInfo', val: !!v }],
+    },
+    SignalFailure: {
+        states: [{ sub: 'signalFailure', role: 'indicator.maintenance', type: 'boolean', name: 'Failure signal' }],
+        decode: (v) => [{ sub: 'signalFailure', val: !!v }],
+    },
+    SignalDoor: {
+        states: [{ sub: 'signalDoor', role: 'sensor.door', type: 'boolean', name: 'Door open' }],
+        decode: (v) => [{ sub: 'signalDoor', val: !!v }],
+    },
+    RemoteEnable: {
+        states: [
+            { sub: 'mobileStart', role: 'indicator', type: 'boolean', name: 'MobileStart enabled' },
+            { sub: 'remoteEnableRaw', role: 'json', type: 'string', name: 'RemoteEnable (raw)' },
+        ],
+        // Element[1] = MobileStart-Freigabe (0/1). Steuerung nur möglich, wenn 1.
+        decode: (v) => [
+            { sub: 'mobileStart', val: Array.isArray(v) ? !!v[1] : false },
+            { sub: 'remoteEnableRaw', val: JSON.stringify(v) },
+        ],
+    },
+    ProcessAction: {
+        states: [{ sub: 'processAction', role: 'value', type: 'number', name: 'Process action' }],
+        decode: (v) => [{ sub: 'processAction', val: v }],
+    },
+    DeviceAction: {
+        states: [{ sub: 'deviceAction', role: 'value', type: 'number', name: 'Device action' }],
+        decode: (v) => [{ sub: 'deviceAction', val: v }],
+    },
+    Light: {
+        states: [{ sub: 'light', role: 'switch.light', type: 'boolean', name: 'Light on' }],
+        // Light: 0 = kein Licht/aus, 1 = an, 2 = aus (gerätespezifisch); >0 && !=2 → an
+        decode: (v) => [{ sub: 'light', val: v === 1 }],
+    },
+    StandbyState: {
+        states: [{ sub: 'standbyState', role: 'value', type: 'number', name: 'Standby state' }],
+        decode: (v) => [{ sub: 'standbyState', val: v }],
+    },
+    SpinningSpeed: {
+        states: [{ sub: 'spinningSpeed', role: 'value', type: 'number', unit: 'rpm', name: 'Spin speed' }],
+        decode: (v) => [{ sub: 'spinningSpeed', val: v }],
+    },
+    DryingStep: {
+        states: [
+            { sub: 'dryingStep', role: 'value', type: 'number', name: 'Drying step (raw)' },
+            { sub: 'dryingStepText', role: 'text', type: 'string', name: 'Drying step' },
+        ],
+        decode: (v) => [{ sub: 'dryingStep', val: v }, { sub: 'dryingStepText', val: dryingStepTextDe(v) }],
+    },
+    SyncState: {
+        states: [{ sub: 'syncState', role: 'value', type: 'number', name: 'Sync state' }],
+        decode: (v) => [{ sub: 'syncState', val: v }],
+    },
+    InternalState: {
+        states: [{ sub: 'internalState', role: 'value', type: 'number', name: 'Internal state' }],
+        decode: (v) => [{ sub: 'internalState', val: v }],
+    },
+};
+
+/** Ident-Felder → info-States (statisch). */
+const IDENT_FIELDS = [
+    { sub: 'techType', role: 'info.name', type: 'string', name: 'Model / TechType', path: ['DeviceIdentLabel', 'TechType'] },
+    { sub: 'fabNumber', role: 'info.serial', type: 'string', name: 'Serial number', path: ['DeviceIdentLabel', 'FabNumber'] },
+    { sub: 'matNumber', role: 'text', type: 'string', name: 'Material number', path: ['DeviceIdentLabel', 'MatNumber'] },
+    { sub: 'deviceType', role: 'value', type: 'number', name: 'Device type', path: ['DeviceType'] },
+    { sub: 'xkmType', role: 'text', type: 'string', name: 'WiFi module type', path: ['XKMIdentLabel', 'TechType'] },
+    { sub: 'xkmVersion', role: 'info.firmware', type: 'string', name: 'WiFi module firmware', path: ['XKMIdentLabel', 'ReleaseVersion'] },
+    { sub: 'protocolVersion', role: 'value', type: 'number', name: 'Protocol version', path: ['ProtocolVersion'] },
+];
+
+/** Steuer-States (beschreibbar, per Opcode). Nur angelegt, wenn allowControl. */
+const CONTROL_STATES = [
+    { sub: 'start', role: 'button.start', name: 'Start program', opcode: 0x01 },
+    { sub: 'stop', role: 'button.stop', name: 'Stop program', opcode: 0x37 },
+    { sub: 'pause', role: 'button.pause', name: 'Pause program', opcode: 0x03 },
+    { sub: 'powerOn', role: 'button', name: 'Switch on', opcode: 0x10 },
+    { sub: 'powerOff', role: 'button', name: 'Switch off', opcode: 0x13 },
+    { sub: 'lightOn', role: 'button', name: 'Light on', opcode: 0x0d },
+    { sub: 'lightOff', role: 'button', name: 'Light off', opcode: 0x0e },
+];
+
+// Geräteart je DeviceType (für den Objektnamen).
+const DEVICE_CATEGORY = {
+    1: 'Waschmaschine', 2: 'Trockner', 24: 'Waschtrockner',
+    7: 'Spülmaschine', 12: 'Backofen', 13: 'Backofen mit Mikrowelle',
+    15: 'Dampfgarer', 16: 'Dampfbackofen', 17: 'Kaffeevollautomat',
+    18: 'Kühlschrank', 19: 'Gefrierschrank', 20: 'Kühl-Gefrier-Kombination',
+    21: 'Weinkühlschrank', 23: 'Dunstabzug', 25: 'Kochfeld', 27: 'Mikrowelle',
+    67: 'Wärmeschublade', 68: 'Wärmeschublade',
+};
+
+function deviceCategory(deviceType) {
+    return DEVICE_CATEGORY[deviceType] || null;
+}
+
+// Gerätespezifische STATE_FIELDS nur beim passenden Gerätetyp anlegen/schreiben - sonst stünde z. B.
+// die Schleuderdrehzahl auch bei Spülmaschine und Backofen (sinnlos). Key = STATE_FIELDS-Schlüssel,
+// Wert = erlaubte deviceTypes. Nicht gelistete Felder gelten für ALLE Geräte (Status, Programm, …).
+const FIELD_DEVICE_TYPES = {
+    SpinningSpeed: [1, 24],   // Schleuderdrehzahl: Waschmaschine, Waschtrockner
+    DryingStep: [2, 24],      // Trockenstufe: Trockner, Waschtrockner
+};
+
+/** true, wenn das STATE_FIELDS-Feld [key] für [deviceType] angelegt/geschrieben werden soll. */
+function fieldAllowed(key, deviceType) {
+    const allowed = FIELD_DEVICE_TYPES[key];
+    return !allowed || allowed.includes(deviceType);
+}
+
+// Deutsche Datenpunkt-Namen (überlappende Punkte an mielecloudservice angelehnt).
+const DE_NAMES = {
+    state: {
+        status: 'Status (Rohwert)', statusText: 'Status',
+        programType: 'Programmart (Rohwert)', programTypeText: 'Programmart',
+        programId: 'Programmbezeichnung (Rohwert)', programText: 'Programmbezeichnung',
+        programPhase: 'Programmphase (Rohwert)', programPhaseText: 'Programmphase',
+        remainingMinutes: 'Restzeit (Minuten)', remainingHHMM: 'Restzeit',
+        estimatedEndTime: 'Voraussichtliches Ende', estimatedEndTimeText: 'Voraussichtliches Ende (Uhrzeit)',
+        elapsedMinutes: 'Verstrichene Zeit (Minuten)', elapsedHHMM: 'Verstrichene Zeit',
+        startInMinutes: 'Startvorwahl (Minuten)', startHHMM: 'Startvorwahl',
+        targetTemperature: 'Zieltemperatur', targetTemperatureZone2: 'Zieltemperatur Zone 2', targetTemperatureZone3: 'Zieltemperatur Zone 3',
+        temperature: 'Temperatur', temperatureZone2: 'Temperatur Zone 2', temperatureZone3: 'Temperatur Zone 3',
+        signalInfo: 'Info-Signal', signalFailure: 'Störungssignal', signalDoor: 'Tür offen',
+        mobileStart: 'MobileStart verfügbar', remoteEnableRaw: 'Fernsteuer-Freigabe (Rohwert)',
+        processAction: 'Prozess-Aktion', deviceAction: 'Geräte-Aktion', light: 'Licht',
+        standbyState: 'Standby-Zustand', spinningSpeed: 'Schleuderdrehzahl',
+        dryingStep: 'Trockenstufe (Rohwert)', dryingStepText: 'Trockenstufe',
+        syncState: 'Sync-Zustand', internalState: 'Interner Zustand',
+    },
+    info: {
+        techType: 'Gerätetyp (Technik)', fabNumber: 'Seriennummer', matNumber: 'Materialnummer',
+        deviceType: 'Gerätetyp', xkmType: 'Kommunikationsmodul-Typ', xkmVersion: 'Kommunikationsmodul-Firmware',
+        protocolVersion: 'Protokollversion',
+    },
+    control: {
+        start: 'Programm starten', stop: 'Programm stoppen', pause: 'Programm pausieren',
+        powerOn: 'Einschalten', powerOff: 'Ausschalten', lightOn: 'Licht an', lightOff: 'Licht aus',
+    },
+};
+
+/**
+ * common.name für einen Datenpunkt: {en, de} wenn eine deutsche Übersetzung existiert,
+ * sonst nur der englische Name. Bei german=false wird immer nur Englisch verwendet.
+ */
+function nameFor(channel, sub, en, german) {
+    const de = DE_NAMES[channel] && DE_NAMES[channel][sub];
+    if (german && de) return { en, de };
+    return en;
+}
+
+function pathGet(obj, path) {
+    let cur = obj;
+    for (const p of path) {
+        if (cur == null) return undefined;
+        cur = cur[p];
+    }
+    return cur;
+}
+
+module.exports = { STATE_FIELDS, IDENT_FIELDS, CONTROL_STATES, DE_NAMES, DEVICE_CATEGORY, deviceCategory, FIELD_DEVICE_TYPES, fieldAllowed, nameFor, timeToMinutes, temp, pathGet, TEMP_SENTINEL };