From e213b58db2d96d5bc33ef9e0e8eb534d461cb1e4 Mon Sep 17 00:00:00 2001
From: Maxim Prokhorov <prokhorov.max@outlook.com>
Date: Wed, 29 Dec 2021 23:54:09 +0300
Subject: [PATCH] settings: continue refactoring internal constants

Settling on naming 'options' for enumerations (...possibly, everything
else in the future, would that make sense to store for 'setting' object)

Update terminal commands that were reporting status to also report a
full list of 'indexed' settings for the specific entity
Also updates the WebUI outputs which are (hopefuly) are already handled
as-is through the .js processing pipeline and the .html properties
receiving certain special string values

More namespacing and save ~2KiB of RAM by reducing the amount of loaded keys strings
However, ROM side of things may suffer b/c of template specializations for the
generic conversion functions when there are many different types involved.
---
 code/espurna/button.cpp         | 494 ++++++++++++++++---------
 code/espurna/debug.cpp          |  88 +++--
 code/espurna/gpio.cpp           |  51 ++-
 code/espurna/gpio.h             |   8 +
 code/espurna/ifan.cpp           |  17 +-
 code/espurna/led.cpp            | 240 ++++++------
 code/espurna/light.cpp          |   3 +-
 code/espurna/migrate.cpp        | 102 ++---
 code/espurna/mqtt.cpp           |  86 +++--
 code/espurna/relay.cpp          | 633 ++++++++++++++++++++------------
 code/espurna/rpnrules.cpp       | 142 +++----
 code/espurna/scheduler.cpp      | 251 +++++++------
 code/espurna/sensor.cpp         | 290 ++++++++-------
 code/espurna/settings.cpp       | 212 +++++------
 code/espurna/settings.h         |  43 ++-
 code/espurna/settings_helpers.h | 572 ++++++++++++++++++-----------
 code/espurna/system.cpp         |  99 ++++-
 code/espurna/system.h           |   9 +
 code/espurna/utils.cpp          |  70 +++-
 code/espurna/utils.h            |   4 +
 code/espurna/wifi.cpp           | 528 ++++++++++++++++++++------
 code/espurna/ws.cpp             |  68 ++--
 code/espurna/ws_utils.h         |  62 +++-
 code/html/custom.js             |   4 +-
 24 files changed, 2615 insertions(+), 1461 deletions(-)

diff --git a/code/espurna/button.cpp b/code/espurna/button.cpp
index 2123a576..ef994844 100644
--- a/code/espurna/button.cpp
+++ b/code/espurna/button.cpp
@@ -30,143 +30,190 @@ Copyright (C) 2019-2021 by Maxim Prokhorov <prokhorov dot max at outlook dot com
 
 // -----------------------------------------------------------------------------
 
+namespace espurna {
+namespace button {
 namespace settings {
-namespace internal {
+namespace keys {
 namespace {
 
+alignas(4) static constexpr char Gpio[] PROGMEM = "btnGpio";
+alignas(4) static constexpr char GpioType[] PROGMEM = "btnGpioType";
+alignas(4) static constexpr char Provider[] PROGMEM = "btnProv";
+alignas(4) static constexpr char Mode[] PROGMEM = "btnMode";
+alignas(4) static constexpr char DefaultValue[] PROGMEM = "btnDefVal";
+alignas(4) static constexpr char PinMode[] PROGMEM = "btnPinMode";
+
+alignas(4) static constexpr char Release[] PROGMEM = "btnRlse";
+alignas(4) static constexpr char Press[] PROGMEM = "btnPress";
+alignas(4) static constexpr char Click[] PROGMEM = "btnClick";
+alignas(4) static constexpr char DoubleClick[] PROGMEM = "btnDclk";
+alignas(4) static constexpr char TripleClick[] PROGMEM = "btnTclk";
+alignas(4) static constexpr char LongClick[] PROGMEM = "btnLclk";
+alignas(4) static constexpr char LongLongClick[] PROGMEM = "btnLLclk";
+
+alignas(4) static constexpr char DebounceDelay[] PROGMEM = "btnDebDel";
+alignas(4) static constexpr char LongClickDelay[] PROGMEM = "btnLclkDel";
+alignas(4) static constexpr char LongLongClickDelay[] PROGMEM = "btnLLclkDel";
+alignas(4) static constexpr char RepeatDelay[] PROGMEM = "btnRepDel";
+
+alignas(4) static constexpr char Relay[] PROGMEM = "btnRelay";
+
+alignas(4) static constexpr char MqttSendAll[] PROGMEM = "btnMqttSendAll";
+alignas(4) static constexpr char MqttRetain[] PROGMEM = "btnMqttRetain";
+
+[[gnu::unused]] alignas(4) static constexpr char AnalogLevel[] PROGMEM = "btnLevel";
+
+} // namespace
+} // namespace keys
+
+namespace options {
+namespace {
+
+using ::settings::options::Enumeration;
+
 alignas(4) static constexpr char Switch[] PROGMEM = "switch";
 alignas(4) static constexpr char Pushbutton[] PROGMEM = "pushbutton";
 
-constexpr static const std::array<EnumOption<debounce_event::types::Mode>, 2> DebounceEventModeOptions PROGMEM {
+static constexpr std::array<Enumeration<debounce_event::types::Mode>, 2> DebounceEventMode PROGMEM {
     {{debounce_event::types::Mode::Switch, Switch},
      {debounce_event::types::Mode::Pushbutton, Pushbutton}}
 };
 
-} // namespace
-
-template<>
-debounce_event::types::Mode convert(const String& value) {
-    return convert(DebounceEventModeOptions, value, debounce_event::types::Mode::Pushbutton);
-}
-
-String serialize(debounce_event::types::Mode value) {
-    return serialize(DebounceEventModeOptions, value);
-}
-
-namespace {
-
 alignas(4) static constexpr char Low[] PROGMEM = "low";
 alignas(4) static constexpr char High[] PROGMEM = "high";
 alignas(4) static constexpr char Initial[] PROGMEM = "initial";
 
-constexpr static const std::array<EnumOption<debounce_event::types::PinValue>, 3> DebounceEventPinValueOptions PROGMEM {
+static constexpr std::array<Enumeration<debounce_event::types::PinValue>, 3> DebounceEventPinValue PROGMEM {
     {{debounce_event::types::PinValue::Low, Low},
      {debounce_event::types::PinValue::High, High},
      {debounce_event::types::PinValue::Initial, Initial}}
 };
 
-} // namespace
-
-template<>
-debounce_event::types::PinValue convert(const String& value) {
-    return convert(DebounceEventPinValueOptions, value, debounce_event::types::PinValue::Low);
-}
-
-String serialize(debounce_event::types::PinValue value) {
-    return serialize(DebounceEventPinValueOptions, value);
-}
-
-namespace {
-
 alignas(4) static constexpr char Input[] PROGMEM = "default";
 alignas(4) static constexpr char InputPullup[] PROGMEM = "pull-up";
 alignas(4) static constexpr char InputPulldown[] PROGMEM = "pull-down";
 
-constexpr static const std::array<EnumOption<debounce_event::types::PinMode>, 3> DebounceEventPinModeOptions PROGMEM {
+static constexpr std::array<Enumeration<debounce_event::types::PinMode>, 3> DebounceEventPinMode PROGMEM {
     {{debounce_event::types::PinMode::Input, Input},
      {debounce_event::types::PinMode::InputPullup, InputPullup},
      {debounce_event::types::PinMode::InputPulldown, InputPulldown}}
 };
 
+alignas(4) static constexpr char None[] PROGMEM = "none";
+alignas(4) static constexpr char Gpio[] PROGMEM = "gpio";
+alignas(4) static constexpr char Analog[] PROGMEM = "analog";
+
+static constexpr std::array<Enumeration<ButtonProvider>, 3> ButtonProviderOptions PROGMEM {
+    {{ButtonProvider::None, None},
+     {ButtonProvider::Gpio, Gpio},
+     {ButtonProvider::Analog, Analog}}
+};
+
+[[gnu::unused]] alignas(4) static constexpr char Toggle[] PROGMEM = "relay-toggle";
+[[gnu::unused]] alignas(4) static constexpr char On[] PROGMEM = "relay-on";
+[[gnu::unused]] alignas(4) static constexpr char Off[] PROGMEM = "relay-off";
+
+alignas(4) static constexpr char AccessPoint[] PROGMEM = "wifi-ap";
+alignas(4) static constexpr char Reset[] PROGMEM = "reset";
+alignas(4) static constexpr char FactoryReset[] PROGMEM = "factory";
+
+[[gnu::unused]] alignas(4) static constexpr char BrightnessIncrease[] PROGMEM = "bri-inc";
+[[gnu::unused]] alignas(4) static constexpr char BrightnessDecrease[] PROGMEM = "bri-dec";
+
+[[gnu::unused]] alignas(4) static constexpr char DisplayOn[] PROGMEM = "display-on";
+
+alignas(4) static constexpr char Custom[] PROGMEM = "custom";
+
+[[gnu::unused]] alignas(4) static constexpr char FanLow[] PROGMEM = "fan-low";
+[[gnu::unused]] alignas(4) static constexpr char FanMedium[] PROGMEM = "fan-medium";
+[[gnu::unused]] alignas(4) static constexpr char FanHigh[] PROGMEM = "fan-high";
+
+static constexpr Enumeration<ButtonAction> ButtonActionOptions[] PROGMEM {
+    {ButtonAction::None, None},
+#if RELAY_SUPPORT
+    {ButtonAction::Toggle, Toggle},
+    {ButtonAction::On, On},
+    {ButtonAction::Off, Off},
+#endif
+    {ButtonAction::AccessPoint, AccessPoint},
+    {ButtonAction::Reset, Reset},
+    {ButtonAction::FactoryReset, FactoryReset},
+#if LIGHT_PROVIDER != LIGHT_PROVIDER_NONE
+    {ButtonAction::BrightnessIncrease, BrightnessIncrease},
+    {ButtonAction::BrightnessDecrease, BrightnessDecrease},
+#endif
+#if THERMOSTAT_DISPLAY_SUPPORT
+    {ButtonAction::DisplayOn, DisplayOn},
+#endif
+    {ButtonAction::Custom, Custom},
+#if FAN_SUPPORT
+    {ButtonAction::FanLow, FanLow},
+    {ButtonAction::FanMedium, FanMedium},
+    {ButtonAction::FanHigh, FanHigh},
+#endif
+};
+
+} // namespace
+} // namespace query
+} // namespace settings
+} // namespace button
+} // namespace espurna
+
+namespace settings {
+namespace internal {
+namespace {
+
+using espurna::button::settings::options::DebounceEventMode;
+using espurna::button::settings::options::DebounceEventPinValue;
+using espurna::button::settings::options::DebounceEventPinMode;
+using espurna::button::settings::options::ButtonProviderOptions;
+using espurna::button::settings::options::ButtonActionOptions;
+
 } // namespace
 
+template<>
+debounce_event::types::Mode convert(const String& value) {
+    return convert(DebounceEventMode, value, debounce_event::types::Mode::Pushbutton);
+}
+
+String serialize(debounce_event::types::Mode value) {
+    return serialize(DebounceEventMode, value);
+}
+
+template<>
+debounce_event::types::PinValue convert(const String& value) {
+    return convert(DebounceEventPinValue, value, debounce_event::types::PinValue::Low);
+}
+
+String serialize(debounce_event::types::PinValue value) {
+    return serialize(DebounceEventPinValue, value);
+}
+
 template<>
 debounce_event::types::PinMode convert(const String& value) {
-    return convert(DebounceEventPinModeOptions, value, debounce_event::types::PinMode::Input);
+    return convert(DebounceEventPinMode, value, debounce_event::types::PinMode::Input);
 }
 
 String serialize(debounce_event::types::PinMode mode) {
-    return serialize(DebounceEventPinModeOptions, mode);
+    return serialize(DebounceEventPinMode, mode);
 }
 
-namespace {
-
-} // namespace
-
 template <>
 ButtonProvider convert(const String& value) {
-    alignas(4) static constexpr char None[] PROGMEM = "none";
-    alignas(4) static constexpr char Gpio[] PROGMEM = "gpio";
-    alignas(4) static constexpr char Analog[] PROGMEM = "analog";
+    return convert(ButtonProviderOptions, value, ButtonProvider::None);
+}
 
-    constexpr static const std::array<EnumOption<ButtonProvider>, 3> options PROGMEM {
-        {{ButtonProvider::None, None},
-         {ButtonProvider::Gpio, Gpio},
-         {ButtonProvider::Analog, Analog}}
-    };
-
-    return convert(options, value, ButtonProvider::None);
+String serialize(ButtonProvider value) {
+    return serialize(ButtonProviderOptions, value);
 }
 
 template<>
 ButtonAction convert(const String& value) {
-    alignas(4) static constexpr char None[] PROGMEM = "none";
+    return convert(ButtonActionOptions, value, ButtonAction::None);
+}
 
-    [[gnu::unused]] alignas(4) static constexpr char Toggle[] PROGMEM = "relay-toggle";
-    [[gnu::unused]] alignas(4) static constexpr char On[] PROGMEM = "relay-on";
-    [[gnu::unused]] alignas(4) static constexpr char Off[] PROGMEM = "relay-off";
-
-    alignas(4) static constexpr char AccessPoint[] PROGMEM = "wifi-ap";
-    alignas(4) static constexpr char Reset[] PROGMEM = "reset";
-    alignas(4) static constexpr char FactoryReset[] PROGMEM = "factory";
-
-    [[gnu::unused]] alignas(4) static constexpr char BrightnessIncrease[] PROGMEM = "bri-inc";
-    [[gnu::unused]] alignas(4) static constexpr char BrightnessDecrease[] PROGMEM = "bri-dec";
-
-    [[gnu::unused]] alignas(4) static constexpr char DisplayOn[] PROGMEM = "display-on";
-
-    alignas(4) static constexpr char Custom[] PROGMEM = "custom";
-
-    [[gnu::unused]] alignas(4) static constexpr char FanLow[] PROGMEM = "fan-low";
-    [[gnu::unused]] alignas(4) static constexpr char FanMedium[] PROGMEM = "fan-medium";
-    [[gnu::unused]] alignas(4) static constexpr char FanHigh[] PROGMEM = "fan-high";
-
-    constexpr static const EnumOption<ButtonAction> options[] PROGMEM {
-        {ButtonAction::None, None},
-#if RELAY_SUPPORT
-        {ButtonAction::Toggle, Toggle},
-        {ButtonAction::On, On},
-        {ButtonAction::Off, Off},
-#endif
-        {ButtonAction::AccessPoint, AccessPoint},
-        {ButtonAction::Reset, Reset},
-        {ButtonAction::FactoryReset, FactoryReset},
-#if LIGHT_PROVIDER != LIGHT_PROVIDER_NONE
-        {ButtonAction::BrightnessIncrease, BrightnessIncrease},
-        {ButtonAction::BrightnessDecrease, BrightnessDecrease},
-#endif
-#if THERMOSTAT_DISPLAY_SUPPORT
-        {ButtonAction::DisplayOn, DisplayOn},
-#endif
-        {ButtonAction::Custom, Custom},
-#if FAN_SUPPORT
-        {ButtonAction::FanLow, FanLow},
-        {ButtonAction::FanMedium, FanMedium},
-        {ButtonAction::FanHigh, FanHigh},
-#endif
-    };
-
-    return convert(options, value, ButtonAction::None);
+String serialize(::ButtonAction value) {
+    return serialize(ButtonActionOptions, value);
 }
 
 } // namespace internal
@@ -174,9 +221,18 @@ ButtonAction convert(const String& value) {
 
 // -----------------------------------------------------------------------------
 
+namespace espurna {
 namespace button {
+namespace internal {
 namespace {
+
+static std::vector<Button> buttons;
+
+} // namespace
+} // namespace internal
+
 namespace build {
+namespace {
 
 constexpr size_t pin(size_t index) {
     return (
@@ -490,7 +546,7 @@ constexpr ButtonProvider provider(size_t index) {
     );
 }
 
-constexpr int analogLevel(size_t index) {
+[[gnu::unused]] constexpr int analogLevel(size_t index) {
     return (
         (index == 0) ? (BUTTON1_ANALOG_LEVEL) :
         (index == 1) ? (BUTTON2_ANALOG_LEVEL) :
@@ -503,14 +559,17 @@ constexpr int analogLevel(size_t index) {
     );
 }
 
+} // namespace
 } // namespace build
 
 namespace settings {
 namespace internal {
+namespace {
 
 template <typename T>
 T indexedThenGlobal(const String& prefix, size_t index, T defaultValue) {
-    SettingsKey key{prefix, index};
+    const auto key = SettingsKey{prefix, index};
+
     auto indexed = ::settings::internal::get(key.value());
     if (indexed) {
         return ::settings::internal::convert<T>(indexed.ref());
@@ -524,104 +583,196 @@ T indexedThenGlobal(const String& prefix, size_t index, T defaultValue) {
     return defaultValue;
 }
 
+} // namespace
 } // namespace internal
 
+namespace {
+
 unsigned char pin(size_t index) {
-    return getSetting({"btnGpio", index}, build::pin(index));
+    return getSetting({keys::Gpio, index}, build::pin(index));
 }
 
 GpioType pinType(size_t index) {
-    return getSetting({"btnGpioType", index}, build::pinType(index));
+    return getSetting({keys::GpioType, index}, build::pinType(index));
 }
 
 ButtonProvider provider(size_t index) {
-    return getSetting({"btnProv", index}, build::provider(index));
+    return getSetting({keys::Provider, index}, build::provider(index));
 }
 
 debounce_event::types::Mode mode(size_t index) {
-    return getSetting({"btnMode", index}, build::mode(index));
+    return getSetting({keys::Mode, index}, build::mode(index));
 }
 
 debounce_event::types::PinValue defaultValue(size_t index) {
-    return getSetting({"btnDefVal", index}, build::defaultValue(index));
+    return getSetting({keys::DefaultValue, index}, build::defaultValue(index));
 }
 
 debounce_event::types::PinMode pinMode(size_t index) {
-    return getSetting({"btnPinMode", index}, build::pinMode(index));
+    return getSetting({keys::PinMode, index}, build::pinMode(index));
 }
 
 ButtonAction release(size_t index) {
-    return getSetting({"btnRlse", index}, build::release(index));
+    return getSetting({keys::Release, index}, build::release(index));
 }
 
 ButtonAction press(size_t index) {
-    return getSetting({"btnPress", index}, build::press(index));
+    return getSetting({keys::Press, index}, build::press(index));
 }
 
 ButtonAction click(size_t index) {
-    return getSetting({"btnClick", index}, build::click(index));
+    return getSetting({keys::Click, index}, build::click(index));
 }
 
 ButtonAction doubleClick(size_t index) {
-   return getSetting({"btnDclk", index}, build::doubleClick(index));
+   return getSetting({keys::DoubleClick, index}, build::doubleClick(index));
 }
 
 ButtonAction tripleClick(size_t index) {
-   return getSetting({"btnTclk", index}, build::tripleClick(index));
+   return getSetting({keys::TripleClick, index}, build::tripleClick(index));
 }
 
 ButtonAction longClick(size_t index) {
-   return getSetting({"btnLclk", index}, build::longClick(index));
+   return getSetting({keys::LongClick, index}, build::longClick(index));
 }
 
 ButtonAction longLongClick(size_t index) {
-   return getSetting({"btnLLclk", index}, build::longLongClick(index));
+   return getSetting({keys::LongLongClick, index}, build::longLongClick(index));
 }
 
 unsigned long debounceDelay(size_t index) {
-    return internal::indexedThenGlobal("btnDebDel", index, build::debounceDelay(index));
+    return internal::indexedThenGlobal(keys::DebounceDelay, index, build::debounceDelay(index));
 }
 
 unsigned long longClickDelay(size_t index) {
-    return internal::indexedThenGlobal("btnLclkDel", index, build::longClickDelay(index));
+    return internal::indexedThenGlobal(keys::LongClickDelay, index, build::longClickDelay(index));
 }
 
 unsigned long longLongClickDelay(size_t index) {
-    return internal::indexedThenGlobal("btnLLclkDel", index, build::longLongClickDelay(index));
+    return internal::indexedThenGlobal(keys::LongLongClickDelay, index, build::longLongClickDelay(index));
 }
 
 [[gnu::unused]]
 unsigned long repeatDelay() {
-    return getSetting("btnRepDel", build::repeatDelay());
+    return getSetting(keys::RepeatDelay, build::repeatDelay());
 }
 
 unsigned long repeatDelay(size_t index) {
-    return internal::indexedThenGlobal("btnRepDel", index, build::repeatDelay(index));
+    return internal::indexedThenGlobal(keys::RepeatDelay, index, build::repeatDelay(index));
 }
 
 size_t relay(size_t index) {
-    return getSetting({"btnRelay", index}, build::relay(index));
+    return getSetting({keys::Relay, index}, build::relay(index));
 }
 
 [[gnu::unused]]
 bool mqttSendAllEvents(size_t index) {
-    return getSetting({"btnMqttSendAll", index}, build::mqttSendAllEvents(index));
+    return getSetting({keys::MqttSendAll, index}, build::mqttSendAllEvents(index));
 }
 
 [[gnu::unused]]
 bool mqttRetain(size_t index) {
-    return getSetting({"btnMqttRetain", index}, build::mqttRetain(index));
+    return getSetting({keys::MqttRetain, index}, build::mqttRetain(index));
 }
 
 #if BUTTON_PROVIDER_ANALOG_SUPPORT
 int analogLevel(size_t index) {
-    return getSetting({"btnLevel", index}, build::analogLevel(index));
+    return getSetting({keys::AnalogLevel, index}, build::analogLevel(index));
 }
 #endif
 
-} // namespace settings
 } // namespace
+
+namespace query {
+namespace internal {
+namespace {
+
+#define ID_VALUE(NAME, FUNC)\
+String NAME (size_t id) {\
+    return ::settings::internal::serialize(FUNC(id));\
+}
+
+ID_VALUE(pin, settings::pin)
+ID_VALUE(pinType, settings::pinType)
+ID_VALUE(provider, settings::provider)
+ID_VALUE(mode, settings::mode)
+ID_VALUE(defaultValue, settings::defaultValue)
+ID_VALUE(pinMode, settings::pinMode)
+ID_VALUE(release, settings::release)
+ID_VALUE(press, settings::press)
+ID_VALUE(click, settings::click)
+ID_VALUE(doubleClick, settings::doubleClick)
+ID_VALUE(tripleClick, settings::tripleClick)
+ID_VALUE(longClick, settings::longClick)
+ID_VALUE(longLongClick, settings::longLongClick)
+ID_VALUE(debounceDelay, settings::debounceDelay)
+ID_VALUE(longClickDelay, settings::longClickDelay)
+ID_VALUE(longLongClickDelay, settings::longLongClickDelay)
+
+#if RELAY_SUPPORT
+ID_VALUE(relay, settings::relay)
+#endif
+
+#if MQTT_SUPPORT
+ID_VALUE(mqttSendAllEvents, settings::mqttSendAllEvents)
+ID_VALUE(mqttRetain, settings::mqttRetain)
+#endif
+
+#undef ID_VALUE
+
+} // namespace
+} // namespace internal
+
+namespace {
+
+static constexpr ::settings::query::IndexedSetting IndexedSettings[] PROGMEM {
+    {keys::Gpio, internal::pin},
+    {keys::GpioType, internal::pinType},
+    {keys::Provider, internal::provider},
+    {keys::Mode, internal::mode},
+    {keys::DefaultValue, internal::defaultValue},
+    {keys::PinMode, internal::pinMode},
+    {keys::Release, internal::release},
+    {keys::Press, internal::press},
+    {keys::Click, internal::click},
+    {keys::DoubleClick, internal::doubleClick},
+    {keys::TripleClick, internal::tripleClick},
+    {keys::LongClick, internal::longClick},
+    {keys::LongLongClick, internal::longLongClick},
+    {keys::DebounceDelay, internal::debounceDelay},
+    {keys::LongClickDelay, internal::longClickDelay},
+    {keys::LongLongClickDelay, internal::longLongClickDelay},
+#if RELAY_SUPPORT
+    {keys::Relay, internal::relay},
+#endif
+#if MQTT_SUPPORT
+    {keys::MqttSendAll, internal::mqttSendAllEvents},
+    {keys::MqttRetain, internal::mqttRetain},
+#endif
+};
+
+bool checkSamePrefix(::settings::StringView key) {
+    alignas(4) static constexpr char Prefix[] PROGMEM = "btn";
+    return ::settings::query::samePrefix(key, Prefix);
+}
+
+String findValueFrom(::settings::StringView key) {
+    return ::settings::query::IndexedSetting::findValueFrom(
+        button::internal::buttons.size(), IndexedSettings, key);
+}
+
+void setup() {
+    settingsRegisterQueryHandler({
+        .check = checkSamePrefix,
+        .get = findValueFrom
+    });
+}
+
+} // namespace
+} // namespace query
+} // namespace settings
 } // namespace button
+} // namespace espurna
 
 namespace {
 
@@ -652,9 +803,9 @@ constexpr ButtonEvent _buttonMapReleased(uint8_t count, unsigned long length, un
 
 debounce_event::types::Config _buttonRuntimeConfig(size_t index) {
     return {
-        button::settings::mode(index),
-        button::settings::defaultValue(index),
-        button::settings::pinMode(index)};
+        espurna::button::settings::mode(index),
+        espurna::button::settings::defaultValue(index),
+        espurna::button::settings::pinMode(index)};
 }
 
 } // namespace
@@ -662,10 +813,10 @@ debounce_event::types::Config _buttonRuntimeConfig(size_t index) {
 // -----------------------------------------------------------------------------
 
 ButtonEventDelays::ButtonEventDelays() :
-    debounce(button::build::debounceDelay()),
-    repeat(button::build::repeatDelay()),
-    lngclick(button::build::longClickDelay()),
-    lnglngclick(button::build::longLongClickDelay())
+    debounce(espurna::button::build::debounceDelay()),
+    repeat(espurna::button::build::repeatDelay()),
+    lngclick(espurna::button::build::longClickDelay()),
+    lnglngclick(espurna::button::build::longLongClickDelay())
 {}
 
 ButtonEventDelays::ButtonEventDelays(unsigned long debounce, unsigned long repeat, unsigned long lngclick, unsigned long lnglngclick) :
@@ -707,12 +858,10 @@ ButtonEvent Button::loop() {
     return ButtonEvent::None;
 }
 
-static std::vector<Button> _buttons;
-
 // -----------------------------------------------------------------------------
 
 size_t buttonCount() {
-    return _buttons.size();
+    return espurna::button::internal::buttons.size();
 }
 
 #if MQTT_SUPPORT
@@ -720,12 +869,13 @@ size_t buttonCount() {
 namespace {
 
 std::bitset<ButtonsMax> _buttons_mqtt_send_all(
-    button::build::mqttSendAllEvents()
+    espurna::button::build::mqttSendAllEvents()
     ? std::numeric_limits<unsigned long>::max()
     : std::numeric_limits<unsigned long>::min()
 );
+
 std::bitset<ButtonsMax> _buttons_mqtt_retain(
-    button::build::mqttRetain()
+    espurna::button::build::mqttRetain()
     ? std::numeric_limits<unsigned long>::max()
     : std::numeric_limits<unsigned long>::min()
 );
@@ -789,7 +939,7 @@ void _buttonWebSocketOnVisible(JsonObject& root) {
 
 void _buttonWebSocketOnConnected(JsonObject& root) {
     if (buttonCount()) {
-        root["btnRepDel"] = button::settings::repeatDelay();
+        root["btnRepDel"] = espurna::button::settings::repeatDelay();
     }
 }
 
@@ -818,8 +968,8 @@ void buttonOnEvent(ButtonEventHandler handler) {
 //------------------------------------------------------------------------------
 
 ButtonAction buttonAction(size_t id, ButtonEvent event) {
-    return (id < _buttons.size())
-        ? _buttonDecodeEventAction(_buttons[id].actions, event)
+    return (id < espurna::button::internal::buttons.size())
+        ? _buttonDecodeEventAction(espurna::button::internal::buttons[id].actions, event)
         : ButtonAction::None;
 }
 
@@ -876,7 +1026,7 @@ void buttonEvent(size_t id, ButtonEvent event) {
         return;
     }
 
-    auto& button = _buttons[id];
+    auto& button = espurna::button::internal::buttons[id];
 
     auto action = _buttonDecodeEventAction(button.actions, event);
     for (auto& notify : _button_notify_event) {
@@ -972,7 +1122,7 @@ void buttonEvent(size_t id, ButtonEvent event) {
 namespace {
 
 void _buttonConfigure() {
-    auto buttons = _buttons.size();
+    auto buttons = espurna::button::internal::buttons.size();
 
 #if RELAY_SUPPORT
     _button_relays.clear();
@@ -980,11 +1130,11 @@ void _buttonConfigure() {
 
     for (decltype(buttons) id = 0; id < buttons; ++id) {
 #if RELAY_SUPPORT
-        _button_relays.push_back(button::settings::relay(id));
+        _button_relays.push_back(espurna::button::settings::relay(id));
 #endif
 #if MQTT_SUPPORT
-        _buttons_mqtt_send_all[id] = button::settings::mqttSendAllEvents(id);
-        _buttons_mqtt_retain[id] = button::settings::mqttRetain(id);
+        _buttons_mqtt_send_all[id] = espurna::button::settings::mqttSendAllEvents(id);
+        _buttons_mqtt_retain[id] = espurna::button::settings::mqttRetain(id);
 #endif
     }
 }
@@ -992,8 +1142,8 @@ void _buttonConfigure() {
 } // namespace
 
 void buttonLoop() {
-    for (size_t id = 0; id < _buttons.size(); ++id) {
-        auto event = _buttons[id].loop();
+    for (size_t id = 0; id < espurna::button::internal::buttons.size(); ++id) {
+        auto event = espurna::button::internal::buttons[id].loop();
         if (event != ButtonEvent::None) {
             buttonEvent(id, event);
         }
@@ -1141,12 +1291,12 @@ namespace {
 
 BasePinPtr _buttonGpioPin(size_t index, ButtonProvider provider) {
     BasePinPtr result;
-    auto pin [[gnu::unused]] = button::settings::pin(index);
+    auto pin [[gnu::unused]] = espurna::button::settings::pin(index);
 
     switch (provider) {
     case ButtonProvider::Gpio: {
 #if BUTTON_PROVIDER_GPIO_SUPPORT
-        auto* base = gpioBase(button::settings::pinType(index));
+        auto* base = gpioBase(espurna::button::settings::pinType(index));
         if (!base) {
             break;
         }
@@ -1185,23 +1335,23 @@ BasePinPtr _buttonGpioPin(size_t index, ButtonProvider provider) {
 
 ButtonActions _buttonActions(size_t index) {
     return {
-        button::settings::press(index),
-        button::settings::release(index),
-        button::settings::click(index),
-        button::settings::doubleClick(index),
-        button::settings::longClick(index),
-        button::settings::longLongClick(index),
-        button::settings::tripleClick(index)};
+        espurna::button::settings::press(index),
+        espurna::button::settings::release(index),
+        espurna::button::settings::click(index),
+        espurna::button::settings::doubleClick(index),
+        espurna::button::settings::longClick(index),
+        espurna::button::settings::longLongClick(index),
+        espurna::button::settings::tripleClick(index)};
 }
 
 // Note that we use settings without indexes as default values to preserve backwards compatibility
 
 ButtonEventDelays _buttonDelays(size_t index) {
     return {
-        button::settings::debounceDelay(index),
-        button::settings::repeatDelay(index),
-        button::settings::longClickDelay(index),
-        button::settings::longLongClickDelay(index)};
+        espurna::button::settings::debounceDelay(index),
+        espurna::button::settings::repeatDelay(index),
+        espurna::button::settings::longClickDelay(index),
+        espurna::button::settings::longLongClickDelay(index)};
 }
 
 bool _buttonSetupProvider(size_t index, ButtonProvider provider) {
@@ -1216,7 +1366,7 @@ bool _buttonSetupProvider(size_t index, ButtonProvider provider) {
             break;
         }
 
-        _buttons.emplace_back(
+        espurna::button::internal::buttons.emplace_back(
             std::move(pin),
             _buttonRuntimeConfig(index),
             _buttonActions(index),
@@ -1235,8 +1385,8 @@ bool _buttonSetupProvider(size_t index, ButtonProvider provider) {
 
 void _buttonSettingsMigrate(int version) {
     if (version < 5) {
-        delSettingPrefix("btnGPIO");
-        moveSetting("btnDelay", "btnRepDel");
+        delSettingPrefix({PSTR("btnGPIO")});
+        moveSetting(F("btnDelay"), F("btnRepDel"));
     }
 }
 
@@ -1245,7 +1395,7 @@ void _buttonSettingsMigrate(int version) {
 bool buttonAdd() {
     const size_t index { buttonCount() };
     if ((index + 1) < ButtonsMax) {
-        _buttons.emplace_back(
+        espurna::button::internal::buttons.emplace_back(
             _buttonActions(index),
             _buttonDelays(index));
         return true;
@@ -1256,32 +1406,40 @@ bool buttonAdd() {
 
 void buttonSetup() {
     migrateVersion(_buttonSettingsMigrate);
+    espurna::button::settings::query::setup();
 
     for (size_t index = 0; index < ButtonsMax; ++index) {
-        auto provider = button::settings::provider(index);
+        auto provider = espurna::button::settings::provider(index);
         if (!_buttonSetupProvider(index, provider)) {
             break;
         }
     }
 
-    auto count = _buttons.size();
+    auto count = espurna::button::internal::buttons.size();
     DEBUG_MSG_P(PSTR("[BUTTON] Number of buttons: %u\n"), count);
 
 #if TERMINAL_SUPPORT
     terminalRegisterCommand(F("BUTTON"), [](::terminal::CommandContext&& ctx) {
-        unsigned index { 0u };
-        for (auto& button : _buttons) {
-            ctx.output.printf_P(PSTR("%u - "), index++);
-            if (button.event_emitter) {
-                auto& pin = button.event_emitter->pin();
-                ctx.output.print(pin->description());
-            } else {
-                ctx.output.print(F("Virtual"));
+        if (ctx.argv.size() == 2) {
+            size_t id;
+            if (!tryParseId(ctx.argv[1].c_str(), buttonCount, id)) {
+                terminalError(ctx, F("Invalid button ID"));
+                return;
             }
-            ctx.output.print('\n');
+
+            settingsDump(ctx, espurna::button::settings::query::IndexedSettings, id);
+            terminalOK(ctx);
+            return;
         }
 
-        terminalOK(ctx);
+        size_t id { 0 };
+        for (const auto& button : espurna::button::internal::buttons) {
+            ctx.output.printf_P(
+                PSTR("button%u {%s}\n"), id++,
+                button.event_emitter
+                    ? (button.event_emitter->pin()->description().c_str())
+                    : PSTR("Virtual"));
+        }
     });
 #endif
 
diff --git a/code/espurna/debug.cpp b/code/espurna/debug.cpp
index 33929262..5f6bf33b 100644
--- a/code/espurna/debug.cpp
+++ b/code/espurna/debug.cpp
@@ -29,23 +29,53 @@ Copyright (C) 2016-2019 by Xose Pérez <xose dot perez at gmail dot com>
 #include <WiFiUdp.h>
 #endif
 
+namespace espurna {
+namespace debug {
 namespace settings {
-namespace internal {
+namespace options {
 namespace {
 
+using ::settings::options::Enumeration;
+
 alignas(4) static constexpr char Disabled[] PROGMEM = "off";
 alignas(4) static constexpr char Enabled[] PROGMEM = "on";
 alignas(4) static constexpr char SkipBoot[] PROGMEM = "skip-boot";
 
-static constexpr const EnumOption<DebugLogMode> DebugLogModeOptions[] PROGMEM {
+static constexpr Enumeration<DebugLogMode> DebugLogModeOptions[] PROGMEM {
     {DebugLogMode::Disabled, Disabled},
     {DebugLogMode::Enabled, Enabled},
     {DebugLogMode::SkipBoot, SkipBoot},
 };
 
 } // namespace
+} // namespace options
 
-String serialize(DebugLogMode value) {
+namespace keys {
+namespace {
+
+alignas(4) static constexpr char SdkDebug[] PROGMEM = "dbgSDK";
+alignas(4) static constexpr char Mode[] PROGMEM = "dbgLogMode";
+alignas(4) static constexpr char Buffer[] PROGMEM = "dbgLogBuf";
+alignas(4) static constexpr char BufferSize[] PROGMEM = "dbgLogBufSize";
+
+alignas(4) static constexpr char HeartbeatMode[] PROGMEM = "dbgHbMode";
+alignas(4) static constexpr char HeartbeatInterval[] PROGMEM = "dbgHbIntvl";
+
+} // namespace
+} // namespace keys
+} // namespace settings
+} // namespace debug
+} // namespace espurna
+
+namespace settings {
+namespace internal {
+namespace {
+
+using espurna::debug::settings::options::DebugLogModeOptions;
+
+} // namespace
+
+String serialize(::DebugLogMode value) {
     return serialize(DebugLogModeOptions, value);
 }
 
@@ -57,6 +87,7 @@ DebugLogMode convert(const String& value) {
 } // namespace internal
 } // namespace settings
 
+namespace espurna {
 namespace debug {
 namespace {
 
@@ -75,7 +106,10 @@ private:
     bool _value { false };
 };
 
+} // namespace
+
 namespace build {
+namespace {
 
 constexpr Timestamp AddTimestamp { 1 == DEBUG_ADD_TIMESTAMP };
 
@@ -103,42 +137,49 @@ constexpr size_t bufferSize() {
     return DEBUG_LOG_BUFFER_SIZE;
 }
 
+} // namespace
 } // namespace build
 
 namespace settings {
+namespace {
 
 bool sdkDebug() {
-    return getSetting("dbgSDK", build::sdkDebug());
+    return getSetting(keys::SdkDebug, build::sdkDebug());
 }
 
 DebugLogMode mode() {
-    return getSetting("dbgLogMode", build::mode());
+    return getSetting(keys::Mode, build::mode());
 }
 
 bool buffer() {
-    return getSetting("dbgLogBuf", build::buffer());
+    return getSetting(keys::Buffer, build::buffer());
 }
 
 size_t bufferSize() {
-    return getSetting("dbgLogBufSize", build::bufferSize());
+    return getSetting(keys::BufferSize, build::bufferSize());
 }
 
 espurna::heartbeat::Mode heartbeatMode() {
-    return getSetting("dbgHbMode", espurna::heartbeat::currentMode());
+    return getSetting(keys::HeartbeatMode, espurna::heartbeat::currentMode());
 }
 
 espurna::duration::Seconds heartbeatInterval() {
-    return getSetting("dbgHbIntvl", espurna::heartbeat::currentInterval());
+    return getSetting(keys::HeartbeatInterval, espurna::heartbeat::currentInterval());
 }
 
+} // namespace
 } // namespace settings
 
 namespace internal {
+namespace {
 
 bool enabled { false };
 
+} // namespace
 } // namespace internal
 
+namespace {
+
 bool enabled() {
     return internal::enabled;
 }
@@ -610,35 +651,36 @@ void onBoot() {
 
 } // namespace
 } // namespace debug
+} // namespace espurna
 
 void debugSendBytes(const uint8_t* bytes, size_t size) {
-    debug::buffer::sendBytes(bytes, size);
+    espurna::debug::buffer::sendBytes(bytes, size);
 }
 
 #if DEBUG_LOG_BUFFER_SUPPORT
 bool debugLogBuffer() {
-    return debug::buffer::enabled();
+    return espurna::debug::buffer::enabled();
 }
 #endif
 
 void debugSend(const char* format, ...) {
-    if (debug::enabled()) {
+    if (espurna::debug::enabled()) {
         va_list args;
         va_start(args, format);
-        debug::formatAndSend(format, args);
+        espurna::debug::formatAndSend(format, args);
         va_end(args);
     }
 }
 
 void debugConfigureBoot() {
-    debug::onBoot();
+    espurna::debug::onBoot();
 }
 
 #if WEB_SUPPORT
 void debugWebSetup() {
     wsRegister()
-        .onVisible(debug::web::onVisible)
-        .onAction(debug::web::onAction);
+        .onVisible(espurna::debug::web::onVisible)
+        .onAction(espurna::debug::web::onAction);
 }
 #endif
 
@@ -648,24 +690,24 @@ void debugSetup() {
 #endif
 
 #if DEBUG_UDP_SUPPORT
-    if (debug::syslog::build::enabled()) {
-        debug::syslog::configure();
-        espurnaRegisterReload(debug::syslog::configure);
+    if (espurna::debug::syslog::build::enabled()) {
+        espurna::debug::syslog::configure();
+        espurnaRegisterReload(espurna::debug::syslog::configure);
     }
 #endif
 
 #if DEBUG_LOG_BUFFER_SUPPORT
 #if TERMINAL_SUPPORT
     terminalRegisterCommand(F("DEBUG.BUFFER"), [](::terminal::CommandContext&& ctx) {
-        debug::buffer::disable();
-        if (!debug::buffer::size()) {
+        espurna::debug::buffer::disable();
+        if (!espurna::debug::buffer::size()) {
             terminalError(ctx, F("buffer is empty\n"));
             return;
         }
 
         ctx.output.printf_P(PSTR("buffer size: %u / %u bytes\n"),
-            debug::buffer::size(), debug::buffer::capacity());
-        debug::buffer::dump(ctx.output);
+            espurna::debug::buffer::size(), espurna::debug::buffer::capacity());
+        espurna::debug::buffer::dump(ctx.output);
         terminalOK(ctx);
     });
 #endif
diff --git a/code/espurna/gpio.cpp b/code/espurna/gpio.cpp
index 5f89480e..c07e9cea 100644
--- a/code/espurna/gpio.cpp
+++ b/code/espurna/gpio.cpp
@@ -18,25 +18,48 @@ Copyright (C) 2017-2019 by Xose Pérez <xose dot perez at gmail dot com>
 
 #include "ws.h"
 
+namespace espurna {
+namespace gpio {
+namespace settings {
+namespace options {
+namespace {
+
+using ::settings::options::Enumeration;
+
+alignas(4) static constexpr char None[] PROGMEM = "none";
+alignas(4) static constexpr char Hardware[] PROGMEM = "hardware";
+
+[[gnu::unused]] alignas(4) static constexpr char Mcp23s08[] PROGMEM = "mcp23s08";
+
+static constexpr Enumeration<GpioType> GpioTypeOptions[] PROGMEM {
+    {GpioType::Hardware, Hardware},
+#if MCP23S08_SUPPORT
+    {GpioType::Mcp23s08, Mcp23s08},
+#endif
+    {GpioType::None, None},
+};
+
+} // namespace
+} // namespace options
+} // namespace settings
+} // namespace gpio
+} // namespace espurna
+
 namespace settings {
 namespace internal {
+namespace {
+
+using espurna::gpio::settings::options::GpioTypeOptions;
+
+} // namespace
 
 template <>
 GpioType convert(const String& value) {
-    alignas(4) static constexpr char None[] PROGMEM = "none";
-    alignas(4) static constexpr char Hardware[] PROGMEM = "hardware";
+    return convert(GpioTypeOptions, value, GpioType::None);
+}
 
-    [[gnu::unused]] alignas(4) static constexpr char Mcp23s08[] PROGMEM = "mcp23s08";
-
-    constexpr static const EnumOption<GpioType> options[] PROGMEM {
-        {GpioType::Hardware, Hardware},
-#if MCP23S08_SUPPORT
-        {GpioType::Mcp23s08, Mcp23s08},
-#endif
-        {GpioType::None, None},
-    };
-
-    return convert(options, value, GpioType::None);
+String serialize(GpioType value) {
+    return serialize(GpioTypeOptions, value);
 }
 
 } // namespace internal
@@ -99,7 +122,7 @@ public:
         return false;
     }
 
-    BasePinPtr pin(unsigned char index) {
+    BasePinPtr pin(unsigned char index) override {
         return std::make_unique<GpioPin>(index);
     }
 
diff --git a/code/espurna/gpio.h b/code/espurna/gpio.h
index 5466166f..0047b443 100644
--- a/code/espurna/gpio.h
+++ b/code/espurna/gpio.h
@@ -19,6 +19,14 @@ enum class GpioType : int {
     Mcp23s08
 };
 
+namespace settings {
+namespace internal {
+
+String serialize(GpioType);
+
+} // namespace internal
+} // namespace settings
+
 class GpioBase {
 public:
     virtual const char* id() const = 0;
diff --git a/code/espurna/ifan.cpp b/code/espurna/ifan.cpp
index e7e1d8fb..661fc379 100644
--- a/code/espurna/ifan.cpp
+++ b/code/espurna/ifan.cpp
@@ -24,8 +24,9 @@ Copyright (C) 2016-2019 by Xose Pérez <xose dot perez at gmail dot com>
 
 // TODO: in case there are more FANs, move externally
 
+namespace ifan {
 namespace settings {
-namespace internal {
+namespace options {
 namespace {
 
 alignas(4) static constexpr char Off[] PROGMEM = "off";
@@ -33,13 +34,25 @@ alignas(4) static constexpr char Low[] PROGMEM = "low";
 alignas(4) static constexpr char Medium[] PROGMEM = "medium";
 alignas(4) static constexpr char High[] PROGMEM = "high";
 
-static constexpr const std::array<EnumOption<FanSpeed>, 4> FanSpeedOptions PROGMEM {
+using ::settings::options::Enumeration;
+static constexpr std::array<Enumeration<FanSpeed>, 4> FanSpeedOptions PROGMEM {
     {{FanSpeed::Off, Off},
      {FanSpeed::Low, Low},
      {FanSpeed::Medium, Medium},
      {FanSpeed::High, High}}
 };
 
+} // namespace
+} // namespace options
+} // namespace settings
+} // namespace ifan
+
+namespace settings {
+namespace internal {
+namespace {
+
+using ifan::settings::options::FanSpeedOptions;
+
 } // namespace
 
 template <>
diff --git a/code/espurna/led.cpp b/code/espurna/led.cpp
index 3a0f72b5..00c11718 100644
--- a/code/espurna/led.cpp
+++ b/code/espurna/led.cpp
@@ -30,6 +30,7 @@ $ pio run -e ... -t espurna/led_pattern.re.ipp
 #include <forward_list>
 #include <vector>
 
+namespace espurna {
 namespace led {
 namespace {
 
@@ -42,7 +43,7 @@ namespace {
 // TODO: full-width int for repeats instead of 8bit? right now, string parser will *force* [min:max] range,
 // but anything else is experiencing overflow mechanics
 
-struct alignas(4) Delay {
+struct alignas(8) Delay {
     using Source = espurna::time::CpuClock;
     using Duration = Source::duration;
     using TimePoint = Source::time_point;
@@ -367,14 +368,25 @@ bool Led::toggle() {
 #include "led_pattern.re.ipp"
 
 } // namespace
-} // namespace led
-
-// -----------------------------------------------------------------------------
 
 namespace settings {
-namespace internal {
+namespace keys {
 namespace {
 
+alignas(4) static constexpr char Gpio[] PROGMEM = "ledGpio";
+alignas(4) static constexpr char Inverse[] PROGMEM = "ledInv";
+alignas(4) static constexpr char Mode[] PROGMEM = "ledMode";
+alignas(4) static constexpr char Relay[] PROGMEM = "ledRelay";
+alignas(4) static constexpr char Pattern[] PROGMEM = "ledPattern";
+
+} // namespace
+} // namespace keys
+
+namespace options {
+namespace {
+
+using ::settings::options::Enumeration;
+
 alignas(4) static constexpr char Manual[] PROGMEM = "manual";
 alignas(4) static constexpr char WiFi[] PROGMEM = "wifi";
 alignas(4) static constexpr char On[] PROGMEM = "on";
@@ -391,7 +403,7 @@ alignas(4) static constexpr char Relays[] PROGMEM = "relays";
 alignas(4) static constexpr char RelaysWiFi[] PROGMEM = "relays-wifi";
 #endif
 
-static constexpr const EnumOption<LedMode> LedModeOptions[] PROGMEM {
+static constexpr Enumeration<LedMode> LedModeOptions[] PROGMEM {
     {LedMode::Manual, Manual},
     {LedMode::WiFi, WiFi},
 #if RELAY_SUPPORT
@@ -408,6 +420,20 @@ static constexpr const EnumOption<LedMode> LedModeOptions[] PROGMEM {
 #endif
 };
 
+} // namespace
+} // namespace options
+} // namespace settings
+} // namespace led
+} // namespace espurna
+
+// -----------------------------------------------------------------------------
+
+namespace settings {
+namespace internal {
+namespace {
+
+using espurna::led::settings::options::LedModeOptions;
+
 } // namespace
 
 template <>
@@ -419,44 +445,15 @@ String serialize(LedMode mode) {
     return serialize(LedModeOptions, mode);
 }
 
-#if 0
-String serialize(espurna::duration::ClockCycles value) {
-    String out;
-    out.reserve(16);
-
-    out += std::chrono::duration_cast<Milliseconds>(value).count();
-
-    return out;
-}
-
-[[gnu::unused]]
-String serialize(const led::Pattern& pattern) {
-    String out;
-
-    for (auto& delay : pattern.delays()) {
-        if (out.length()) {
-            out += ' ';
-        }
-
-        out += serialize(delay.on());
-        out += ',';
-        out += serialize(delay.off());
-        out += ',';
-        out += String(delay.repeats(), 10);
-    }
-
-    return out;
-}
-#endif
-
 } // namespace internal
 } // namespace settings
 
 // -----------------------------------------------------------------------------
 
+namespace espurna {
 namespace led {
-namespace {
 namespace build {
+namespace {
 
 constexpr size_t LedsMax { 8ul };
 
@@ -541,49 +538,43 @@ constexpr bool inverse(size_t index) {
     );
 }
 
+} // namespace
 } // namespace build
 
 namespace settings {
-namespace keys {
-
-alignas(4) static constexpr char Gpio[] PROGMEM = "ledGpio";
-alignas(4) static constexpr char Inverse[] PROGMEM = "ledInv";
-alignas(4) static constexpr char Mode[] PROGMEM = "ledMode";
-alignas(4) static constexpr char Relay[] PROGMEM = "ledRelay";
-alignas(4) static constexpr char Pattern[] PROGMEM = "ledPattern";
-
-} // namespace keys
+namespace {
 
 unsigned char pin(size_t id) {
-    return getSetting({FPSTR(keys::Gpio), id}, build::pin(id));
+    return getSetting({keys::Gpio, id}, build::pin(id));
 }
 
 bool inverse(size_t id) {
-    return getSetting({FPSTR(keys::Inverse), id}, build::inverse(id));
+    return getSetting({keys::Inverse, id}, build::inverse(id));
 }
 
 LedMode mode(size_t id) {
-    return getSetting({FPSTR(keys::Mode), id}, build::mode(id));
+    return getSetting({keys::Mode, id}, build::mode(id));
 }
 
 size_t relay(size_t id) {
-    return getSetting({FPSTR(keys::Relay), id}, build::relay(id));
+    return getSetting({keys::Relay, id}, build::relay(id));
 }
 
 Pattern pattern(size_t id) {
-    return Pattern(getSetting({FPSTR(keys::Pattern), id}));
+    return Pattern(getSetting({keys::Pattern, id}));
 }
 
 void migrate(int version) {
     if (version < 5) {
         delSettingPrefix({
-            "ledGPIO",
-            "ledGpio",
-            "ledLogic"
+            keys::Gpio,
+            PSTR("ledGPIO"),
+            PSTR("ledLogic")
         });
     }
 }
 
+} // namespace
 } // namespace settings
 
 // For network-based modes, indefinitely cycle ON <-> OFF
@@ -606,49 +597,70 @@ LED_STATIC_DELAY(NetworkConfigInverse, 900, 100);
 LED_STATIC_DELAY(NetworkIdle, 500, 500);
 
 namespace internal {
+namespace {
 
 std::vector<Led> leds;
 bool update { false };
 
+} // namespace
 } // namespace internal
 
 namespace settings {
-namespace defaults {
+namespace query {
+namespace internal {
+namespace {
 
-#define ID_DEFAULT(NAME)\
+#define ID_VALUE(NAME)\
 String NAME (size_t id) {\
-    return ::settings::internal::serialize(::led::settings::NAME(id));\
+    return ::settings::internal::serialize(::espurna::led::settings::NAME(id));\
 }
 
-ID_DEFAULT(pin)
-ID_DEFAULT(inverse)
-ID_DEFAULT(mode)
-ID_DEFAULT(relay)
+ID_VALUE(pin)
+ID_VALUE(inverse)
+ID_VALUE(mode)
+ID_VALUE(relay)
 
-#undef ID_DEFAULT
+#undef ID_VALUE
 
-} // namespace defaults
+} // namespace
+} // namespace internal
 
-String findKeyDefault(const String& key) {
-    using ::settings::KeyDefault;
-    using ::settings::Iota;
+namespace {
 
-    constexpr static const std::array<KeyDefault, 4> defaults PROGMEM {
-        {{keys::Gpio, defaults::pin},
-         {keys::Inverse, defaults::inverse},
-         {keys::Mode, defaults::mode},
-         {keys::Relay, defaults::relay}}
-    };
+static constexpr ::settings::query::IndexedSetting IndexedSettings[] PROGMEM {
+    {keys::Gpio, internal::pin},
+    {keys::Inverse, internal::inverse},
+    {keys::Mode, internal::mode},
+#if RELAY_SUPPORT
+    {keys::Relay, internal::relay},
+#endif
+};
 
-    return KeyDefault::findKeyDefault(
-            Iota{internal::leds.size()}, defaults, key);
+bool checkSamePrefix(::settings::StringView key) {
+    static constexpr char Prefix[] PROGMEM = "led";
+    return ::settings::query::samePrefix(key, Prefix);
 }
 
+String findValueFrom(::settings::StringView key) {
+    return ::settings::query::IndexedSetting::findValueFrom(
+        ::espurna::led::internal::leds.size(), IndexedSettings, key);
+}
+
+void setup() {
+    ::settingsRegisterQueryHandler({
+        .check = checkSamePrefix,
+        .get = findValueFrom
+    });
+}
+
+} // namespace
+} // namespace query
 } // namespace settings
 
 #if RELAY_SUPPORT
 namespace relay {
 namespace internal {
+namespace {
 
 struct Link {
     Led& led;
@@ -692,8 +704,11 @@ size_t find(Led& led) {
     return RelaysMax;
 }
 
+} // namespace
 } // namespace internal
 
+namespace {
+
 void unlink(Led& led) {
     internal::unlink(led);
 }
@@ -722,9 +737,12 @@ bool areAnyOn() {
     return result;
 }
 
+} // namespace
 } // namespace relay
 #endif
 
+namespace {
+
 size_t count() {
     return internal::leds.size();
 }
@@ -927,8 +945,11 @@ void loop() {
     cancel();
 }
 
+} // namespace
+
 #if MQTT_SUPPORT
 namespace mqtt {
+namespace {
 
 void callback(unsigned int type, const char* topic, char* payload) {
     if (type == MQTT_CONNECT_EVENT) {
@@ -970,14 +991,16 @@ void callback(unsigned int type, const char* topic, char* payload) {
     }
 }
 
+} // namespace
 } // namespace mqtt
 #endif // MQTT_SUPPORT
 
 #if WEB_SUPPORT
 namespace web {
+namespace {
 
-bool onKeyCheck(const char * key, JsonVariant&) {
-    return (strncmp(key, "led", 3) == 0);
+bool onKeyCheck(const char* key, JsonVariant&) {
+    return settings::query::checkSamePrefix(key);
 }
 
 void onVisible(JsonObject& root) {
@@ -985,38 +1008,19 @@ void onVisible(JsonObject& root) {
 }
 
 void onConnected(JsonObject& root) {
-    if (!count()) {
-        return;
+    if (count()) {
+        ::web::ws::EnumerableConfig config{root, STRING_VIEW("ledConfig")};
+        config(STRING_VIEW("leds"), ::espurna::led::count(), settings::query::IndexedSettings);
     }
-
-    // TODO: something compatible with the settings defaults, to display module config in the terminal as well
-    // TODO: add ledPattern strings from settings?
-    // TODO: serialize()? although, bool will produce `true` / `false` and not a short number result. and it would be a dynamic string entry
-
-    ::web::ws::EnumerableConfig config{root, F("ledConfig")};
-    config(F("leds"), ::led::count(), {
-        {F("ledGpio"), [](JsonArray& led, size_t index) {
-            led.add(settings::pin(index));
-        }},
-        {F("ledInv"), [](JsonArray& led, size_t index) {
-            led.add(static_cast<int>(settings::inverse(index)));
-        }},
-        {F("ledMode"), [](JsonArray& led, size_t index) {
-            led.add(static_cast<int>(settings::mode(index)));
-        }},
-#if RELAY_SUPPORT
-        {F("ledRelay"), [](JsonArray& led, size_t index) {
-            led.add(settings::relay(index));
-        }}
-#endif
-    });
 }
 
+} // namespace
 } // namespace web
 #endif // WEB_SUPPORT
 
 #if TERMINAL_SUPPORT
 namespace terminal {
+namespace {
 
 void setup() {
     terminalRegisterCommand(F("LED"), [](::terminal::CommandContext&& ctx) {
@@ -1028,12 +1032,11 @@ void setup() {
             }
 
             auto& led = internal::leds[id];
-            if (ctx.argv.size() > 2) {
+            if (ctx.argv.size() == 2) {
+                settingsDump(ctx, settings::query::IndexedSettings, id);
+            } else if (ctx.argv.size() > 2) {
                 led.mode(LedMode::Manual);
                 pattern(led, Pattern(ctx.argv[2]));
-            } else {
-                led.mode(settings::mode(id));
-                led.pattern(settings::pattern(id));
             }
 
             schedule();
@@ -1042,13 +1045,21 @@ void setup() {
             return;
         }
 
-        terminalError(ctx, F("LED <ID> [<PATTERN>]"));
+        size_t id { 0 };
+        for (const auto& led : internal::leds) {
+            ctx.output.printf_P(
+                PSTR("led%u {Gpio=%hhu Mode=%s}\n"), id++, led.pin(),
+                ::settings::internal::serialize(led.mode()).c_str());
+        }
     });
 }
 
+} // namespace
 } // namespace terminal
 #endif
 
+namespace {
+
 void setup() {
     migrateVersion(settings::migrate);
     internal::leds.reserve(build::preconfiguredLeds());
@@ -1063,10 +1074,10 @@ void setup() {
                 settings::inverse(index), settings::mode(index));
     }
 
-    auto leds = count();
+    const auto leds = internal::leds.size();
     DEBUG_MSG_P(PSTR("[LED] Number of leds: %u\n"), leds);
     if (leds) {
-        ::settingsRegisterDefaults("led", settings::findKeyDefault);
+        led::settings::query::setup();
 #if MQTT_SUPPORT
         ::mqttRegister(mqtt::callback);
 #endif
@@ -1094,33 +1105,34 @@ void setup() {
 
 } // namespace
 } // namespace led
+} // namespace led
 
 bool ledStatus(size_t id, bool status) {
-    if (id < led::count()) {
-        return led::status(id, status);
+    if (id < espurna::led::count()) {
+        return espurna::led::status(id, status);
     }
 
     return status;
 }
 
 bool ledStatus(size_t id) {
-    if (id < led::count()) {
-        return led::status(id);
+    if (id < espurna::led::count()) {
+        return espurna::led::status(id);
     }
 
     return false;
 }
 
 size_t ledCount() {
-    return led::count();
+    return espurna::led::count();
 }
 
 void ledLoop() {
-    led::loop();
+    espurna::led::loop();
 }
 
 void ledSetup() {
-    led::setup();
+    espurna::led::setup();
 }
 
 #endif // LED_SUPPORT
diff --git a/code/espurna/light.cpp b/code/espurna/light.cpp
index aa876989..8580a033 100644
--- a/code/espurna/light.cpp
+++ b/code/espurna/light.cpp
@@ -694,7 +694,8 @@ my92xx_model_t convert(const String& value) {
     alignas(4) static constexpr char MY9291[] PROGMEM = "9291";
     alignas(4) static constexpr char MY9231[] PROGMEM = "9231";
 
-    constexpr static const std::array<EnumOption<my92xx_model_t>, 2> options {
+    using Options = std::array<::settings::options::Enumeration<my92xx_model_t>, 2>;
+    static constexpr Options options {
         {{MY92XX_MODEL_MY9291, MY9291},
          {MY92XX_MODEL_MY9231, MY9231}}
     };
diff --git a/code/espurna/migrate.cpp b/code/espurna/migrate.cpp
index 0e52ee93..e09ace89 100644
--- a/code/espurna/migrate.cpp
+++ b/code/espurna/migrate.cpp
@@ -1,8 +1,9 @@
 /*
 
-MIGRATE MODULE
+Part of the SETTINGS MODULE
 
 Copyright (C) 2016-2019 by Xose Pérez <xose dot perez at gmail dot com>
+Copyright (C) 2020-2021 by Maxim Prokhorov <prokhorov dot max at outlook dot com>
 
 */
 
@@ -12,73 +13,84 @@ Copyright (C) 2016-2019 by Xose Pérez <xose dot perez at gmail dot com>
 #include <vector>
 #include <utility>
 
-void delSettingPrefix(const std::initializer_list<const char*>& prefixes) {
+namespace espurna {
+namespace settings {
+namespace schema {
+namespace {
+
+// Configuration version for the internal key-value storage
+// Represented as a 32bit int, updates every time things change
+constexpr static int Version PROGMEM { CFG_VERSION };
+alignas(4) static constexpr char Key[] PROGMEM = "cfg";
+
+int version() {
+    return getSetting(Key, Version);
+}
+
+} // namespace
+} // namespace schema
+
+namespace migrate {
+namespace {
+
+void deletePrefixes(::settings::query::StringViewIterator prefixes) {
     std::vector<String> to_purge;
 
-    settings::internal::foreach([&](settings::kvs_type::KeyValueResult&& kv) {
-        auto key = kv.key.read();
-        for (const auto* prefix : prefixes) {
-            if (key.startsWith(prefix)) {
+    ::settings::internal::foreach([&](::settings::kvs_type::KeyValueResult&& kv) {
+        const auto key = kv.key.read();
+        for (auto it = prefixes.begin(); it != prefixes.end(); ++it) {
+            if (::settings::query::samePrefix(::settings::StringView{key}, (*it))) {
                 to_purge.push_back(std::move(key));
                 return;
             }
         }
     });
 
-    for (auto& key : to_purge) {
+    for (const auto& key : to_purge) {
         delSetting(key);
     }
 }
 
-void delSettingPrefix(const char* prefix) {
-    delSettingPrefix({prefix});
-}
-
-void delSettingPrefix(const String& prefix) {
-    delSettingPrefix(prefix.c_str());
-}
-
-// Configuration versions
-//
-// 1: based on Embedis, no board definitions
-// 2: based on Embedis, with board definitions 1-based
-// 3: based on Embedis, with board definitions 0-based
-// 4: based on Embedis, no board definitions
-// 5: based on Embedis, updated rfb codes format
-
-int migrateVersion() {
-    const static auto version = getSetting("cfg", CFG_VERSION);
-    if (version != CFG_VERSION) {
-        return version;
+int currentVersion() {
+    const static auto current = schema::version();
+    if (current != schema::Version) {
+        return current;
     }
 
     return 0;
 }
 
+} // namespace
+} // namespace migrate
+} // namespace settings
+} // namespace espurna
+
+void delSettingPrefix(::settings::query::StringViewIterator prefixes) {
+    espurna::settings::migrate::deletePrefixes(std::move(prefixes));
+}
+
+int migrateVersion() {
+    return espurna::settings::migrate::currentVersion();
+}
+
 void migrateVersion(MigrateVersionCallback callback) {
-    int version = migrateVersion();
-    if (version) {
-        callback(version);
+    static const auto current = espurna::settings::migrate::currentVersion();
+    if (current) {
+        callback(current);
     }
 }
 
 void migrate() {
-    // We either get 0, when version did not change
-    // Or, the version we migrate from
-    const auto version = migrateVersion();
-    setSetting("cfg", CFG_VERSION);
-
-    // get rid of old keys that were never used until now
-    // and some very old keys that were forced via migrate.ino
-    if (version) {
-        switch (version) {
-        case 2:
-        case 3:
-        case 4:
-            delSetting("board");
-            break;
-        }
+    using namespace espurna::settings::schema;
+    setSetting(FPSTR(Key), Version);
 
+    using namespace espurna::settings::migrate;
+    switch (currentVersion()) {
+    case 2:
+    case 3:
+    case 4:
+        delSetting(F("board"));
         saveSettings();
+        break;
     }
 }
diff --git a/code/espurna/mqtt.cpp b/code/espurna/mqtt.cpp
index ff1f238e..a83a013d 100644
--- a/code/espurna/mqtt.cpp
+++ b/code/espurna/mqtt.cpp
@@ -223,105 +223,141 @@ constexpr uint16_t mfln() {
 } // namespace build
 
 namespace settings {
+namespace keys {
+
+alignas(4) static constexpr char Server[] PROGMEM = "mqttServer";
+alignas(4) static constexpr char Port[] PROGMEM = "mqttPort";
+
+alignas(4) static constexpr char Enabled[] PROGMEM = "mqttEnabled";
+alignas(4) static constexpr char Autoconnect[] PROGMEM = "mqttAutoconnect";
+
+alignas(4) static constexpr char Topic[] PROGMEM = "mqttTopic";
+alignas(4) static constexpr char Getter[] PROGMEM = "mqttGetter";
+alignas(4) static constexpr char Setter[] PROGMEM = "mqttSetter";
+
+alignas(4) static constexpr char User[] PROGMEM = "mqttUser";
+alignas(4) static constexpr char Password[] PROGMEM = "mqttPassword";
+alignas(4) static constexpr char QoS[] PROGMEM = "mqttQoS";
+alignas(4) static constexpr char Retain[] PROGMEM = "mqttRetain";
+alignas(4) static constexpr char Keepalive[] PROGMEM = "mqttKeep";
+alignas(4) static constexpr char ClientId[] PROGMEM = "mqttClientID";
+alignas(4) static constexpr char TopicWill[] PROGMEM = "mqttWill";
+
+alignas(4) static constexpr char UseJson[] PROGMEM = "mqttUseJson";
+alignas(4) static constexpr char TopicJson[] PROGMEM = "mqttJson";
+
+alignas(4) static constexpr char HeartbeatMode[] PROGMEM = "mqttHbMode";
+alignas(4) static constexpr char HeartbeatInterval[] PROGMEM = "mqttHbIntvl";
+alignas(4) static constexpr char SkipTime[] PROGMEM = "mqttSkipTime";
+
+alignas(4) static constexpr char PayloadOnline[] PROGMEM = "mqttPayloadOnline";
+alignas(4) static constexpr char PayloadOffline[] PROGMEM = "mqttPayloadOffline";
+
+alignas(4) static constexpr char Secure[] PROGMEM = "mqttUseSSL";
+alignas(4) static constexpr char Fingerprint[] PROGMEM = "mqttFP";
+alignas(4) static constexpr char SecureClientCheck[] PROGMEM = "mqttScCheck";
+alignas(4) static constexpr char SecureClientMfln[] PROGMEM = "mqttScMFLN";
+
+} // namespace keys
 
 String server() {
-    return getSetting("mqttServer", build::server());
+    return getSetting(keys::Server, build::server());
 }
 
 uint16_t port() {
-    return getSetting("mqttPort", build::port());
+    return getSetting(keys::Port, build::port());
 }
 
 bool enabled() {
-    return getSetting("mqttEnabled", build::enabled());
+    return getSetting(keys::Enabled, build::enabled());
 }
 
 bool autoconnect() {
-    return getSetting("mqttAutoconnect", build::autoconnect());
+    return getSetting(keys::Autoconnect, build::autoconnect());
 }
 
 String topic() {
-    return getSetting("mqttTopic", build::topic());
+    return getSetting(keys::Topic, build::topic());
 }
 
 String getter() {
-    return getSetting("mqttGetter", build::getter());
+    return getSetting(keys::Getter, build::getter());
 }
 
 String setter() {
-    return getSetting("mqttSetter", build::setter());
+    return getSetting(keys::Setter, build::setter());
 }
 
 String user() {
-    return getSetting("mqttUser", build::user());
+    return getSetting(keys::User, build::user());
 }
 
 String password() {
-    return getSetting("mqttPassword", build::password());
+    return getSetting(keys::Password, build::password());
 }
 
 int qos() {
-    return getSetting("mqttQoS", build::qos());
+    return getSetting(keys::QoS, build::qos());
 }
 
 bool retain() {
-    return getSetting("mqttRetain", build::retain());
+    return getSetting(keys::Retain, build::retain());
 }
 
 uint16_t keepalive() {
-    return getSetting("mqttKeep", build::keepalive());
+    return getSetting(keys::Keepalive, build::keepalive());
 }
 
 String clientId() {
-    return getSetting("mqttClientID", getIdentifier());
+    return getSetting(keys::ClientId, getIdentifier());
 }
 
 String topicWill() {
-    return getSetting("mqttWill", build::topicWill());
+    return getSetting(keys::TopicWill, build::topicWill());
 }
 
 bool json() {
-    return getSetting("mqttUseJson", build::json());
+    return getSetting(keys::UseJson, build::json());
 }
 
 String topicJson() {
-    return getSetting("mqttJson", build::topicJson());
+    return getSetting(keys::TopicJson, build::topicJson());
 }
 
 espurna::heartbeat::Mode heartbeatMode() {
-    return getSetting("mqttHbMode", espurna::heartbeat::currentMode());
+    return getSetting(keys::HeartbeatMode, espurna::heartbeat::currentMode());
 }
 
 espurna::duration::Seconds heartbeatInterval() {
-    return getSetting("mqttHbIntvl", espurna::heartbeat::currentInterval());
+    return getSetting(keys::HeartbeatInterval, espurna::heartbeat::currentInterval());
 }
 
 unsigned long skipTime() {
-    return getSetting("mqttSkipTime", build::skipTime());
+    return getSetting(keys::SkipTime, build::skipTime());
 }
 
 String payloadOnline() {
-    return getSetting("mqttPayloadOnline", build::payloadOnline());
+    return getSetting(keys::PayloadOnline, build::payloadOnline());
 }
 
 String payloadOffline() {
-    return getSetting("mqttPayloadOffline", build::payloadOffline());
+    return getSetting(keys::PayloadOffline, build::payloadOffline());
 }
 
 bool secure() {
-    return getSetting("mqttUseSSL", build::secure());
+    return getSetting(keys::Secure, build::secure());
 }
 
 int secureClientCheck() {
-    return getSetting("mqttScCheck", build::secureClientCheck());
+    return getSetting(keys::SecureClientCheck, build::secureClientCheck());
 }
 
 String fingerprint() {
-    return getSetting("mqttFP", build::fingerprint());
+    return getSetting(keys::Fingerprint, build::fingerprint());
 }
 
 uint16_t mfln() {
-    return getSetting("mqttScMFLN", build::mfln());
+    return getSetting(keys::SecureClientMfln, build::mfln());
 }
 
 } // namespace settings
diff --git a/code/espurna/relay.cpp b/code/espurna/relay.cpp
index b4e10db4..2b7b0d88 100644
--- a/code/espurna/relay.cpp
+++ b/code/espurna/relay.cpp
@@ -38,8 +38,8 @@ namespace flood {
 using Duration = espurna::duration::Milliseconds;
 using Seconds = std::chrono::duration<float>;
 
-namespace {
 namespace build {
+namespace {
 
 constexpr Duration window() {
     static_assert(Seconds{RELAY_FLOOD_WINDOW}.count() >= 0.0f, "");
@@ -50,24 +50,35 @@ constexpr unsigned long changes() {
     return RELAY_FLOOD_CHANGES;
 }
 
+} // namespace
 } // namespace build
 
 namespace settings {
+namespace keys {
+namespace {
+
+alignas(4) static constexpr char Time[] PROGMEM = "relayFloodTime";
+alignas(4) static constexpr char Changes[] PROGMEM = "relayFloodChanges";
+
+} // namespace
+} // namespace keys
+
+namespace {
 
 Duration window() {
-    return getSetting("relayFloodTime", build::window());
+    return getSetting(keys::Time, build::window());
 }
 
 unsigned long changes() {
-    return getSetting("relayFloodChanges", build::changes());
+    return getSetting(keys::Changes, build::changes());
 }
 
-} // namespace settings
 } // namespace
+} // namespace settings
 } // namespace flood
 
-namespace {
 namespace build {
+namespace {
 
 constexpr espurna::duration::Milliseconds saveDelay() {
     return espurna::duration::Milliseconds(RELAY_SAVE_DELAY);
@@ -257,8 +268,8 @@ constexpr PayloadStatus mqttDisconnectionStatus(size_t index) {
     );
 }
 
-} // namespace build
 } // namespace
+} // namespace build
 
 namespace pulse {
 
@@ -280,8 +291,8 @@ enum class Mode {
 namespace espurna {
 namespace relay {
 namespace pulse {
-namespace {
 namespace build {
+namespace {
 
 constexpr Seconds time(size_t index) {
     return Seconds(
@@ -318,12 +329,23 @@ constexpr Mode mode(size_t index) {
     );
 }
 
+} // namespace
 } // namespace build
 
 namespace settings {
+namespace keys {
+namespace {
+
+alignas(4) static constexpr char Time[] PROGMEM = "relayTime";
+alignas(4) static constexpr char Mode[] PROGMEM = "relayPulse";
+
+} // namespace
+} // namespace keys
+
+namespace {
 
 Result time(size_t index) {
-    auto time = ::settings::internal::get(SettingsKey{"relayTime", index}.value());
+    auto time = ::settings::internal::get(SettingsKey{keys::Time, index}.value());
     if (!time) {
         return Result { std::chrono::duration_cast<Duration>(build::time(index)) };
     }
@@ -332,11 +354,14 @@ Result time(size_t index) {
 }
 
 Mode mode(size_t index) {
-    return getSetting({"relayPulse", index}, build::mode(index));
+    return getSetting({keys::Mode, index}, build::mode(index));
 }
 
+} // namespace
 } // namespace settings
 
+namespace {
+
 struct Timer {
     // limit is per https://www.espressif.com/sites/default/files/documentation/2c-esp8266_non_os_sdk_api_reference_en.pdf
     // > 3.1.1 os_timer_arm
@@ -527,30 +552,129 @@ bool isActive(Mode pulse) {
 
 } // namespace
 } // namespace pulse
+
+namespace settings {
+namespace options {
+namespace {
+
+using ::settings::options::Enumeration;
+
+alignas(4) static constexpr char TristateNone[] PROGMEM = "none";
+alignas(4) static constexpr char TristateOff[] PROGMEM = "off";
+alignas(4) static constexpr char TristateOn[] PROGMEM = "on";
+
+template <typename T>
+struct RelayTristateHelper {
+    static constexpr std::array<Enumeration<T>, 3> Options PROGMEM {
+        {{T::None, TristateNone},
+         {T::Off, TristateOff},
+         {T::On, TristateOn}}
+    };
+
+    static T convert(const String& value) {
+        return ::settings::internal::convert(Options, value, T::None);
+    }
+
+    static String serialize(T value) {
+        return ::settings::internal::serialize(Options, value);
+    }
+};
+
+template <typename T>
+constexpr const std::array<Enumeration<T>, 3> RelayTristateHelper<T>::Options;
+
+alignas(4) static constexpr char PayloadStatusOff[] PROGMEM = "off";
+alignas(4) static constexpr char PayloadStatusOn[] PROGMEM = "on";
+alignas(4) static constexpr char PayloadStatusToggle[] PROGMEM = "toggle";
+alignas(4) static constexpr char PayloadStatusUnknown[] PROGMEM = "unknown";
+
+static constexpr std::array<Enumeration<PayloadStatus>, 4> PayloadStatusOptions PROGMEM {
+    {{PayloadStatus::Off, PayloadStatusOff},
+     {PayloadStatus::On, PayloadStatusOn},
+     {PayloadStatus::Toggle, PayloadStatusToggle},
+     {PayloadStatus::Unknown, PayloadStatusUnknown}}
+};
+
+alignas(4) static constexpr char Normal[] PROGMEM = "normal";
+alignas(4) static constexpr char Inverse[] PROGMEM = "inverse";
+
+static constexpr std::array<Enumeration<RelayMqttTopicMode>, 2> RelayMqttTopicModeOptions PROGMEM {
+    {{RelayMqttTopicMode::Normal, Normal},
+     {RelayMqttTopicMode::Inverse, Inverse}}
+};
+
+alignas(4) static constexpr char RelayBootOff[] PROGMEM = "off";
+alignas(4) static constexpr char RelayBootOn[] PROGMEM = "on";
+alignas(4) static constexpr char RelayBootSame[] PROGMEM = "same";
+alignas(4) static constexpr char RelayBootToggle[] PROGMEM = "toggle";
+alignas(4) static constexpr char RelayBootLockedOff[] PROGMEM = "locked-off";
+alignas(4) static constexpr char RelayBootLockedOn[] PROGMEM = "locked-on";
+
+static constexpr std::array<Enumeration<RelayBoot>, 6> RelayBootOptions PROGMEM {
+    {{RelayBoot::Off, RelayBootOff},
+     {RelayBoot::On, RelayBootOn},
+     {RelayBoot::Same, RelayBootSame},
+     {RelayBoot::Toggle, RelayBootToggle},
+     {RelayBoot::LockedOff, RelayBootLockedOff},
+     {RelayBoot::LockedOn, RelayBootLockedOn}}
+};
+
+alignas(4) static constexpr char RelayProviderNone[] PROGMEM = "none";
+alignas(4) static constexpr char RelayProviderDummy[] PROGMEM = "dummy";
+alignas(4) static constexpr char RelayProviderGpio[] PROGMEM = "gpio";
+alignas(4) static constexpr char RelayProviderDual[] PROGMEM = "dual";
+alignas(4) static constexpr char RelayProviderStm[] PROGMEM = "stm";
+
+static constexpr std::array<Enumeration<RelayProvider>, 5> RelayProviderOptions PROGMEM {
+    {{RelayProvider::None, RelayProviderNone},
+     {RelayProvider::Dummy, RelayProviderDummy},
+     {RelayProvider::Gpio, RelayProviderGpio},
+     {RelayProvider::Dual, RelayProviderDual},
+     {RelayProvider::Stm, RelayProviderStm}}
+};
+
+alignas(4) constexpr static char RelayTypeNormal[] PROGMEM = "normal";
+alignas(4) constexpr static char RelayTypeInverse[] PROGMEM = "inverse";
+alignas(4) constexpr static char RelayTypeLatched[] PROGMEM = "latched";
+alignas(4) constexpr static char RelayTypeLatchedInverse[] PROGMEM = "latched-inverse";
+
+static constexpr std::array<Enumeration<RelayType>, 4> RelayTypeOptions PROGMEM {
+    {{RelayType::Normal, RelayTypeNormal},
+     {RelayType::Inverse, RelayTypeInverse},
+     {RelayType::Latched, RelayTypeLatched},
+     {RelayType::LatchedInverse, RelayTypeLatchedInverse}}
+};
+
+} // namespace
+} // namespace options
+} // namespace settings
 } // namespace relay
 } // namespace espurna
 
-namespace {
-
 using RelayMask = std::bitset<RelaysMax>;
 
 struct RelayMaskHelper {
-    RelayMaskHelper() = default;
+    using IntegralType = uint32_t;
+    static_assert(RelaysMax <= (sizeof(IntegralType) * 8), "");
 
-    explicit RelayMaskHelper(uint32_t mask) :
+    RelayMaskHelper() = default;
+    RelayMaskHelper(const RelayMaskHelper&) = default;
+    RelayMaskHelper(RelayMaskHelper&&) = default;
+
+    explicit RelayMaskHelper(RelayMask mask) noexcept :
         _mask(mask)
     {}
 
-    explicit RelayMaskHelper(RelayMask&& mask) :
-        _mask(std::move(mask))
+    explicit RelayMaskHelper(IntegralType mask) noexcept :
+        _mask(mask)
     {}
 
-    uint32_t toUnsigned() const {
+    IntegralType toUnsigned() const {
         return _mask.to_ulong();
     }
 
     String toString() const {
-        return settings::internal::serialize(toUnsigned(), 2);
+        return formatUnsigned(toUnsigned(), 2);
     }
 
     const RelayMask& mask() const {
@@ -570,69 +694,38 @@ struct RelayMaskHelper {
     }
 
 private:
-    RelayMask _mask { 0ul };
+    RelayMask _mask {};
 };
 
-} // namespace
-
 namespace settings {
 namespace internal {
 namespace {
 
-alignas(4) static constexpr char TristateNone[] PROGMEM = "none";
-alignas(4) static constexpr char TristateOff[] PROGMEM = "off";
-alignas(4) static constexpr char TristateOn[] PROGMEM = "on";
-
-template <typename T>
-struct RelayTristateHelper {
-    constexpr static const std::array<EnumOption<T>, 3> Options PROGMEM {
-        {{T::None, TristateNone},
-         {T::Off, TristateOff},
-         {T::On, TristateOn}}
-    };
-
-    static T convert(const String& value) {
-        return ::settings::internal::convert(Options, value, T::None);
-    }
-
-    static String serialize(T value) {
-        return ::settings::internal::serialize(Options, value);
-    }
-};
-
-template <typename T>
-constexpr const std::array<EnumOption<T>, 3> RelayTristateHelper<T>::Options;
+using espurna::relay::settings::options::RelayTristateHelper;
+using espurna::relay::settings::options::PayloadStatusOptions;
+using espurna::relay::settings::options::RelayMqttTopicModeOptions;
+using espurna::relay::settings::options::RelayBootOptions;
+using espurna::relay::settings::options::RelayProviderOptions;
+using espurna::relay::settings::options::RelayTypeOptions;
 
 } // namespace
 
 template <>
 PayloadStatus convert(const String& value) {
-    alignas(4) static constexpr char Off[] PROGMEM = "off";
-    alignas(4) static constexpr char On[] PROGMEM = "on";
-    alignas(4) static constexpr char Toggle[] PROGMEM = "toggle";
-    alignas(4) static constexpr char Unknown[] PROGMEM = "unknown";
+    return convert(PayloadStatusOptions, value, PayloadStatus::Unknown);
+}
 
-    constexpr static const std::array<EnumOption<PayloadStatus>, 4> options PROGMEM {
-        {{PayloadStatus::Off, Off},
-         {PayloadStatus::On, On},
-         {PayloadStatus::Toggle, Toggle},
-         {PayloadStatus::Unknown, Unknown}}
-    };
-
-    return convert(options, value, PayloadStatus::Unknown);
+String serialize(PayloadStatus value) {
+    return serialize(PayloadStatusOptions, value);
 }
 
 template <>
 RelayMqttTopicMode convert(const String& value) {
-    alignas(4) static constexpr char Normal[] PROGMEM = "normal";
-    alignas(4) static constexpr char Inverse[] PROGMEM = "inverse";
+    return convert(RelayMqttTopicModeOptions, value, RelayMqttTopicMode::Normal);
+}
 
-    constexpr static const std::array<EnumOption<RelayMqttTopicMode>, 2> options PROGMEM {
-        {{RelayMqttTopicMode::Normal, Normal},
-         {RelayMqttTopicMode::Inverse, Inverse}}
-    };
-
-    return convert(options, value, RelayMqttTopicMode::Normal);
+String serialize(RelayMqttTopicMode value) {
+    return serialize(RelayMqttTopicModeOptions, value);
 }
 
 template <>
@@ -640,25 +733,17 @@ espurna::relay::pulse::Mode convert(const String& value) {
     return RelayTristateHelper<espurna::relay::pulse::Mode>::convert(value);
 }
 
+String serialize(espurna::relay::pulse::Mode value) {
+    return RelayTristateHelper<espurna::relay::pulse::Mode>::serialize(value);
+}
+
 template <>
 RelayBoot convert(const String& value) {
-    alignas(4) static constexpr char Off[] PROGMEM = "off";
-    alignas(4) static constexpr char On[] PROGMEM = "on";
-    alignas(4) static constexpr char Same[] PROGMEM = "same";
-    alignas(4) static constexpr char Toggle[] PROGMEM = "toggle";
-    alignas(4) static constexpr char LockedOff[] PROGMEM = "locked-off";
-    alignas(4) static constexpr char LockedOn[] PROGMEM = "locked-on";
+    return convert(RelayBootOptions, value, RelayBoot::Off);
+}
 
-    constexpr static const std::array<EnumOption<RelayBoot>, 6> options PROGMEM {
-        {{RelayBoot::Off, Off},
-         {RelayBoot::On, On},
-         {RelayBoot::Same, Same},
-         {RelayBoot::Toggle, Toggle},
-         {RelayBoot::LockedOff, LockedOff},
-         {RelayBoot::LockedOn, LockedOn}}
-    };
-
-    return convert(options, value, RelayBoot::Off);
+String serialize(RelayBoot value) {
+    return serialize(RelayBootOptions, value);
 }
 
 template <>
@@ -668,43 +753,25 @@ RelayLock convert(const String& value) {
 
 template <>
 RelayProvider convert(const String& value) {
-    alignas(4) static constexpr char None[] PROGMEM = "none";
-    alignas(4) static constexpr char Dummy[] PROGMEM = "dummy";
-    alignas(4) static constexpr char Gpio[] PROGMEM = "gpio";
-    alignas(4) static constexpr char Dual[] PROGMEM = "dual";
-    alignas(4) static constexpr char Stm[] PROGMEM = "stm";
+    return convert(RelayProviderOptions, value, RelayProvider::None);
+}
 
-    constexpr static const std::array<EnumOption<RelayProvider>, 5> options PROGMEM {
-        {{RelayProvider::None, None},
-         {RelayProvider::Dummy, Dummy},
-         {RelayProvider::Gpio, Gpio},
-         {RelayProvider::Dual, Dual},
-         {RelayProvider::Stm, Stm}}
-    };
-
-    return convert(options, value, RelayProvider::None);
+String serialize(RelayProvider value) {
+    return serialize(RelayProviderOptions, value);
 }
 
 template <>
 RelayType convert(const String& value) {
-    alignas(4) static constexpr char Normal[] PROGMEM = "normal";
-    alignas(4) static constexpr char Inverse[] PROGMEM = "inverse";
-    alignas(4) static constexpr char Latched[] PROGMEM = "latched";
-    alignas(4) static constexpr char LatchedInverse[] PROGMEM = "latched-inverse";
-
-    constexpr static const std::array<EnumOption<RelayType>, 4> options PROGMEM {
-        {{RelayType::Normal, Normal},
-         {RelayType::Inverse, Inverse},
-         {RelayType::Latched, Latched},
-         {RelayType::LatchedInverse, LatchedInverse}}
-    };
-
-    return convert(options, value, RelayType::Normal);
+    return convert(RelayTypeOptions, value, RelayType::Normal);
 }
 
-template <>
+String serialize(RelayType value) {
+    return serialize(RelayTypeOptions, value);
+}
+
+template<>
 RelayMaskHelper convert(const String& value) {
-    return RelayMaskHelper(convert<unsigned long>(value));
+    return RelayMaskHelper { convert<RelayMaskHelper::IntegralType>(value) };
 }
 
 String serialize(RelayMaskHelper mask) {
@@ -716,106 +783,214 @@ String serialize(RelayMaskHelper mask) {
 
 namespace espurna {
 namespace relay {
-namespace {
 namespace settings {
+namespace keys {
+namespace {
+
+alignas(4) static constexpr char Name[] PROGMEM = "relayName";
+alignas(4) static constexpr char Provider[] PROGMEM = "relayProv";
+alignas(4) static constexpr char Type[] PROGMEM = "relayType";
+alignas(4) static constexpr char GpioType[] PROGMEM = "relayGpioType";
+alignas(4) static constexpr char Gpio[] PROGMEM = "relayGpio";
+alignas(4) static constexpr char ResetGpio[] PROGMEM = "relayResetGpio";
+alignas(4) static constexpr char Boot[] PROGMEM = "relayBoot";
+alignas(4) static constexpr char DelayOn[] PROGMEM = "relayDelayOn";
+alignas(4) static constexpr char DelayOff[] PROGMEM = "relayDelayOff";
+
+#if MQTT_SUPPORT
+alignas(4) static constexpr char TopicPub[] PROGMEM = "relayTopicPub";
+alignas(4) static constexpr char TopicSub[] PROGMEM = "relayTopicSub";
+alignas(4) static constexpr char TopicMode[] PROGMEM = "relayTopicMode";
+alignas(4) static constexpr char MqttDisconnection[] PROGMEM = "relayMqttDisc";
+#endif
+
+alignas(4) static constexpr char Dummy[] PROGMEM = "relayDummy";
+alignas(4) static constexpr char BootMask[] PROGMEM = "relayBootMask";
+alignas(4) static constexpr char Interlock[] PROGMEM = "relayIlkDelay";
+alignas(4) static constexpr char Sync[] PROGMEM = "relaySync";
+
+alignas(4) static constexpr char PayloadOn[] PROGMEM = "relayPayloadOn";
+alignas(4) static constexpr char PayloadOff[] PROGMEM = "relayPayloadOff";
+alignas(4) static constexpr char PayloadToggle[] PROGMEM = "relayPayloadOff";
+
+} // namespace
+} // namespace keys
+
+namespace {
 
 size_t dummyCount() {
-    return getSetting("relayDummy", build::dummyCount());
+    return getSetting(keys::Dummy, build::dummyCount());
 }
 
 [[gnu::unused]]
 String name(size_t index) {
-    return getSetting({"relayName", index});
+    return getSetting({keys::Name, index});
 }
 
 RelayProvider provider(size_t index) {
-    return getSetting({"relayProv", index}, build::provider(index));
+    return getSetting({keys::Provider, index}, build::provider(index));
 }
 
 RelayType type(size_t index) {
-    return getSetting({"relayType", index}, build::type(index));
+    return getSetting({keys::Type, index}, build::type(index));
 }
 
 GpioType pinType(size_t index) {
-    return getSetting({"relayGpioType", index}, build::pinType(index));
+    return getSetting({keys::GpioType, index}, build::pinType(index));
 }
 
 unsigned char pin(size_t index) {
-    return getSetting({"relayGpio", index}, build::pin(index));
+    return getSetting({keys::Gpio, index}, build::pin(index));
 }
 
 unsigned char resetPin(size_t index) {
-    return getSetting({"relayResetGpio", index}, build::resetPin(index));
+    return getSetting({keys::ResetGpio, index}, build::resetPin(index));
 }
 
 RelayBoot bootMode(size_t index) {
-    return getSetting({"relayBoot", index}, build::bootMode(index));
+    return getSetting({keys::Boot, index}, build::bootMode(index));
 }
 
 RelayMaskHelper bootMask() {
-    const static RelayMaskHelper defaultMask;
-    return getSetting("relayBootMask", defaultMask);
+    static const RelayMaskHelper defaultMask;
+    return getSetting(keys::BootMask, defaultMask);
 }
 
 void bootMask(const String& mask) {
-    setSetting("relayBootMask", mask);
+    setSetting(keys::BootMask, mask);
 }
 
 void bootMask(const RelayMaskHelper& mask) {
-    bootMask(::settings::internal::serialize(mask));
+    bootMask(mask.toString());
 }
 
 espurna::duration::Milliseconds delayOn(size_t index) {
-    return getSetting({"relayDelayOn", index}, build::delayOn(index));
+    return getSetting({keys::DelayOn, index}, build::delayOn(index));
 }
 
 espurna::duration::Milliseconds delayOff(size_t index) {
-    return getSetting({"relayDelayOff", index}, build::delayOff(index));
+    return getSetting({keys::DelayOff, index}, build::delayOff(index));
 }
 
 espurna::duration::Milliseconds interlockDelay() {
-    return getSetting("relayIlkDelay", build::interlockDelay());
+    return getSetting(keys::Interlock, build::interlockDelay());
 }
 
 int syncMode() {
-    return getSetting("relaySync", build::syncMode());
+    return getSetting(keys::Sync, build::syncMode());
 }
 
 [[gnu::unused]]
 String payloadOn() {
-    return getSetting("relayPayloadOn", build::payloadOn());
+    return getSetting(keys::PayloadOn, build::payloadOn());
 }
 
 [[gnu::unused]]
 String payloadOff() {
-    return getSetting("relayPayloadOff", build::payloadOff());
+    return getSetting(keys::PayloadOff, build::payloadOff());
 }
 
 [[gnu::unused]]
 String payloadToggle() {
-    return getSetting("relayPayloadToggle", build::payloadToggle());
+    return getSetting(keys::PayloadToggle, build::payloadToggle());
 }
 
 #if MQTT_SUPPORT
 String mqttTopicSub(size_t index) {
-    return getSetting({"relayTopicSub", index}, build::mqttTopicSub(index));
+    return getSetting({keys::TopicSub, index}, build::mqttTopicSub(index));
 }
 
 String mqttTopicPub(size_t index) {
-    return getSetting({"relayTopicPub", index}, build::mqttTopicPub(index));
+    return getSetting({keys::TopicPub, index}, build::mqttTopicPub(index));
 }
 
 RelayMqttTopicMode mqttTopicMode(size_t index) {
-    return getSetting({"relayTopicMode", index}, build::mqttTopicMode(index));
+    return getSetting({keys::TopicMode, index}, build::mqttTopicMode(index));
 }
 
 PayloadStatus mqttDisconnectionStatus(size_t index) {
-    return getSetting({"relayMqttDisc", index}, build::mqttDisconnectionStatus(index));
+    return getSetting({keys::MqttDisconnection, index}, build::mqttDisconnectionStatus(index));
 }
 #endif
 
-} // namespace settings
 } // namespace
+
+namespace query {
+namespace {
+
+#define EXACT_VALUE(NAME, FUNC)\
+String NAME () {\
+    return ::settings::internal::serialize(FUNC());\
+}
+
+#define ID_VALUE(NAME, FUNC)\
+String NAME (size_t id) {\
+    return ::settings::internal::serialize(FUNC(id));\
+}
+
+namespace internal {
+
+EXACT_VALUE(dummyCount, settings::dummyCount)
+EXACT_VALUE(bootMask, settings::bootMask)
+EXACT_VALUE(interlockDelay, settings::interlockDelay)
+EXACT_VALUE(syncMode, settings::syncMode)
+
+ID_VALUE(provider, settings::provider)
+ID_VALUE(type, settings::type)
+ID_VALUE(pinType, settings::pinType)
+ID_VALUE(pin, settings::pin)
+ID_VALUE(resetPin, settings::resetPin)
+ID_VALUE(bootMode, settings::bootMode)
+ID_VALUE(delayOn, settings::delayOn)
+ID_VALUE(delayOff, settings::delayOff)
+
+ID_VALUE(pulseMode, pulse::settings::mode)
+String pulseTime(size_t index) {
+    const auto result = pulse::settings::time(index);
+    const auto as_seconds = std::chrono::duration_cast<pulse::Seconds>(result.duration());
+    return ::settings::internal::serialize(as_seconds.count());
+}
+
+#if MQTT_SUPPORT
+ID_VALUE(mqttDisconnectionStatus, settings::mqttDisconnectionStatus)
+ID_VALUE(mqttTopicMode, settings::mqttTopicMode)
+#endif
+
+#undef ID_VALUE
+#undef EXACT_VALUE
+
+} // namespace internal
+
+static constexpr ::settings::query::Setting Settings[] PROGMEM {
+    {keys::Dummy, internal::dummyCount},
+    {keys::BootMask, internal::bootMask},
+    {keys::Interlock, internal::interlockDelay},
+    {keys::Sync, internal::syncMode}
+};
+
+static constexpr ::settings::query::IndexedSetting IndexedSettings[] PROGMEM {
+    {keys::Name, settings::name},
+    {keys::Provider, internal::provider},
+    {keys::Type, internal::type},
+    {keys::GpioType, internal::pinType},
+    {keys::Gpio, internal::pin},
+    {keys::ResetGpio, internal::resetPin},
+    {keys::Boot, internal::bootMode},
+    {keys::DelayOn, internal::delayOn},
+    {keys::DelayOff, internal::delayOff},
+    {pulse::settings::keys::Time, internal::pulseTime},
+    {pulse::settings::keys::Mode, internal::pulseMode},
+#if MQTT_SUPPORT
+    {keys::TopicPub, settings::mqttTopicPub},
+    {keys::TopicSub, settings::mqttTopicSub},
+    {keys::TopicMode, internal::mqttTopicMode},
+    {keys::MqttDisconnection, internal::mqttDisconnectionStatus},
+#endif
+};
+
+} // namespace
+} // namespace query
+} // namespace settings
 } // namespace relay
 } // namespace espurna
 
@@ -1821,8 +1996,9 @@ namespace {
 
 void _relaySettingsMigrate(int version) {
     if (version < 5) {
+        using namespace espurna::relay::settings;
         // just a rename
-        moveSetting("relayDelayInterlock", "relayIlkDelay");
+        moveSetting("relayDelayInterlock", keys::Interlock);
 
         // groups use a new set of keys
         for (size_t index = 0; index < RelaysMax; ++index) {
@@ -1834,23 +2010,23 @@ void _relaySettingsMigrate(int version) {
             auto syncKey = SettingsKey("mqttGroupSync", index);
             auto sync = getSetting(syncKey);
 
-            setSetting({"relayTopicSub", index}, group);
+            setSetting({keys::TopicSub, index}, group);
             if (sync.length()) {
                 if (sync != "2") { // aka RECEIVE_ONLY
-                    setSetting("relayTopicMode", sync);
-                    setSetting("relayTopicPub", group);
+                    setSetting(keys::TopicMode, sync);
+                    setSetting(keys::TopicPub, group);
                 }
             }
         }
 
         delSettingPrefix({
-            "mqttGroup",     // migrated to relayTopic
-            "mqttGroupSync", // migrated to relayTopic
-            "relayOnDisc",   // replaced with relayMqttDisc
-            "relayGPIO",     // avoid depending on migrate.ino
-            "relayGpio",     //
-            "relayProvider", // different type
-            "relayType",     // different type
+            STRING_VIEW("mqttGroup"),     // migrated to relayTopic
+            STRING_VIEW("mqttGroupSync"), // migrated to relayTopic
+            STRING_VIEW("relayOnDisc"),   // replaced with relayMqttDisc
+            STRING_VIEW("relayGPIO"),     // avoid depending on migrate module
+            STRING_VIEW("relayGpio"),     // avoid depending on migrate module
+            STRING_VIEW("relayProvider"), // different type
+            STRING_VIEW("relayType"),     // different type
         });
         delSetting("relays"); // does not do anything
     }
@@ -1961,13 +2137,12 @@ bool _relayWebSocketOnKeyCheck(const char * key, JsonVariant&) {
 }
 
 void _relayWebSocketUpdate(JsonObject& root) {
-    ::web::ws::EnumerableConfig config{root, F("relayState")};
-
-    config(F("states"), _relays.size(), {
-        {F("status"), [](JsonArray& out, size_t index) {
+    ::web::ws::EnumerablePayload payload{root, STRING_VIEW("relayState")};
+    payload(STRING_VIEW("states"), _relays.size(), {
+        {STRING_VIEW("status"), [](JsonArray& out, size_t index) {
             out.add(_relays[index].target_status ? 1 : 0);
         }},
-        {F("lock"), [](JsonArray& out, size_t index) {
+        {STRING_VIEW("lock"), [](JsonArray& out, size_t index) {
             out.add(static_cast<uint8_t>(_relays[index].lock));
         }},
     });
@@ -1978,47 +2153,14 @@ void _relayWebSocketSendRelays(JsonObject& root) {
         return;
     }
 
-    ::web::ws::EnumerableConfig config{root, F("relayConfig")};
+    ::web::ws::EnumerableConfig config{root, STRING_VIEW("relayConfig")};
 
     auto& container = config.root();
     container["size"] = _relays.size();
     container["start"] = 0;
 
-    config(F("relays"), _relays.size(), {
-        {F("relayDesc"), [](JsonArray& out, size_t index) {
-            out.add(_relays[index].provider->id());
-        }},
-        {F("relayProv"), [](JsonArray& out, size_t index) {
-            out.add(static_cast<uint8_t>(espurna::relay::settings::provider(index)));
-        }},
-        {F("relayName"), [](JsonArray& out, size_t index) {
-            out.add(espurna::relay::settings::name(index));
-        }},
-        {F("relayBoot"), [](JsonArray& out, size_t index) {
-            out.add(static_cast<int>(espurna::relay::settings::bootMode(index)));
-        }},
-#if MQTT_SUPPORT
-        {F("relayTopicPub"), [](JsonArray& out, size_t index) {
-            out.add(espurna::relay::settings::mqttTopicSub(index));
-        }},
-        {F("relayTopicSub"), [](JsonArray& out, size_t index) {
-            out.add(espurna::relay::settings::mqttTopicPub(index));
-        }},
-        {F("relayTopicMode"), [](JsonArray& out, size_t index) {
-            out.add(static_cast<uint8_t>(espurna::relay::settings::mqttTopicMode(index)));
-        }},
-        {F("relayMqttDisc"), [](JsonArray& out, size_t index) {
-            out.add(static_cast<uint8_t>(espurna::relay::settings::mqttDisconnectionStatus(index)));
-        }},
-#endif
-        {F("relayPulse"), [](JsonArray& out, size_t index) {
-            out.add(static_cast<uint8_t>(_relays[index].pulse));
-        }},
-        {F("relayTime"), [](JsonArray& out, size_t index) {
-            out.add(std::chrono::duration_cast<espurna::relay::pulse::Seconds>(
-                _relays[index].pulse_time).count());
-        }},
-    });
+    config(STRING_VIEW("relays"), _relays.size(),
+        espurna::relay::settings::query::IndexedSettings);
 }
 
 void _relayWebSocketOnVisible(JsonObject& root) {
@@ -2304,11 +2446,10 @@ void _relayMqttSubscribeCustomTopics() {
     }
 
     settings::internal::foreach([&](settings::kvs_type::KeyValueResult&& kv) {
-        const char* const SubPrefix = "relayTopicSub";
-        const char* const ModePrefix = "relayTopicMode";
-
-        if ((kv.key.length <= strlen(SubPrefix))
-                && (kv.key.length <= strlen(ModePrefix))) {
+        static constexpr settings::StringView SubPrefix { espurna::relay::settings::keys::TopicSub };
+        static constexpr settings::StringView ModePrefix { espurna::relay::settings::keys::TopicMode };
+        if ((kv.key.length <= SubPrefix.length())
+                && (kv.key.length <= ModePrefix.length())) {
             return;
         }
 
@@ -2319,12 +2460,12 @@ void _relayMqttSubscribeCustomTopics() {
         const auto key = kv.key.read();
         size_t id;
 
-        if (key.startsWith(SubPrefix)) {
-            if (_relayTryParseId(key.c_str() + strlen(SubPrefix), id)) {
+        if (SubPrefix.compareFlash(key)) {
+            if (_relayTryParseId(key.c_str() + SubPrefix.length(), id)) {
                 topics[id] = kv.value.read();
             }
-        } else if (key.startsWith(ModePrefix)) {
-            if (_relayTryParseId(key.c_str() + strlen(ModePrefix), id)) {
+        } else if (ModePrefix.compareFlash(key)) {
+            if (_relayTryParseId(key.c_str() + ModePrefix.length(), id)) {
                 topics[id] = settings::internal::convert<RelayMqttTopicMode>(kv.value.read());
             }
         }
@@ -2515,51 +2656,18 @@ String _relayTristateToPayload(T value) {
     return ::settings::internal::RelayTristateHelper<T>::serialize(value);
 }
 
-template <size_t Size>
-void _relayPrintExtra(const Relay& relay, char (&buffer)[Size]) {
-    int index = 0;
-    char* out { &buffer[0] };
-    if (index >= 0 && relay.delay_on.count()) {
-        index += snprintf_P(out + index, Size,
-                PSTR(" DelayOn=%u(ms)"), relay.delay_on.count());
-    }
-    if (index >= 0 && relay.delay_off.count()) {
-        index += snprintf_P(out + index, Size,
-                PSTR(" DelayOff=%u(ms)"), relay.delay_off.count());
-    }
-    if (index >= 0 && relay.lock != RelayLock::None) {
-        index += snprintf_P(out + index, Size,
-                PSTR(" Lock=%s"), _relayTristateToPayload(relay.lock).c_str());
-    }
-}
-
-void _relayPrint(Print& out, size_t start, size_t stop, bool extra) {
-    for (size_t index = start; index < stop; ++index) {
-        auto& relay = _relays[index];
-
-        char pulse_info[64] = "";
-        if ((relay.pulse != espurna::relay::pulse::Mode::None) && (relay.pulse_time.count() > 0)) {
-            snprintf_P(pulse_info, sizeof(pulse_info), PSTR(" Pulse=%s Time=%u(ms)"),
-                _relayTristateToPayload(relay.pulse).c_str(), relay.pulse_time);
-        }
-
-        char extended_info[64] = "";
-        if (extra) {
-            _relayPrintExtra(relay, extended_info);
-        }
-
-        out.printf_P(PSTR("relay%u {Prov=%s Current=%s Target=%s%s%s}\n"),
-            index, relay.provider->id(),
-            relay.current_status ? "ON" : "OFF",
-            relay.target_status ? "ON" : "OFF",
-            pulse_info,
-            extended_info
-        );
-    }
+void _relayPrint(Print& out, const Relay& relay, size_t index) {
+    out.printf_P(PSTR("relay%u {Prov=%s TargetStatus=%s CurrentStatus=%s Lock=%s}\n"),
+        index, relay.provider->id(),
+        relay.target_status ? "on" : "off",
+        relay.current_status ? "on" : "off",
+        _relayTristateToPayload(relay.lock).c_str());
 }
 
 void _relayPrint(Print& out, size_t start, size_t stop) {
-    _relayPrint(out, start, stop, true);
+    for (size_t index = start; index < stop; ++index) {
+        _relayPrint(out, _relays[index], index);
+    }
 }
 
 void _relayInitCommands() {
@@ -2584,9 +2692,12 @@ void _relayInitCommands() {
             }
 
             _relayHandleStatus(id, status);
+            _relayPrint(ctx.output, _relays[id], id);
+            terminalOK(ctx);
+            return;
         }
 
-        _relayPrint(ctx.output, id, id + 1, false);
+        settingsDump(ctx, espurna::relay::settings::query::IndexedSettings, id);
         terminalOK(ctx);
     });
 
@@ -2838,10 +2949,58 @@ void _relaySetup() {
 
 } // namespace
 
+namespace espurna {
+namespace relay {
+namespace settings {
+namespace query {
+namespace {
+
+bool checkSamePrefix(::settings::StringView key) {
+    alignas(4) static constexpr char Prefix[] PROGMEM = "relay";
+    return ::settings::query::samePrefix(key, Prefix);
+}
+
+String findIndexedValueFrom(::settings::StringView key) {
+    return ::settings::query::IndexedSetting::findValueFrom(_relays.size(), IndexedSettings, key);
+}
+
+bool checkExact(::settings::StringView key) {
+    for (const auto& setting : Settings) {
+        if (setting.key().compareFlash(key)) {
+            return true;
+        }
+    }
+
+    return false;
+}
+
+String findValueFrom(::settings::StringView key) {
+    return ::settings::query::Setting::findValueFrom(Settings, key);
+}
+
+void setup() {
+    ::settingsRegisterQueryHandler({
+        .check = checkSamePrefix,
+        .get = findIndexedValueFrom
+    });
+
+    ::settingsRegisterQueryHandler({
+        .check = checkExact,
+        .get = findValueFrom
+    });
+}
+
+} // namespace
+} // namespace query
+} // namespace settings
+} // namespace relay
+} // namespace espurna
+
 void relaySetup() {
     migrateVersion(_relaySettingsMigrate);
 
     _relaySetup();
+    espurna::relay::settings::query::setup();
 
     _relayConfigure();
     _relayBootAll();
diff --git a/code/espurna/rpnrules.cpp b/code/espurna/rpnrules.cpp
index 49b2f1a3..0b416895 100644
--- a/code/espurna/rpnrules.cpp
+++ b/code/espurna/rpnrules.cpp
@@ -108,27 +108,53 @@ constexpr unsigned long delay() {
 } // namespace build
 
 namespace settings {
+namespace keys {
+
+alignas(4) static constexpr char Sticky[] PROGMEM = "rpnSticky";
+alignas(4) static constexpr char Delay[] PROGMEM = "rpnDelay";
+alignas(4) static constexpr char Rule[] PROGMEM = "rpnRule";
+
+alignas(4) static constexpr char Topic[] PROGMEM = "rpnTopic";
+alignas(4) static constexpr char Name[] PROGMEM = "rpnName";
+
+} // namespace keys
 
 bool sticky() {
-    return getSetting("rpnSticky", build::sticky());
+    return getSetting(keys::Sticky, build::sticky());
 }
 
 unsigned long delay() {
-    return getSetting("rpnDelay", build::delay());
+    return getSetting(keys::Delay, build::delay());
 }
 
 String rule(size_t index) {
-    return getSetting({"rpnRule", index});
+    return getSetting({keys::Rule, index});
 }
 
 String topic(size_t index) {
-    return getSetting({"rpnTopic", index});
+    return getSetting({keys::Topic, index});
 }
 
 String name(size_t index) {
-    return getSetting({"rpnName", index});
+    return getSetting({keys::Name, index});
 }
 
+#if MQTT_SUPPORT
+size_t countMqttNames() {
+    size_t index { 0 };
+    for (;;) {
+        auto name = SettingsKey{ keys::Name, index };
+        if (!::settings::internal::has(name.value())) {
+            break;
+        }
+
+        ++index;
+    }
+
+    return index;
+}
+#endif
+
 } // namespace settings
 
 namespace internal {
@@ -181,7 +207,7 @@ struct RunnersHandler {
     RunnersHandler& operator=(const RunnersHandler&) = delete;
 
     RunnersHandler(RunnersHandler&&) = default;
-    RunnersHandler& operator=(RunnersHandler&&) = default;
+    RunnersHandler& operator=(RunnersHandler&&) = delete;
 
     explicit RunnersHandler(internal::Runners& runners) :
         _runners(runners)
@@ -211,7 +237,6 @@ private:
 // -----------------------------------------------------------------------------
 
 #if TERMINAL_SUPPORT
-
 namespace terminal {
 
 String valueToString(const rpn_value& value) {
@@ -324,11 +349,9 @@ void setup() {
 }
 
 } // namespace terminal
-
 #endif // TERMINAL_SUPPORT
 
 #if WEB_SUPPORT
-
 namespace web {
 
 void onVisible(JsonObject& root) {
@@ -340,10 +363,10 @@ bool onKeyCheck(const char * key, JsonVariant& value) {
 }
 
 void onConnected(JsonObject& root) {
-    root["rpnSticky"] = rpnrules::settings::sticky();
-    root["rpnDelay"] = rpnrules::settings::delay();
+    root[FPSTR(settings::keys::Sticky)] = rpnrules::settings::sticky();
+    root[FPSTR(settings::keys::Delay)] = rpnrules::settings::delay();
 
-    JsonArray& rules = root.createNestedArray("rpnRules");
+    JsonArray& rules = root.createNestedArray(F("rpnRules"));
 
     size_t index { 0 };
     String rule;
@@ -357,44 +380,20 @@ void onConnected(JsonObject& root) {
     }
 
 #if MQTT_SUPPORT
-    {
-        JsonObject& topicsConfig = root.createNestedObject("rpnTopics");
+    static constexpr std::array<::settings::query::IndexedSetting, 2> Settings {
+        {{settings::keys::Name, settings::name},
+         {settings::keys::Topic, settings::topic}}
+    };
 
-        static const char* const keys[] PROGMEM {
-            "rpnName", "rpnTopic"
-        };
-
-        JsonArray& schema = topicsConfig.createNestedArray("schema");
-        schema.copyFrom(keys, sizeof(keys) / sizeof(*keys));
-
-        JsonArray& topics = topicsConfig.createNestedArray("topics");
-
-        size_t index { 0 };
-        String name;
-        String topic;
-        for (;;) {
-            name = rpnrules::settings::name(index);
-            topic = rpnrules::settings::topic(index);
-            ++index;
-
-            if (!name.length() || !topic.length()) {
-                break;
-            }
-
-            JsonArray& entry = topics.createNestedArray();
-            entry.add(name);
-            entry.add(topic);
-        }
-    }
+    ::web::ws::EnumerableConfig config{ root, STRING_VIEW("rpnTopics") };
+    config(STRING_VIEW("topics"), settings::countMqttNames(), Settings);
 #endif
 }
 
 } // namespace web
-
 #endif // WEB_SUPPORT
 
 #if MQTT_SUPPORT
-
 namespace mqtt {
 
 struct Variable {
@@ -473,7 +472,6 @@ void init(rpn_context& context) {
 }
 
 } // namespace mqtt
-
 #endif // MQTT_SUPPORT
 
 namespace operators {
@@ -757,7 +755,6 @@ void init(rpn_context& context) {
 #endif // LIGHT_PROVIDER
 
 #if RFB_SUPPORT
-
 namespace rfbridge {
 
 struct Code {
@@ -772,6 +769,37 @@ struct Match {
     String raw;
 };
 
+namespace build {
+
+constexpr uint32_t RepeatWindow { 2000ul };
+constexpr uint32_t MatchWindow { 2000ul };
+constexpr uint32_t StaleDelay { 10000ul };
+
+} // namespace build
+
+namespace settings {
+namespace keys {
+
+alignas(4) static constexpr char RepeatWindow[] PROGMEM = "rfbRepeatWindow";
+alignas(4) static constexpr char MatchWindow[] PROGMEM = "rfbWatchWindow";
+alignas(4) static constexpr char StaleDelay[] PROGMEM = "rfbStaleDelay";
+
+} // namespace keys
+
+uint32_t repeatWindow() {
+    return getSetting(keys::RepeatWindow, build::RepeatWindow);
+}
+
+uint32_t matchWindow() {
+    return getSetting(keys::MatchWindow, build::MatchWindow);
+}
+
+uint32_t staleDelay() {
+    return getSetting(keys::StaleDelay, build::StaleDelay);
+}
+
+} // namespace settings
+
 namespace internal {
 
 // TODO: in theory, we could do with forward_list. however, this would require a more complicated removal process,
@@ -779,21 +807,16 @@ namespace internal {
 using Codes = std::list<Code>;
 Codes codes;
 
-constexpr uint32_t RepeatWindow { 2000ul };
-uint32_t repeat_window { RepeatWindow };
-
-constexpr uint32_t MatchWindow { 2000ul };
-uint32_t match_window ;
-
-constexpr uint32_t StaleDelay { 10000ul };
-uint32_t stale_delay { StaleDelay };
-
 Codes::iterator find(Codes& container, unsigned char protocol, const String& match) {
     return std::find_if(container.begin(), container.end(), [protocol, &match](const Code& code) {
         return (code.protocol == protocol) && (code.raw == match);
     });
 }
 
+uint32_t repeat_window { build::RepeatWindow };
+uint32_t match_window { build::MatchWindow };
+uint32_t stale_delay { build::StaleDelay };
+
 } // namespace internal
 
 rpn_error sequence(rpn_context& ctxt) {
@@ -958,9 +981,9 @@ void init(rpn_context& context) {
     //   Code counter is reset to 0 when outside of the window.
     // - Stale delay allows the handler to remove really old codes.
     //   (TODO: can this happen in loop() cb instead?)
-    internal::repeat_window = getSetting("rfbRepeatWindow", internal::RepeatWindow);
-    internal::match_window = getSetting("rfbMatchWindow", internal::MatchWindow);
-    internal::stale_delay = getSetting("rfbStaleDelay", internal::StaleDelay);
+    internal::repeat_window = settings::repeatWindow();
+    internal::match_window = settings::matchWindow();
+    internal::stale_delay = settings::staleDelay();
 
 #if TERMINAL_SUPPORT
     terminalRegisterCommand(F("RFB.CODES"), [](::terminal::CommandContext&& ctx) {
@@ -989,11 +1012,9 @@ void init(rpn_context& context) {
 }
 
 } // namespace rfbridge
-
 #endif // RFB_SUPPORT
 
 #if SENSOR_SUPPORT
-
 namespace sensor {
 
 void updateVariables(const String& topic, unsigned char index, double reading, const char*) {
@@ -1013,11 +1034,9 @@ void init(rpn_context&) {
 }
 
 } // namespace sensor
-
 #endif // SENSOR_SUPPORT
 
 #if TERMINAL_SUPPORT
-
 namespace terminal {
 
 void init(rpn_context& context) {
@@ -1028,11 +1047,9 @@ void init(rpn_context& context) {
 }
 
 } // namespace terminal
-
 #endif
 
 #if DEBUG_SUPPORT
-
 namespace debug {
 
 void init(rpn_context& context) {
@@ -1046,7 +1063,6 @@ void init(rpn_context& context) {
 }
 
 } // namespace debug
-
 #endif
 
 namespace system {
diff --git a/code/espurna/scheduler.cpp b/code/espurna/scheduler.cpp
index 910aa3b8..99c2df5c 100644
--- a/code/espurna/scheduler.cpp
+++ b/code/espurna/scheduler.cpp
@@ -190,85 +190,130 @@ void show(const Schedules& schedules) {
 } // namespace debug
 
 namespace settings {
+namespace keys {
 namespace {
 
-constexpr std::array<const char* const, 9> keys PROGMEM {
-    "schEnabled",
-    "schTarget",
-    "schType",
-    "schAction",
-    "schRestore",
-    "schUTC",
-    "schWDs",
-    "schHour",
-    "schMinute"
-};
-
-static_assert(keys[0] != nullptr, "");
-static_assert(keys[1] != nullptr, "");
-static_assert(keys[2] != nullptr, "");
-static_assert(keys[3] != nullptr, "");
-static_assert(keys[4] != nullptr, "");
-static_assert(keys[5] != nullptr, "");
-static_assert(keys[6] != nullptr, "");
-static_assert(keys[7] != nullptr, "");
-static_assert(keys[8] != nullptr, "");
+alignas(4) static constexpr char Enabled[] PROGMEM = "schEnabled";
+alignas(4) static constexpr char Target[] PROGMEM = "schTarget";
+alignas(4) static constexpr char Type[] PROGMEM = "schType";
+alignas(4) static constexpr char Action[] PROGMEM = "schAction";
+alignas(4) static constexpr char Restore[] PROGMEM = "schRestore";
+alignas(4) static constexpr char UseUTC[] PROGMEM = "schUTC";
+alignas(4) static constexpr char Weekdays[] PROGMEM = "schWDs";
+alignas(4) static constexpr char Hour[] PROGMEM = "schHour";
+alignas(4) static constexpr char Minute[] PROGMEM = "schMinute";
 
 } // namespace
+} // namespace keys
 
 bool enabled(size_t index) {
-    return getSetting({"schEnabled", index}, false);
+    return getSetting({keys::Enabled, index}, false);
 }
 
 size_t target(size_t index) {
-    return getSetting({"schTarget", index}, build::defaultTarget());
+    return getSetting({keys::Target, index}, build::defaultTarget());
 }
 
 int type(size_t index) {
-    return getSetting({"schType", index}, build::defaultType());
+    return getSetting({keys::Type, index}, build::defaultType());
 }
 
 int action(size_t index) {
-    return getSetting({"schAction", index}, build::action());
+    return getSetting({keys::Action, index}, build::action());
 }
 
 bool restore(size_t index) {
-    return getSetting({"schRestore", index}, build::restoreLast());
+    return getSetting({keys::Restore, index}, build::restoreLast());
 }
 
 Weekdays weekdays(size_t index) {
-    return Weekdays(getSetting({"schWDs", index}, build::weekdays()));
+    return Weekdays(getSetting({keys::Weekdays, index}, build::weekdays()));
 }
 
 bool utc(size_t index) {
-    return getSetting({"schUTC", index}, build::utc());
+    return getSetting({keys::UseUTC, index}, build::utc());
 }
 
 int hour(size_t index) {
-    return getSetting({"schHour", index}, build::hour());
+    return getSetting({keys::Hour, index}, build::hour());
 }
 
 int minute(size_t index) {
-    return getSetting({"schMinute", index}, build::minute());
+    return getSetting({keys::Minute, index}, build::minute());
+}
+
+namespace internal {
+
+#define ID_VALUE(NAME, FUNC)\
+String NAME (size_t id) {\
+    return ::settings::internal::serialize(FUNC(id));\
+}
+
+ID_VALUE(enabled, settings::enabled)
+ID_VALUE(target, settings::target)
+ID_VALUE(type, settings::type)
+ID_VALUE(action, settings::action)
+ID_VALUE(restore, settings::restore)
+ID_VALUE(utc, settings::utc)
+
+String weekdays(size_t index) {
+    return settings::weekdays(index).toString();
+}
+
+ID_VALUE(hour, settings::hour)
+ID_VALUE(minute, settings::minute)
+
+} // namespace internal
+
+static constexpr ::settings::query::IndexedSetting IndexedSettings[] PROGMEM {
+    {keys::Enabled, internal::enabled},
+    {keys::Target, internal::target},
+    {keys::Type, internal::type},
+    {keys::Action, internal::action},
+    {keys::Restore, internal::restore},
+    {keys::UseUTC, internal::utc},
+    {keys::Weekdays, internal::weekdays},
+    {keys::Hour, internal::hour},
+    {keys::Minute, internal::minute}
+};
+
+Schedule schedule(size_t index, int type) {
+    return {
+        .enabled = enabled(index),
+        .target = target(index),
+        .type = type,
+        .action = action(index),
+        .restore = restore(index),
+        .utc = utc(index),
+        .weekdays = weekdays(index),
+        .hour = hour(index),
+        .minute = minute(index)
+    };
 }
 
 Schedule schedule(size_t index) {
-    return Schedule{
-        enabled(index),
-        target(index),
-        type(index),
-        action(index),
-        restore(index),
-        utc(index),
-        weekdays(index),
-        hour(index),
-        minute(index)};
+    return schedule(index, type(index));
+}
+
+size_t count() {
+    size_t out { 0 };
+
+    for (size_t index = 0; index < build::max(); ++index) {
+        auto type = settings::type(index);
+        if (type == SCHEDULER_TYPE_NONE) {
+            break;
+        }
+
+        ++out;
+    }
+
+    return out;
 }
 
 void gc(size_t total) {
-    for (size_t i = total; i < build::max(); ++i) {
-        for (auto* key : keys) {
-            delSetting({key, i});
+    for (size_t index = total; index < build::max(); ++index) {
+        for (auto setting : IndexedSettings) {
+            delSetting({setting.prefix().c_str(), index});
         }
     }
 }
@@ -277,12 +322,13 @@ Schedules schedules() {
     Schedules out;
     out.reserve(build::max());
 
-    for (size_t i = 0; i < build::max(); ++i) {
-        auto current = schedule(i);
-        if (current.type == SCHEDULER_TYPE_NONE) {
+    for (size_t index = 0; index < build::max(); ++index) {
+        auto type = settings::type(index);
+        if (type == SCHEDULER_TYPE_NONE) {
             break;
         }
-        out.push_back(std::move(current));
+
+        out.emplace_back(settings::schedule(index, type));
     }
 
     return out;
@@ -290,7 +336,7 @@ Schedules schedules() {
 
 void migrate(int version) {
     if (version < 6) {
-        moveSettings("schSwitch", "schTarget");
+        moveSettings(PSTR("schSwitch"), keys::Target);
     }
 }
 
@@ -298,25 +344,39 @@ void migrate(int version) {
 
 // -----------------------------------------------------------------------------
 
-namespace api {
 #if API_SUPPORT
+namespace api {
+namespace keys {
+
+alignas(4) static constexpr char Enabled[] PROGMEM = "enabled";
+alignas(4) static constexpr char Target[] PROGMEM = "enabled";
+alignas(4) static constexpr char Type[] PROGMEM = "type";
+alignas(4) static constexpr char Action[] PROGMEM = "action";
+alignas(4) static constexpr char Restore[] PROGMEM = "restore";
+alignas(4) static constexpr char UseUTC[] PROGMEM = "utc";
+alignas(4) static constexpr char Weekdays[] PROGMEM = "weekdays";
+alignas(4) static constexpr char Hour[] PROGMEM = "hour";
+alignas(4) static constexpr char Minute[] PROGMEM = "minute";
+
+} // namespace keys
 
 void print(JsonObject& root, const Schedule& schedule) {
-    root["enabled"] = schedule.enabled;
-    root["target"] = schedule.target;
-    root["type"] = schedule.type;
-    root["action"] = schedule.action;
-    root["restore"] = schedule.restore;
-    root["utc"] = schedule.utc;
-    root["weekdays"] = schedule.weekdays.toString();
-    root["hour"] = schedule.hour;
-    root["minute"] = schedule.minute;
+    root[FPSTR(keys::Enabled)] = schedule.enabled;
+    root[FPSTR(keys::Target)] = schedule.target;
+    root[FPSTR(keys::Type)] = schedule.type;
+    root[FPSTR(keys::Action)] = schedule.action;
+    root[FPSTR(keys::Restore)] = schedule.restore;
+    root[FPSTR(keys::UseUTC)] = schedule.utc;
+    root[FPSTR(keys::Weekdays)] = schedule.weekdays.toString();
+    root[FPSTR(keys::Hour)] = schedule.hour;
+    root[FPSTR(keys::Minute)] = schedule.minute;
 }
 
 template <typename T>
-bool setFromJsonIf(JsonObject& root, SettingsKey&& key, const char* const jsonKey) {
-    if (root.containsKey(jsonKey) && root.is<T>(jsonKey)) {
-        setSetting(key, ::settings::internal::serialize(root[jsonKey].as<T>()));
+bool setFromJsonIf(JsonObject& root, const char* key, size_t id, const char* jsonKey) {
+    const auto* jsonKeyFpstr = FPSTR(jsonKey);
+    if (root.containsKey(jsonKeyFpstr) && root.is<T>(jsonKeyFpstr)) {
+        setSetting({key, id}, ::settings::internal::serialize(root[jsonKeyFpstr].as<T>()));
         return true;
     }
 
@@ -324,9 +384,10 @@ bool setFromJsonIf(JsonObject& root, SettingsKey&& key, const char* const jsonKe
 }
 
 template <>
-bool setFromJsonIf<String>(JsonObject& root, SettingsKey&& key, const char* const jsonKey) {
-    if (root.containsKey(jsonKey) && root.is<String>(jsonKey)) {
-        setSetting(key, root[jsonKey].as<String>());
+bool setFromJsonIf<String>(JsonObject& root, const char* key, size_t id, const char* jsonKey) {
+    const auto* jsonKeyFpstr = FPSTR(jsonKey);
+    if (root.containsKey(jsonKeyFpstr) && root.is<String>(jsonKeyFpstr)) {
+        setSetting({key, id}, root[jsonKeyFpstr].as<String>());
         return true;
     }
 
@@ -334,23 +395,23 @@ bool setFromJsonIf<String>(JsonObject& root, SettingsKey&& key, const char* cons
 }
 
 bool set(JsonObject& root, const size_t id) {
-    if (setFromJsonIf<int>(root, {"schType", id}, "type")) {
-        setFromJsonIf<bool>(root, {"schEnabled", id}, "enabled");
-        setFromJsonIf<int>(root, {"schTarget", id}, "target");
-        setFromJsonIf<int>(root, {"schAction", id}, "action");
-        setFromJsonIf<bool>(root, {"schRestore", id}, "restore");
-        setFromJsonIf<bool>(root, {"schUTC", id}, "utc");
-        setFromJsonIf<String>(root, {"schWDs", id}, "weekdays");
-        setFromJsonIf<int>(root, {"schHour", id}, "hour");
-        setFromJsonIf<int>(root, {"schMinute", id}, "minute");
+    if (setFromJsonIf<int>(root, settings::keys::Type, id, keys::Type)) {
+        setFromJsonIf<bool>(root, settings::keys::Enabled, id, keys::Enabled);
+        setFromJsonIf<int>(root, settings::keys::Target, id, keys::Target);
+        setFromJsonIf<int>(root, settings::keys::Action, id, keys::Action);
+        setFromJsonIf<bool>(root, settings::keys::Restore, id, keys::Restore);
+        setFromJsonIf<bool>(root, settings::keys::UseUTC, id, keys::UseUTC);
+        setFromJsonIf<String>(root, settings::keys::Weekdays, id, keys::Weekdays);
+        setFromJsonIf<int>(root, settings::keys::Hour, id, keys::Hour);
+        setFromJsonIf<int>(root, settings::keys::Minute, id, keys::Minute);
         return true;
     }
 
     return false;
 }
 
-#endif  // API_SUPPORT
 } // namespace api
+#endif  // API_SUPPORT
 
 // -----------------------------------------------------------------------------
 
@@ -367,44 +428,14 @@ void onVisible(JsonObject& root) {
     }
 }
 
-void fillEntry(JsonArray& entry, const Schedule& schedule) {
-    entry.add(schedule.enabled);
-    entry.add(schedule.target);
-    entry.add(schedule.type);
-    entry.add(schedule.action);
-    entry.add(schedule.restore);
-    entry.add(schedule.utc);
-    entry.add(schedule.weekdays.toString());
-    entry.add(schedule.hour);
-    entry.add(schedule.minute);
-}
+void onConnected(JsonObject& root){
+    if (schedulable()) {
+        ::web::ws::EnumerableConfig config{ root, STRING_VIEW("schConfig") };
+        config(STRING_VIEW("schedules"), settings::count(), settings::IndexedSettings);
 
-void onConnected(JsonObject &root){
-    if (!schedulable()) return;
-
-    JsonObject& config = root.createNestedObject("schConfig");
-    config["max"] = build::max();
-
-    JsonArray& schema = config.createNestedArray("schema");
-    schema.copyFrom(settings::keys.data(), settings::keys.size());
-
-    uint8_t size = 0;
-
-    JsonArray& schedules = config.createNestedArray("schedules");
-
-    for (size_t id = 0; id < build::max(); ++id) {
-        auto schedule = settings::schedule(id);
-        if (schedule.type == SCHEDULER_TYPE_NONE) {
-            break;
-        }
-
-        JsonArray& entry = schedules.createNestedArray();
-        fillEntry(entry, schedule);
-        ++size;
+        auto& schedules = config.root();
+        schedules["max"] = build::max();
     }
-
-    config["size"] = size;
-    config["start"] = 0;
 }
 
 #endif
diff --git a/code/espurna/sensor.cpp b/code/espurna/sensor.cpp
index 05d00a64..bcdb751e 100644
--- a/code/espurna/sensor.cpp
+++ b/code/espurna/sensor.cpp
@@ -26,6 +26,7 @@ Copyright (C) 2020-2021 by Maxim Prokhorov <prokhorov dot max at outlook dot com
 
 #include <cfloat>
 #include <cmath>
+#include <cstring>
 
 #include <limits>
 #include <vector>
@@ -467,35 +468,35 @@ namespace settings {
 namespace internal {
 namespace {
 
-alignas(4) constexpr static const char Farenheit[] = ("°F");
-alignas(4) constexpr static const char Celcius[] = ("°C");
-alignas(4) constexpr static const char Kelvin[] = ("K");
-alignas(4) constexpr static const char Percentage[] = ("%");
-alignas(4) constexpr static const char Hectopascal[] = ("hPa");
-alignas(4) constexpr static const char Ampere[] = ("A");
-alignas(4) constexpr static const char Volt[] = ("V");
-alignas(4) constexpr static const char Watt[] = ("W");
-alignas(4) constexpr static const char Kilowatt[] = ("kW");
-alignas(4) constexpr static const char Voltampere[] = ("VA");
-alignas(4) constexpr static const char Kilovoltampere[] = ("kVA");
-alignas(4) constexpr static const char VoltampereReactive[] = ("VAR");
-alignas(4) constexpr static const char KilovoltampereReactive[] = ("kVAR");
-alignas(4) constexpr static const char Joule[] = ("J");
-alignas(4) constexpr static const char KilowattHour[] = ("kWh");
-alignas(4) constexpr static const char MicrogrammPerCubicMeter[] = ("µg/m³");
-alignas(4) constexpr static const char PartsPerMillion[] = ("ppm");
-alignas(4) constexpr static const char Lux[] = ("lux");
-alignas(4) constexpr static const char UltravioletIndex[] = ("UVindex");
-alignas(4) constexpr static const char Ohm[] = ("ohm");
-alignas(4) constexpr static const char MilligrammPerCubicMeter[] = ("mg/m³");
-alignas(4) constexpr static const char CountsPerMinute[] = ("cpm");
-alignas(4) constexpr static const char MicrosievertPerHour[] = ("µSv/h");
-alignas(4) constexpr static const char Meter[] = ("m");
-alignas(4) constexpr static const char Hertz[] = ("Hz");
-alignas(4) constexpr static const char Ph[] = ("pH");
-alignas(4) constexpr static const char None[] = ("none");
+alignas(4) static constexpr char Farenheit[] PROGMEM = "°F";
+alignas(4) static constexpr char Celcius[] PROGMEM = "°C";
+alignas(4) static constexpr char Kelvin[] PROGMEM = "K";
+alignas(4) static constexpr char Percentage[] PROGMEM = "%";
+alignas(4) static constexpr char Hectopascal[] PROGMEM = "hPa";
+alignas(4) static constexpr char Ampere[] PROGMEM = "A";
+alignas(4) static constexpr char Volt[] PROGMEM = "V";
+alignas(4) static constexpr char Watt[] PROGMEM = "W";
+alignas(4) static constexpr char Kilowatt[] PROGMEM = "kW";
+alignas(4) static constexpr char Voltampere[] PROGMEM = "VA";
+alignas(4) static constexpr char Kilovoltampere[] PROGMEM = "kVA";
+alignas(4) static constexpr char VoltampereReactive[] PROGMEM = "VAR";
+alignas(4) static constexpr char KilovoltampereReactive[] PROGMEM = "kVAR";
+alignas(4) static constexpr char Joule[] PROGMEM = "J";
+alignas(4) static constexpr char KilowattHour[] PROGMEM = "kWh";
+alignas(4) static constexpr char MicrogrammPerCubicMeter[] PROGMEM = "µg/m³";
+alignas(4) static constexpr char PartsPerMillion[] PROGMEM = "ppm";
+alignas(4) static constexpr char Lux[] PROGMEM = "lux";
+alignas(4) static constexpr char UltravioletIndex[] PROGMEM = "UVindex";
+alignas(4) static constexpr char Ohm[] PROGMEM = "ohm";
+alignas(4) static constexpr char MilligrammPerCubicMeter[] PROGMEM = "mg/m³";
+alignas(4) static constexpr char CountsPerMinute[] PROGMEM = "cpm";
+alignas(4) static constexpr char MicrosievertPerHour[] PROGMEM = "µSv/h";
+alignas(4) static constexpr char Meter[] PROGMEM = "m";
+alignas(4) static constexpr char Hertz[] PROGMEM = "Hz";
+alignas(4) static constexpr char Ph[] PROGMEM = "pH";
+alignas(4) static constexpr char None[] PROGMEM = "none";
 
-constexpr static const EnumOption<sensor::Unit> SensorUnitOptions[] PROGMEM {
+static constexpr ::settings::options::Enumeration<sensor::Unit> SensorUnitOptions[] PROGMEM {
     {sensor::Unit::Farenheit, Farenheit},
     {sensor::Unit::Celcius, Celcius},
     {sensor::Unit::Kelvin, Kelvin},
@@ -540,34 +541,6 @@ String serialize(sensor::Unit unit) {
 } // namespace internal
 } // namespace settings
 
-namespace {
-
-// -----------------------------------------------------------------------------
-// Configuration
-// -----------------------------------------------------------------------------
-
-constexpr double _magnitudeCorrection(unsigned char type) {
-    return (
-        (MAGNITUDE_TEMPERATURE == type) ? (SENSOR_TEMPERATURE_CORRECTION) :
-        (MAGNITUDE_HUMIDITY == type) ? (SENSOR_HUMIDITY_CORRECTION) :
-        (MAGNITUDE_LUX == type) ? (SENSOR_LUX_CORRECTION) :
-        (MAGNITUDE_PRESSURE == type) ? (SENSOR_PRESSURE_CORRECTION) :
-        0.0
-    );
-}
-
-constexpr bool _magnitudeCorrectionSupported(unsigned char type) {
-    return (
-        (MAGNITUDE_TEMPERATURE == type) ? (true) :
-        (MAGNITUDE_HUMIDITY == type) ? (true) :
-        (MAGNITUDE_LUX == type) ? (true) :
-        (MAGNITUDE_PRESSURE == type) ? (true) :
-        false
-    );
-}
-
-} // namespace
-
 // -----------------------------------------------------------------------------
 // Energy persistence
 // -----------------------------------------------------------------------------
@@ -575,7 +548,6 @@ constexpr bool _magnitudeCorrectionSupported(unsigned char type) {
 namespace {
 
 struct SensorEnergyTracker {
-    static constexpr int Every { SENSOR_SAVE_EVERY };
     using Magnitude = std::reference_wrapper<sensor_magnitude_t>;
 
     struct Counter {
@@ -1437,23 +1409,57 @@ String _magnitudeSettingsKey(sensor_magnitude_t& magnitude, T&& suffix) {
     return _magnitudeSettingsKey(magnitude.type, std::forward<T>(suffix));
 }
 
-bool _sensorMatchKeyPrefix(const char* key) {
-    if (strncmp_P(key, PSTR("sns"), 3) == 0) {
+constexpr double _magnitudeCorrection(unsigned char type) {
+    return (
+        (MAGNITUDE_TEMPERATURE == type) ? (SENSOR_TEMPERATURE_CORRECTION) :
+        (MAGNITUDE_HUMIDITY == type) ? (SENSOR_HUMIDITY_CORRECTION) :
+        (MAGNITUDE_LUX == type) ? (SENSOR_LUX_CORRECTION) :
+        (MAGNITUDE_PRESSURE == type) ? (SENSOR_PRESSURE_CORRECTION) :
+        0.0
+    );
+}
+
+constexpr bool _magnitudeCorrectionSupported(unsigned char type) {
+  return (MAGNITUDE_TEMPERATURE == type)
+      || (MAGNITUDE_HUMIDITY == type)
+      || (MAGNITUDE_LUX == type)
+      || (MAGNITUDE_PRESSURE == type);
+}
+
+SettingsKey _magnitudeSettingsCorrectionKey(unsigned char type, size_t index) {
+    static constexpr char Key[] PROGMEM { "Correction" };
+    return {_magnitudeSettingsKey(type, FPSTR(Key)), index};
+}
+
+SettingsKey _magnitudeSettingsCorrectionKey(const sensor_magnitude_t& magnitude) {
+    return _magnitudeSettingsCorrectionKey(magnitude.type, magnitude.index_global);
+}
+
+bool _sensorCheckKeyPrefix(::settings::StringView key) {
+    if (key.length() < 3) {
+        return false;
+    }
+
+    using settings::query::samePrefix;
+    using settings::StringView;
+
+    alignas(4) static constexpr char SensorPrefix[] PROGMEM = "sns";
+    if (samePrefix(key, SensorPrefix)) {
         return true;
     }
 
-    if (strncmp_P(key, PSTR("pwr"), 3) == 0) {
+    alignas(4) static constexpr char PowerPrefix[] PROGMEM = "pwr";
+    if (samePrefix(key, PowerPrefix)) {
         return true;
     }
 
-    const String _key(key);
     return _magnitudeForEachCountedCheck([&](unsigned char type) {
-        return _key.startsWith(_magnitudeSettingsPrefix(type));
+        return samePrefix(key, StringView{_magnitudeSettingsPrefix(type)});
     });
 }
 
 SettingsKey _magnitudeSettingsRatioKey(unsigned char type, size_t index) {
-    static const char RatioKey[] PROGMEM { "Ratio" };
+    static constexpr char RatioKey[] PROGMEM { "Ratio" };
     return {_magnitudeSettingsKey(type, FPSTR(RatioKey)), index};
 }
 
@@ -1472,38 +1478,26 @@ constexpr bool _magnitudeRatioSupported(unsigned char type) {
         || (type == MAGNITUDE_ENERGY);
 }
 
-String _sensorQueryDefault(const String& key) {
-    auto get_defaults = [](sensor_magnitude_t* magnitude) -> String {
-        if (magnitude && _sensorIsEmon(magnitude->sensor)) {
-            auto* sensor = static_cast<BaseEmonSensor*>(magnitude->sensor);
-            if (_magnitudeRatioSupported(magnitude->type)) {
-                return String(sensor->defaultRatio(magnitude->slot));
-            }
-        }
+String _sensorQueryHandler(::settings::StringView key) {
+    String out;
 
-        return String();
-    };
-
-    auto magnitude_key = [](const sensor_magnitude_t& magnitude) -> SettingsKey {
-        if (_magnitudeRatioSupported(magnitude.type)) {
-            return _magnitudeSettingsRatioKey(magnitude);
-        }
-
-        return "";
-    };
-
-    sensor_magnitude_t* target { nullptr };
     for (auto& magnitude : _magnitudes) {
         if (_magnitudeRatioSupported(magnitude.type)) {
-            auto ratioKey(magnitude_key(magnitude));
-            if (ratioKey == key) {
-                target = &magnitude;
+            auto expected = String(_magnitudeSettingsRatioKey(magnitude));
+            if (key == expected) {
+                out = String(reinterpret_cast<BaseEmonSensor*>(magnitude.sensor)->defaultRatio(magnitude.slot));
+                break;
+            }
+        } else if (_magnitudeCorrectionSupported(magnitude.type)) {
+            auto expected = String(_magnitudeSettingsCorrectionKey(magnitude));
+            if (key == expected) {
+                out = String(magnitude.correction);
                 break;
             }
         }
     }
 
-    return get_defaults(target);
+    return out;
 }
 
 } // namespace
@@ -1575,7 +1569,7 @@ double _sensorApiEmonExpectedValue(const sensor_magnitude_t& magnitude, double e
 namespace {
 
 bool _sensorWebSocketOnKeyCheck(const char* key, JsonVariant&) {
-    return _sensorMatchKeyPrefix(key);
+    return _sensorCheckKeyPrefix(key);
 }
 
 String _sensorError(unsigned char error) {
@@ -1749,40 +1743,40 @@ String _magnitudeName(unsigned char type) {
 // make sure these are properly ordered, as UI does not delay processing
 
 void _sensorWebSocketTypes(JsonObject& root) {
-    ::web::ws::EnumerableConfig config{root, F("types")};
-    config(F("values"), {MAGNITUDE_NONE + 1, MAGNITUDE_MAX},
+    ::web::ws::EnumerablePayload payload{root, STRING_VIEW("types")};
+    payload(STRING_VIEW("values"), {MAGNITUDE_NONE + 1, MAGNITUDE_MAX},
         [](size_t type) {
             return sensor_magnitude_t::counts(type) > 0;
         },
         {
-            {F("type"), [](JsonArray& out, size_t index) {
+            {STRING_VIEW("type"), [](JsonArray& out, size_t index) {
                 out.add(index);
             }},
-            {F("prefix"), [](JsonArray& out, size_t index) {
+            {STRING_VIEW("prefix"), [](JsonArray& out, size_t index) {
                 out.add(_magnitudeSettingsPrefix(index));
             }},
-            {F("name"), [](JsonArray& out, size_t index) {
+            {STRING_VIEW("name"), [](JsonArray& out, size_t index) {
                 out.add(_magnitudeName(index));
             }}
         });
 }
 
 void _sensorWebSocketErrors(JsonObject& root) {
-    ::web::ws::EnumerableConfig config{root, F("errors")};
-    config(F("values"), SENSOR_ERROR_MAX, {
-        {F("type"), [](JsonArray& out, size_t index) {
+    ::web::ws::EnumerablePayload payload{root, STRING_VIEW("errors")};
+    payload(STRING_VIEW("values"), SENSOR_ERROR_MAX, {
+        {STRING_VIEW("type"), [](JsonArray& out, size_t index) {
             out.add(index);
         }},
-        {F("name"), [](JsonArray& out, size_t index) {
+        {STRING_VIEW("name"), [](JsonArray& out, size_t index) {
             out.add(_sensorError(index));
         }}
     });
 }
 
 void _sensorWebSocketUnits(JsonObject& root) {
-    ::web::ws::EnumerableConfig config{root, F("units")};
-    config(F("values"), _magnitudes.size(), {
-        {F("supported"), [](JsonArray& out, size_t index) {
+    ::web::ws::EnumerablePayload payload{root, STRING_VIEW("units")};
+    payload(STRING_VIEW("values"), _magnitudes.size(), {
+        {STRING_VIEW("supported"), [](JsonArray& out, size_t index) {
             JsonArray& units = out.createNestedArray();
             const auto range = _magnitudeUnitsRange(_magnitudes[index].type);
             for (auto it = range.begin(); it != range.end(); ++it) {
@@ -1795,18 +1789,18 @@ void _sensorWebSocketUnits(JsonObject& root) {
 }
 
 void _sensorWebSocketList(JsonObject& root) {
-    ::web::ws::EnumerableConfig config{root, F("magnitudes-list")};
-    config(F("values"), _magnitudes.size(), {
-        {F("index_global"), [](JsonArray& out, size_t index) {
+    ::web::ws::EnumerablePayload payload{root, STRING_VIEW("magnitudes-list")};
+    payload(STRING_VIEW("values"), _magnitudes.size(), {
+        {STRING_VIEW("index_global"), [](JsonArray& out, size_t index) {
             out.add(_magnitudes[index].index_global);
         }},
-        {F("type"), [](JsonArray& out, size_t index) {
+        {STRING_VIEW("type"), [](JsonArray& out, size_t index) {
             out.add(_magnitudes[index].type);
         }},
-        {F("description"), [](JsonArray& out, size_t index) {
+        {STRING_VIEW("description"), [](JsonArray& out, size_t index) {
             out.add(_magnitudeDescription(_magnitudes[index]));
         }},
-        {F("units"), [](JsonArray& out, size_t index) {
+        {STRING_VIEW("units"), [](JsonArray& out, size_t index) {
             out.add(static_cast<int>(_magnitudes[index].units));
         }}
     });
@@ -1818,9 +1812,9 @@ void _sensorWebSocketSettings(JsonObject& root) {
     // NaN, instead of more commonly used null (but, expect this to be fixed after switching to v6+)
     static const char* const NullSymbol { nullptr };
 
-    ::web::ws::EnumerableConfig config{root, F("magnitudes-settings")};
-    config(F("values"), _magnitudes.size(), {
-        {F("Correction"), [](JsonArray& out, size_t index) {
+    ::web::ws::EnumerablePayload payload{root, STRING_VIEW("magnitudes-settings")};
+    payload(STRING_VIEW("values"), _magnitudes.size(), {
+        {STRING_VIEW("Correction"), [](JsonArray& out, size_t index) {
             const auto& magnitude = _magnitudes[index];
             if (_magnitudeCorrectionSupported(magnitude.type)) {
                 out.add(magnitude.correction);
@@ -1828,7 +1822,7 @@ void _sensorWebSocketSettings(JsonObject& root) {
                 out.add(NullSymbol);
             }
         }},
-        {F("Ratio"), [](JsonArray& out, size_t index) {
+        {STRING_VIEW("Ratio"), [](JsonArray& out, size_t index) {
             const auto& magnitude = _magnitudes[index];
             if (_magnitudeRatioSupported(magnitude.type)) {
                 out.add(static_cast<BaseEmonSensor*>(magnitude.sensor)->getRatio(magnitude.slot));
@@ -1836,7 +1830,7 @@ void _sensorWebSocketSettings(JsonObject& root) {
                 out.add(NullSymbol);
             }
         }},
-        {F("ZeroThreshold"), [](JsonArray& out, size_t index) {
+        {STRING_VIEW("ZeroThreshold"), [](JsonArray& out, size_t index) {
             const auto threshold = _magnitudes[index].zero_threshold;
             if (!std::isnan(threshold)) {
                 out.add(threshold);
@@ -1844,10 +1838,10 @@ void _sensorWebSocketSettings(JsonObject& root) {
                 out.add(NullSymbol);
             }
         }},
-        {F("MinDelta"), [](JsonArray& out, size_t index) {
+        {STRING_VIEW("MinDelta"), [](JsonArray& out, size_t index) {
             out.add(_magnitudes[index].min_delta);
         }},
-        {F("MaxDelta"), [](JsonArray& out, size_t index) {
+        {STRING_VIEW("MaxDelta"), [](JsonArray& out, size_t index) {
             out.add(_magnitudes[index].max_delta);
         }}
     });
@@ -1860,32 +1854,34 @@ void _sensorWebSocketSettings(JsonObject& root) {
 }
 
 void _sensorWebSocketSendData(JsonObject& root) {
-    ::web::ws::EnumerableConfig config{root, F("magnitudes")};
-    config(F("values"), _magnitudes.size(), {
-        {F("value"), [](JsonArray& out, size_t index) {
-            char buffer[64];
-            dtostrf(_magnitudeProcess(
-                _magnitudes[index], _magnitudes[index].last),
-                1, _magnitudes[index].decimals, buffer);
-            out.add(buffer);
-        }},
-        {F("error"), [](JsonArray& out, size_t index) {
-            out.add(_magnitudes[index].sensor->error());
-        }},
-        {F("info"), [](JsonArray& out, size_t index) {
+    if (_magnitudes.size()) {
+        ::web::ws::EnumerablePayload payload{root, STRING_VIEW("magnitudes")};
+        payload(STRING_VIEW("values"), _magnitudes.size(), {
+            {STRING_VIEW("value"), [](JsonArray& out, size_t index) {
+                char buffer[64];
+                dtostrf(_magnitudeProcess(
+                    _magnitudes[index], _magnitudes[index].last),
+                    1, _magnitudes[index].decimals, buffer);
+                out.add(buffer);
+            }},
+            {STRING_VIEW("error"), [](JsonArray& out, size_t index) {
+                out.add(_magnitudes[index].sensor->error());
+            }},
+            {STRING_VIEW("info"), [](JsonArray& out, size_t index) {
 #if NTP_SUPPORT
-            if ((_magnitudes[index].type == MAGNITUDE_ENERGY) && (_sensor_energy_tracker)) {
-                out.add(String(F("Last saved: "))
-                    + getSetting({"eneTime", _magnitudes[index].index_global},
-                        F("(unknown)")));
-            } else {
+                if ((_magnitudes[index].type == MAGNITUDE_ENERGY) && (_sensor_energy_tracker)) {
+                    out.add(String(F("Last saved: "))
+                        + getSetting({"eneTime", _magnitudes[index].index_global},
+                            F("(unknown)")));
+                } else {
 #endif
-                out.add("");
+                    out.add("");
 #if NTP_SUPPORT
-            }
+                }
 #endif
-        }}
-    });
+            }}
+        });
+    }
 }
 
 void _sensorWebSocketOnAction(uint32_t client_id, const char* action, JsonObject& data) {
@@ -1994,19 +1990,19 @@ void _sensorWebSocketOnConnectedSettings(JsonObject& root) {
 // Prefix controls the UI templates, supplied callback should retrieve module-specific value Id
 
 void sensorWebSocketMagnitudes(JsonObject& root, const char* prefix, SensorWebSocketMagnitudesCallback callback) {
-    ::web::ws::EnumerableConfig config{root, F("magnitudes-module")};
+    ::web::ws::EnumerablePayload payload{root, STRING_VIEW("magnitudes-module")};
 
-    auto& container = config.root();
+    auto& container = payload.root();
     container[F("prefix")] = prefix;
 
-    config(F("values"), _magnitudes.size(), {
-        {F("type"), [](JsonArray& out, size_t index) {
+    payload(STRING_VIEW("values"), _magnitudes.size(), {
+        {STRING_VIEW("type"), [](JsonArray& out, size_t index) {
             out.add(_magnitudes[index].type);
         }},
-        {F("index_global"), [](JsonArray& out, size_t index) {
+        {STRING_VIEW("index_global"), [](JsonArray& out, size_t index) {
             out.add(_magnitudes[index].index_global);
         }},
-        {F("index_module"), callback}
+        {STRING_VIEW("index_module"), callback}
     });
 }
 
@@ -3073,8 +3069,9 @@ void _sensorConfigure() {
             // TODO: inject math or rpnlib expression?
             {
                 if (_magnitudeCorrectionSupported(magnitude.type)) {
-                    auto key = String(_magnitudeSettingsPrefix(magnitude.type)) + F("Correction");
-                    magnitude.correction = getSetting({key, magnitude.index_global}, getSetting(key, _magnitudeCorrection(magnitude.type)));
+                    magnitude.correction = getSetting(
+                        _magnitudeSettingsCorrectionKey(magnitude),
+                        _magnitudeCorrection(magnitude.type));
                 }
             }
 
@@ -3283,10 +3280,9 @@ void sensorSetup() {
     _sensorConfigure();
 
     // Allow us to query key default
-    _magnitudeForEachCounted([](unsigned char type) {
-        if (_magnitudeRatioSupported(type)) {
-            settingsRegisterDefaults(_magnitudeSettingsPrefix(type), _sensorQueryDefault);
-        }
+    settingsRegisterQueryHandler({
+        .check = _sensorCheckKeyPrefix,
+        .get = _sensorQueryHandler
     });
 
     // Websockets integration, send sensor readings and configuration
diff --git a/code/espurna/settings.cpp b/code/espurna/settings.cpp
index 83270deb..ebfb9b50 100644
--- a/code/espurna/settings.cpp
+++ b/code/espurna/settings.cpp
@@ -42,31 +42,85 @@ static kvs_type kv_store(
 // --------------------------------------------------------------------------
 
 namespace settings {
+namespace query {
+
+String Setting::findValueFrom(const Setting* begin, const Setting* end, StringView key) {
+    String out;
+
+    for (auto it = begin; it != end; ++it) {
+        if ((*it) == key) {
+            out = (*it).value();
+            break;
+        }
+    }
+
+    return out;
+}
+
+bool IndexedSetting::findSamePrefix(const IndexedSetting* begin, const IndexedSetting* end, StringView key) {
+    for (auto it = begin; it != end; ++it) {
+        if (samePrefix(key, (*it).prefix())) {
+            return true;
+        }
+    }
+
+    return false;
+}
+
+String IndexedSetting::findValueFrom(Iota iota, const IndexedSetting* begin, const IndexedSetting* end, StringView key) {
+    String out;
+
+    while (iota) {
+        for (auto it = begin; it != end; ++it) {
+            const auto expected = SettingsKey(
+                (*it).prefix().toString(), *iota);
+            if (key == expected.value()) {
+                out = (*it).value(*iota);
+                goto output;
+            }
+        }
+        ++iota;
+    }
+
+output:
+    return out;
+}
+
 namespace internal {
 namespace {
 
-struct SettingsKeyMatcher {
-    SettingsKeyMatcher(String prefix, RetrieveDefault retrieve) :
-        _prefix(std::move(prefix)),
-        _retrieve(retrieve)
-    {}
-
-    const String& prefix() const {
-        return _prefix;
-    }
-
-    String retrieve(const String& key) const {
-        return _retrieve(key);
-    }
-
-private:
-    String _prefix;
-    RetrieveDefault _retrieve;
-};
-
-std::forward_list<SettingsKeyMatcher> matchers;
+std::forward_list<Handler> handlers;
 
 } // namespace
+} // namespace internal
+} // namespace query
+
+namespace options {
+
+bool EnumerationNumericHelper::check(const String& value) {
+    if (value.length()) {
+        if ((value.length() > 1) && (*value.begin() == '0')) {
+            return false;
+        }
+
+        for (auto it = value.begin(); it != value.end(); ++it) {
+            switch (*it) {
+            case '0'...'9':
+                break;
+            default:
+                return false;
+            }
+        }
+
+        return true;
+    }
+
+    return false;
+}
+
+} // namespace options
+
+namespace internal {
 
 ValueResult get(const String& key) {
     return kv_store.get(key);
@@ -107,23 +161,6 @@ void foreach(KeyValueResultCallback&& callback) {
 
 // --------------------------------------------------------------------------
 
-uint32_t u32fromString(const String& string, int base) {
-
-    const char *ptr = string.c_str();
-    char *value_endptr = nullptr;
-
-    // invalidate the whole string when invalid chars are detected
-    const auto value = strtoul(ptr, &value_endptr, base);
-    if (value_endptr == ptr || value_endptr[0] != '\0') {
-        return 0;
-    }
-
-    return value;
-
-}
-
-// --------------------------------------------------------------------------
-
 template <>
 float convert(const String& value) {
     return atof(value.c_str());
@@ -177,62 +214,11 @@ bool convert(const String& value) {
 
 template <>
 uint32_t convert(const String& value) {
-    if (!value.length()) {
-        return 0;
-    }
-
-    int base = 10;
-    if (value.length() > 2) {
-        auto* ptr = value.c_str();
-        if (*ptr == '0') {
-            switch (*(ptr + 1)) {
-            case 'b':
-                base = 2;
-                break;
-            case 'o':
-                base = 8;
-                break;
-            case 'x':
-                base = 16;
-                break;
-            }
-        }
-    }
-
-    return u32fromString((base == 10) ? value : value.substring(2), base);
+    return parseUnsigned(value);
 }
 
 String serialize(uint32_t value, int base) {
-    constexpr size_t Size { 8 * sizeof(decltype(value)) };
-
-    String result;
-    if (base == 2) {
-        result += "0b";
-    } else if (base == 8) {
-        result += "0o";
-    } else if (base == 16) {
-        result += "0x";
-    }
-
-    char buffer[Size + 1] = {0};
-    ultoa(value, buffer, base);
-    result += buffer;
-
-    return result;
-}
-
-bool EnumOptionNumeric::check(const String& value) {
-    if (value.length() && (*value.begin() != '0')) {
-        for (auto it = value.begin(); it != value.end(); ++it) {
-            if (((*it) < '0') || ('9' < (*it))) {
-                return false;
-            }
-        }
-
-        return true;
-    }
-
-    return false;
+    return formatUnsigned(value, base);
 }
 
 template <>
@@ -271,17 +257,21 @@ std::vector<String> settingsKeys() {
     return keys;
 }
 
-void settingsRegisterDefaults(String prefix, settings::RetrieveDefault retrieve) {
-    settings::internal::matchers.emplace_front(std::move(prefix), retrieve);
+void settingsRegisterQueryHandler(settings::query::Handler handler) {
+    settings::query::internal::handlers.push_front(handler);
 }
 
-String settingsQueryDefaults(const String& key) {
-    for (auto& matcher : settings::internal::matchers) {
-        if (key.startsWith(matcher.prefix())) {
-            return matcher.retrieve(key);
+String settingsQuery(::settings::StringView key) {
+    String out;
+
+    for (const auto& handler : settings::query::internal::handlers) {
+        if (handler.check(key)) {
+            out = handler.get(key);
+            break;
         }
     }
-    return {};
+
+    return out;
 }
 
 void moveSetting(const String& from, const String& to) {
@@ -505,6 +495,21 @@ void settingsGetJson(JsonObject& root) {
 
 #if TERMINAL_SUPPORT
 
+void settingsDump(const ::terminal::CommandContext& ctx, const ::settings::query::Setting* begin, const ::settings::query::Setting* end) {
+    for (auto it = begin; it != end; ++it) {
+        ctx.output.printf_P(PSTR("> %s => %s\n"),
+            (*it).key().c_str(), (*it).value().c_str());
+    }
+}
+
+void settingsDump(const ::terminal::CommandContext& ctx, const ::settings::query::IndexedSetting* begin, const ::settings::query::IndexedSetting* end, size_t index) {
+    for (auto it = begin; it != end; ++it) {
+        ctx.output.printf_P(PSTR("> %s%u => %s\n"),
+            (*it).prefix().c_str(), index,
+            (*it).value(index).c_str());
+    }
+}
+
 namespace {
 
 void _settingsInitCommands() {
@@ -520,8 +525,6 @@ void _settingsInitCommands() {
     terminalRegisterCommand(F("KEYS"), [](::terminal::CommandContext&& ctx) {
         auto keys = settingsKeys();
 
-        ctx.output.print(F("Current settings:"));
-
         String value;
         for (unsigned int i=0; i<keys.size(); i++) {
             value = getSetting(keys[i]);
@@ -575,13 +578,13 @@ void _settingsInitCommands() {
         }
 
         for (auto it = (ctx.argv.cbegin() + 1); it != ctx.argv.cend(); ++it) {
-            const String& key { *it };
+            auto key = ::settings::StringView { *it };
 
-            auto result = settings::internal::get(key);
+            auto result = settings::internal::get(key.toString());
             if (!result) {
-                const auto maybeDefault = settingsQueryDefaults(key);
-                if (maybeDefault.length()) {
-                    ctx.output.printf_P(PSTR("> %s => %s (default)\n"), key.c_str(), maybeDefault.c_str());
+                const auto maybeValue = settingsQuery(key);
+                if (maybeValue.length()) {
+                    ctx.output.printf_P(PSTR("> %s => %s (default)\n"), key.c_str(), maybeValue.c_str());
                 } else {
                     ctx.output.printf_P(PSTR("> %s =>\n"), key.c_str());
                 }
@@ -613,7 +616,6 @@ void _settingsInitCommands() {
 }
 
 } // namespace
-
 #endif
 
 void settingsSetup() {
diff --git a/code/espurna/settings.h b/code/espurna/settings.h
index dfb3415f..845f804a 100644
--- a/code/espurna/settings.h
+++ b/code/espurna/settings.h
@@ -142,6 +142,10 @@ inline String serialize(long value, int base = 10) {
     return String(value, base);
 }
 
+inline String serialize(bool value) {
+    return value ? PSTR("true") : PSTR("false");
+}
+
 inline String serialize(float value) {
     return String(value, 3);
 }
@@ -150,15 +154,12 @@ inline String serialize(double value) {
     return String(value, 3);
 }
 
-inline String serialize(bool value) {
-    return value ? F("true") : F("false");
-}
-
 template <typename Container, typename T>
 T convert(const Container& options, const String& value, T defaultValue) {
     if (value.length()) {
-        using UnderlyingType = typename EnumOption<T>::UnderlyingType;
-        typename EnumOption<T>::Numeric numeric;
+        using ::settings::options::Enumeration;
+        using UnderlyingType = typename Enumeration<T>::UnderlyingType;
+        typename Enumeration<T>::Numeric numeric;
         numeric.check(value, convert<UnderlyingType>);
 
         for (auto it = std::begin(options); it != std::end(options); ++it) {
@@ -193,13 +194,21 @@ String serialize(const Container& options, T value) {
 // --------------------------------------------------------------------------
 
 namespace settings {
+namespace query {
 
-using RetrieveDefault = String(*)(const String& key);
+using Check = bool(*)(StringView key);
+using Get = String(*)(StringView key);
 
+struct Handler {
+    Check check;
+    Get get;
+};
+
+} // namespace query
 } // namespace settings
 
-void settingsRegisterDefaults(String prefix, settings::RetrieveDefault retrieve);
-String settingsQueryDefaults(const String& key);
+void settingsRegisterQueryHandler(settings::query::Handler);
+String settingsQuery(::settings::StringView key);
 
 // --------------------------------------------------------------------------
 
@@ -242,15 +251,25 @@ bool delSetting(const String& key);
 bool delSetting(const __FlashStringHelper* key);
 bool delSetting(const SettingsKey& key);
 
-void delSettingPrefix(const std::initializer_list<const char*>&);
-void delSettingPrefix(const char* prefix);
-void delSettingPrefix(const String& prefix);
+void delSettingPrefix(settings::query::StringViewIterator);
 
 bool hasSetting(const char* key);
 bool hasSetting(const String& key);
 bool hasSetting(const __FlashStringHelper* key);
 bool hasSetting(const SettingsKey& key);
 
+void settingsDump(const ::terminal::CommandContext&, const ::settings::query::Setting* begin, const ::settings::query::Setting* end);
+template <typename T>
+void settingsDump(const ::terminal::CommandContext& ctx, const T& settings) {
+    settingsDump(ctx, std::begin(settings), std::end(settings));
+}
+
+void settingsDump(const ::terminal::CommandContext&, const ::settings::query::IndexedSetting* begin, const ::settings::query::IndexedSetting* end, size_t index);
+template <typename T>
+void settingsDump(const ::terminal::CommandContext& ctx, const T& settings, size_t index) {
+    settingsDump(ctx, std::begin(settings), std::end(settings), index);
+}
+
 void settingsGetJson(JsonObject& data);
 bool settingsRestoreJson(char* json_string, size_t json_buffer_size = 1024);
 bool settingsRestoreJson(JsonObject& data);
diff --git a/code/espurna/settings_helpers.h b/code/espurna/settings_helpers.h
index ff9d4f83..40f5c23f 100644
--- a/code/espurna/settings_helpers.h
+++ b/code/espurna/settings_helpers.h
@@ -49,6 +49,16 @@ public:
         _key += index;
     }
 
+    SettingsKey(const char* prefix, size_t index) :
+        _key(prefix)
+    {
+        _key += index;
+    }
+
+    SettingsKey(const __FlashStringHelper* prefix, size_t index) :
+        SettingsKey(reinterpret_cast<const char*>(prefix), index)
+    {}
+
     const char* c_str() const {
         return _key.c_str();
     }
@@ -81,216 +91,8 @@ private:
 // --------------------------------------------------------------------------
 
 namespace settings {
-namespace internal {
 
-struct BasicSetting {
-    using Get = String(*)();
-
-    BasicSetting() = delete;
-    constexpr BasicSetting(const char* key, Get get) :
-        _key(key),
-        _get(get)
-    {}
-
-    constexpr const char* key() const {
-        return _key;
-    }
-
-    String get() const {
-        return _get();
-    }
-
-private:
-    const char* const _key;
-    Get _get;
-};
-
-struct IndexedSetting {
-    using Get = String(*)(size_t);
-
-    IndexedSetting() = delete;
-    constexpr IndexedSetting(const char* prefix, Get get) :
-        _prefix(prefix),
-        _get(get)
-    {}
-
-    constexpr const char* prefix() const {
-        return _prefix;
-    }
-
-    String get(size_t index) const {
-        return _get(index);
-    }
-
-private:
-    const char* const _prefix;
-    Get _get;
-};
-
-struct EnumOptionNumeric {
-    static bool check(const String& value);
-};
-
-template <typename Value>
-struct alignas(4) EnumOption {
-    static_assert(std::is_enum<Value>::value, "");
-
-    using ValueType = Value;
-    using UnderlyingType = typename std::underlying_type<Value>::type;
-    static_assert((alignof(UnderlyingType) % 4) == 0, "");
-
-    struct Numeric {
-        using Convert = UnderlyingType(*)(const String&);
-
-        bool check(const String& value, Convert convert) {
-            _checked = false;
-
-            if (EnumOptionNumeric::check(value)) {
-                _value = convert(value);
-                _checked = true;
-            }
-
-            return _checked;
-        }
-
-        explicit operator bool() const {
-            return _checked;
-        }
-
-        UnderlyingType value() const {
-            return _value;
-        }
-
-    private:
-        UnderlyingType _value{};
-        bool _checked { false };
-    };
-
-
-    EnumOption() = delete;
-    constexpr EnumOption(ValueType value, const char* string) noexcept :
-        _value(value),
-        _string(string)
-    {}
-
-    constexpr ValueType value() const {
-        return _value;
-    }
-
-    constexpr UnderlyingType numeric() const {
-        return static_cast<UnderlyingType>(_value);
-    }
-
-    constexpr const char* string() const {
-        return _string;
-    }
-
-    bool operator==(const String& string) const {
-        return strcmp_P(string.c_str(), _string) == 0;
-    }
-
-private:
-    ValueType _value;
-    const char* _string;
-};
-
-} // namespace internal
-
-// generic number range
-struct Iota {
-    Iota() = default;
-    constexpr explicit Iota(size_t end) :
-        _it(0),
-        _end(end)
-    {}
-
-    constexpr Iota(size_t begin, size_t end) :
-        _it(begin),
-        _end(end)
-    {}
-
-    constexpr Iota(size_t begin, size_t end, size_t step) :
-        _it(begin),
-        _end(end),
-        _step(step)
-    {}
-
-#if __cplusplus >= 201703L
-    constexpr
-#endif
-    Iota& operator++() {
-        if (_it != _end) {
-            _it = ((_it + _step) > _end)
-                ? _end : (_it + _step);
-        }
-
-        return *this;
-    }
-
-#if __cplusplus >= 201703L
-    constexpr
-#endif
-    Iota operator++(int) {
-        Iota out(*this);
-        ++out;
-        return out;
-    }
-
-    constexpr explicit operator bool() const {
-        return _it != _end;
-    }
-
-    constexpr size_t operator*() const {
-        return _it;
-    }
-
-private:
-    size_t _it { 0 };
-    size_t _end { 0 };
-    size_t _step { 1 };
-};
-
-// store and allow to query an array of key default values and their serialization functions
-struct alignas(4) KeyDefault {
-    using SerializedFunc = String(*)(size_t);
-
-    KeyDefault() = delete;
-    constexpr KeyDefault(const char* key, SerializedFunc func) noexcept :
-        _key(key),
-        _func(func)
-    {}
-
-    bool match(const String& key, size_t id) const {
-        return SettingsKey(FPSTR(_key), id) == key;
-    }
-
-    String serialized(size_t id) const {
-        return _func(id);
-    }
-
-    template <typename T>
-    static String findKeyDefault(Iota iota, const T& defaults, const String& key) {
-        String out;
-
-        while (iota) {
-            for (const auto& keyDefault : defaults) {
-                if (keyDefault.match(key, *iota)) {
-                    out = keyDefault.serialized(*iota);
-                    break;
-                }
-            }
-            ++iota;
-        }
-
-        return out;
-    }
-
-private:
-    const char* _key;
-    SerializedFunc _func;
-};
-
-// 'optional' type for byte range
+// 'optional' type for a byte range (...from the settings storage)
 struct ValueResult {
     ValueResult() = default;
     ValueResult(const ValueResult&) = default;
@@ -343,4 +145,356 @@ private:
     String _value;
 };
 
+// generic number range
+struct Iota {
+    Iota() = default;
+    constexpr explicit Iota(size_t end) noexcept :
+        _it(0),
+        _end(end)
+    {}
+
+    constexpr Iota(size_t begin, size_t end) noexcept :
+        _it(begin),
+        _end(end)
+    {}
+
+    constexpr Iota(size_t begin, size_t end, size_t step) noexcept :
+        _it(begin),
+        _end(end),
+        _step(step)
+    {}
+
+#if __cplusplus >= 201703L
+    constexpr
+#endif
+    Iota& operator++() {
+        if (_it != _end) {
+            _it = ((_it + _step) > _end)
+                ? _end : (_it + _step);
+        }
+
+        return *this;
+    }
+
+#if __cplusplus >= 201703L
+    constexpr
+#endif
+    Iota operator++(int) {
+        Iota out(*this);
+        ++out;
+        return out;
+    }
+
+    constexpr explicit operator bool() const {
+        return _it != _end;
+    }
+
+    constexpr size_t operator*() const {
+        return _it;
+    }
+
+    constexpr size_t end() const {
+        return _end;
+    }
+
+private:
+    size_t _it { 0 };
+    size_t _end { 0 };
+    size_t _step { 1 };
+};
+
+struct StringView {
+    StringView() = delete;
+
+    template <size_t Size>
+    constexpr StringView(const char (&string)[Size]) noexcept :
+        _ptr(&string[0]),
+        _len(Size - 1)
+    {}
+
+    constexpr StringView(const char* ptr, size_t len) noexcept :
+        _ptr(ptr),
+        _len(len)
+    {}
+
+    explicit StringView(const __FlashStringHelper* ptr) noexcept :
+        _ptr(reinterpret_cast<const char*>(ptr)),
+        _len(strlen_P(_ptr))
+    {}
+
+    explicit StringView(const SettingsKey& key) noexcept :
+        _ptr(key.c_str()),
+        _len(key.length())
+    {}
+
+    StringView(const String&&) = delete;
+    StringView(const String& string) noexcept :
+        StringView(string.c_str(), string.length())
+    {}
+
+    constexpr StringView(const char* ptr) noexcept :
+        StringView(ptr, __builtin_strlen(ptr))
+    {}
+
+    bool compareRam(const StringView& other) const {
+        return (other._len == _len)
+            && (strncmp(other._ptr, _ptr, _len) == 0);
+    }
+
+    bool compareFlash(const StringView& other) const {
+        return (other._len == _len)
+            && (strncmp_P(other._ptr, _ptr, _len) == 0);
+    }
+
+    bool operator==(const String& other) const {
+        return compareFlash(other);
+    }
+
+    constexpr const char* c_str() const {
+        return _ptr;
+    }
+
+    constexpr size_t length() const {
+        return _len;
+    }
+
+    String toString() const {
+        String out;
+        out.concat(_ptr, _len);
+        return out;
+    }
+
+private:
+    const char* _ptr;
+    size_t _len;
+};
+
+#define STRING_VIEW(X) ({\
+        alignas(4) static constexpr char __pstr__[] PROGMEM = (X);\
+        ::settings::StringView{__pstr__};\
+    })
+
+namespace options {
+
+struct EnumerationNumericHelper {
+    static bool check(const String& value);
+};
+
+template <typename Value>
+struct alignas(8) Enumeration {
+    static_assert(std::is_enum<Value>::value, "");
+
+    using ValueType = Value;
+    using UnderlyingType = typename std::underlying_type<Value>::type;
+    static_assert((alignof(UnderlyingType) % 4) == 0, "");
+
+    struct Numeric {
+        using Convert = UnderlyingType(*)(const String&);
+
+        bool check(const String& value, Convert convert) {
+            _checked = false;
+
+            if (EnumerationNumericHelper::check(value)) {
+                _value = convert(value);
+                _checked = true;
+            }
+
+            return _checked;
+        }
+
+        explicit operator bool() const {
+            return _checked;
+        }
+
+        UnderlyingType value() const {
+            return _value;
+        }
+
+    private:
+        UnderlyingType _value{};
+        bool _checked { false };
+    };
+
+
+    Enumeration() = delete;
+    constexpr Enumeration(ValueType value, const char* string) noexcept :
+        _value(value),
+        _string(string)
+    {}
+
+    constexpr ValueType value() const {
+        return _value;
+    }
+
+    constexpr UnderlyingType numeric() const {
+        return static_cast<UnderlyingType>(_value);
+    }
+
+    constexpr const char* string() const {
+        return _string;
+    }
+
+    bool operator==(const String& string) const {
+        return strcmp_P(string.c_str(), _string) == 0;
+    }
+
+private:
+    ValueType _value;
+    const char* _string;
+};
+
+} // namespace options
+
+namespace query {
+
+inline bool samePrefix(StringView key, StringView prefix) {
+    if (key.length() > prefix.length()) {
+        return strncmp_P(key.c_str(), prefix.c_str(), prefix.length()) == 0;
+    }
+
+    return false;
+}
+
+struct StringViewIterator {
+    using Element = const StringView*;
+
+    StringViewIterator() = delete;
+    StringViewIterator(const StringViewIterator&) = default;
+    StringViewIterator(StringViewIterator&&) = default;
+
+    constexpr StringViewIterator(Element begin, Element end) noexcept :
+        _it(begin),
+        _begin(begin),
+        _end(end)
+    {}
+
+    StringViewIterator(std::initializer_list<StringView>&& values) noexcept :
+        _it(std::begin(values)),
+        _begin(_it),
+        _end(std::end(values))
+    {}
+
+    StringViewIterator& operator++() {
+        if (_it != _end) {
+            ++_it;
+        }
+
+        return *this;
+    }
+
+    StringViewIterator operator++(int) {
+        StringViewIterator out(*this);
+        ++out;
+        return out;
+    }
+
+    constexpr Element operator*() const {
+        return _it;
+    }
+
+    constexpr Element begin() const {
+        return _begin;
+    }
+
+    constexpr Element end() const {
+        return _end;
+    }
+
+private:
+    Element _it;
+    Element _begin;
+    Element _end;
+};
+
+// static container to allow queries on an array of key<->serialized value pairs
+// both require a linear iterators as input e.g. most commonly - a static array
+// (either a plain [], or an std::array. template should treat both equally)
+
+// single key variant, exact match of the provided string
+struct alignas(8) Setting {
+    using ValueFunc = String(*)();
+
+    Setting() = delete;
+    constexpr Setting(StringView key, ValueFunc func) noexcept :
+        _key(key),
+        _func(func)
+    {}
+
+    constexpr StringView key() const {
+        return _key;
+    }
+
+    String value() const {
+        return _func();
+    }
+
+    bool operator==(const String& key) const {
+        return _key == key;
+    }
+
+    bool operator==(const StringView& key) const {
+        return _key.compareFlash(key);
+    }
+
+    static String findValueFrom(const Setting* begin, const Setting* end, StringView key);
+
+    template <typename T>
+    static String findValueFrom(const T& settings, StringView key) {
+        return findValueFrom(std::begin(settings), std::end(settings), key);
+    }
+
+private:
+    StringView _key;
+    ValueFunc _func;
+};
+
+// 'indexed' variant, for a group of objects under the same prefix with a numeric suffix
+// (suffix range depends on the external 'iota', only known at runtime)
+struct alignas(8) IndexedSetting {
+    using ValueFunc = String(*)(size_t);
+
+    IndexedSetting() = delete;
+    constexpr IndexedSetting(StringView prefix, ValueFunc func) noexcept :
+        _prefix(prefix),
+        _func(func)
+    {}
+
+    String value(size_t id) const {
+        return _func(id);
+    }
+
+    constexpr ValueFunc func() const {
+        return _func;
+    }
+
+    constexpr StringView prefix() const {
+        return _prefix;
+    }
+
+    static bool findSamePrefix(const IndexedSetting* begin, const IndexedSetting* end, StringView key);
+
+    template <typename T>
+    static bool findSamePrefix(const T& settings, StringView key) {
+        return findSamePrefix(std::begin(settings), std::end(settings), key);
+    }
+
+    static String findValueFrom(Iota iota, const IndexedSetting* begin, const IndexedSetting* end, StringView key);
+
+    template <typename T>
+    static String findValueFrom(Iota iota, const T& settings, StringView key) {
+        return findValueFrom(iota, std::begin(settings), std::end(settings), key);
+    }
+
+    template <typename T>
+    static String findValueFrom(size_t size, const T& settings, StringView key) {
+        return findValueFrom(Iota{size}, settings, key);
+    }
+
+private:
+    StringView _prefix;
+    ValueFunc _func;
+};
+
+
+} // namespace query
 } // namespace settings
diff --git a/code/espurna/system.cpp b/code/espurna/system.cpp
index 4a86841a..a9c6c53c 100644
--- a/code/espurna/system.cpp
+++ b/code/espurna/system.cpp
@@ -40,23 +40,48 @@ extern "C" unsigned long adc_rand_noise;
 
 // -----------------------------------------------------------------------------
 
+namespace espurna {
+namespace system {
+namespace settings {
+
+namespace options {
+namespace internal {
+namespace {
+
+alignas(4) static constexpr char None[] PROGMEM = "none";
+alignas(4) static constexpr char Once[] PROGMEM = "once";
+alignas(4) static constexpr char Repeat[] PROGMEM = "repeat";
+
+} // namespace
+} // namespace internal
+
+namespace {
+
+static constexpr ::settings::options::Enumeration<heartbeat::Mode> HeartbeatModeOptions[] PROGMEM {
+    {heartbeat::Mode::None, internal::None},
+    {heartbeat::Mode::Once, internal::Once},
+    {heartbeat::Mode::Repeat, internal::Repeat},
+};
+
+} // namespace
+} // namespace options
+} // namespace settings
+} // namespace system
+} // namespace espurna
+
+// -----------------------------------------------------------------------------
+
 namespace settings {
 namespace internal {
+namespace {
+
+using espurna::system::settings::options::HeartbeatModeOptions;
+
+} // namespace
 
 template <>
 espurna::heartbeat::Mode convert(const String& value) {
-    alignas(4) static constexpr char None[] PROGMEM = "none";
-    alignas(4) static constexpr char Once[] PROGMEM = "once";
-    alignas(4) static constexpr char Repeat[] PROGMEM = "repeat";
-
-    using namespace espurna::heartbeat;
-    constexpr static const EnumOption<Mode> options[] PROGMEM {
-        {Mode::None, None},
-        {Mode::Once, Once},
-        {Mode::Repeat, Repeat},
-    };
-
-    return convert(options, value, Mode::Repeat);
+    return convert(HeartbeatModeOptions, value, espurna::heartbeat::Mode::Repeat);
 }
 
 template <>
@@ -69,6 +94,14 @@ espurna::duration::Milliseconds convert(const String& value) {
     return espurna::duration::Milliseconds(convert<espurna::duration::Milliseconds::rep>(value));
 }
 
+String serialize(espurna::duration::Milliseconds value) {
+    return serialize(value.count());
+}
+
+String serialize(espurna::duration::ClockCycles value) {
+    return serialize(value.count());
+}
+
 template <>
 espurna::duration::Seconds convert(const String& value) {
     return espurna::duration::Seconds(convert<espurna::duration::Seconds::rep>(value));
@@ -113,8 +146,8 @@ void blockingDelay(CoreClock::duration timeout) {
 
 } // namespace time
 
-namespace {
 namespace memory {
+namespace {
 
 // returns 'total stack size' minus 'un-painted area'
 // needs re-painting step, as this never decreases
@@ -144,9 +177,11 @@ decltype(freeHeap()) initialFreeHeap() {
     return value;
 }
 
+}
 } // namespace memory
 
 namespace boot {
+namespace {
 
 String serialize(CustomResetReason reason) {
     const __FlashStringHelper* ptr { nullptr };
@@ -271,10 +306,14 @@ Ticker timer;
 bool flag { true };
 
 } // namespace internal
+}
+
+namespace {
 
 #if SYSTEM_CHECK_ENABLED
 namespace stability {
 namespace build {
+namespace {
 
 constexpr uint8_t ChecksMin { 0 };
 constexpr uint8_t ChecksMax { SYSTEM_CHECK_MAX };
@@ -284,8 +323,11 @@ static_assert(ChecksMin < ChecksMax, "");
 constexpr espurna::duration::Seconds CheckTime { SYSTEM_CHECK_TIME };
 static_assert(CheckTime > espurna::duration::Seconds::min(), "");
 
+} // namespace
 } // namespace build
 
+namespace {
+
 void init() {
     // on cold boot / rst, bumps count to 2 so we don't end up
     // spamming crash recorder in case something goes wrong
@@ -306,6 +348,7 @@ bool check() {
     return internal::flag;
 }
 
+} // namespace
 } // namespace stability
 #endif
 
@@ -331,6 +374,7 @@ void customReason(CustomResetReason reason) {
     internal::persistent_data.reason(reason);
 }
 
+} // namespace
 } // namespace boot
 
 // -----------------------------------------------------------------------------
@@ -338,6 +382,7 @@ void customReason(CustomResetReason reason) {
 // Calculated load average of the loop() as a percentage (notice that this may not be accurate)
 namespace load_average {
 namespace build {
+namespace {
 
 constexpr size_t ValueMin { 0 };
 constexpr size_t ValueMax { 100 };
@@ -345,8 +390,11 @@ constexpr size_t ValueMax { 100 };
 static constexpr espurna::duration::Seconds Interval { LOADAVG_INTERVAL };
 static_assert(Interval <= espurna::duration::Seconds(90), "");
 
+} // namespace
 } // namespace build
 
+namespace {
+
 using TimeSource = espurna::time::SystemClock;
 using Type = unsigned long;
 
@@ -392,8 +440,8 @@ void loop() {
         : 0;
 }
 
-} // namespace load_average
 } // namespace
+} // namespace load_average
 
 // -----------------------------------------------------------------------------
 
@@ -454,13 +502,22 @@ constexpr Mask value() {
 } // namespace build
 
 namespace settings {
+namespace keys {
+namespace {
+
+alignas(4) static constexpr char Mode[] PROGMEM = "hbMode";
+alignas(4) static constexpr char Interval[] PROGMEM = "hbInterval";
+alignas(4) static constexpr char Report[] PROGMEM = "hbReport";
+
+} // namespace
+} // namespace keys
 
 Mode mode() {
-    return getSetting("hbMode", build::mode());
+    return getSetting(keys::Mode, build::mode());
 }
 
 espurna::duration::Seconds interval() {
-    return getSetting("hbInterval", build::interval());
+    return getSetting(keys::Interval, build::interval());
 }
 
 Mask value() {
@@ -468,7 +525,7 @@ Mask value() {
     // first bit as a flag to enable all of the messages
     static constexpr Mask MaskAll { 1 };
 
-    auto value = getSetting("hbReport", build::value());
+    auto value = getSetting(keys::Report, build::value());
     if (value == MaskAll) {
         value = std::numeric_limits<Mask>::max();
     }
@@ -641,10 +698,9 @@ void init() {
 } // namespace
 } // namespace heartbeat
 
-namespace {
-
 #if WEB_SUPPORT
 namespace web {
+namespace {
 
 void onConnected(JsonObject& root) {
     root["hbReport"] = heartbeat::settings::value();
@@ -658,12 +714,14 @@ bool onKeyCheck(const char * key, JsonVariant&) {
     return false;
 }
 
+} // namespace
 } // namespace web
 #endif
 
 // Allow to schedule a reset at the next loop
 // Store reset reason both here and in for the next boot
 namespace internal {
+namespace {
 
 Ticker reset_timer;
 auto reset_reason = CustomResetReason::None;
@@ -673,8 +731,11 @@ void reset(CustomResetReason reason) {
     reset_reason = reason;
 }
 
+} // namespace
 } // namespace internal
 
+namespace {
+
 // raw reboot call, effectively:
 // ```
 // system_restart();
diff --git a/code/espurna/system.h b/code/espurna/system.h
index c8f84b4c..7fbb368b 100644
--- a/code/espurna/system.h
+++ b/code/espurna/system.h
@@ -252,6 +252,15 @@ Mode currentMode();
 } // namespace heartbeat
 } // namespace espurna
 
+namespace settings {
+namespace internal {
+
+String serialize(espurna::duration::Milliseconds);
+String serialize(espurna::duration::ClockCycles);
+
+} // namespace internal
+} // namespace settings
+
 unsigned long systemFreeStack();
 
 HeapStats systemHeapStats();
diff --git a/code/espurna/utils.cpp b/code/espurna/utils.cpp
index 779a7dda..a929b012 100644
--- a/code/espurna/utils.cpp
+++ b/code/espurna/utils.cpp
@@ -289,8 +289,75 @@ char* strnstr(const char* buffer, const char* token, size_t n) {
 
 namespace {
 
-// From a byte array to an hexa char array ("A220EE...", double the size)
+uint32_t parseUnsignedImpl(const String& value, int base) {
+    const char* ptr { value.c_str() };
+    char* endp { nullptr };
 
+    // invalidate the whole string when invalid chars are detected
+    // while this does not return a 'result' type, we can't know
+    // whether 0 was the actual decoded number or not
+    const auto result = strtoul(ptr, &endp, base);
+    if (endp == ptr || endp[0] != '\0') {
+        return 0;
+    }
+
+    return result;
+}
+
+} // namespace
+
+uint32_t parseUnsigned(const String& value, int base) {
+    return parseUnsignedImpl(value, base);
+}
+
+uint32_t parseUnsigned(const String& value) {
+    if (!value.length()) {
+        return 0;
+    }
+
+    int base = 10;
+    if (value.length() > 2) {
+        auto* ptr = value.c_str();
+        if (*ptr == '0') {
+            switch (*(ptr + 1)) {
+            case 'b':
+                base = 2;
+                break;
+            case 'o':
+                base = 8;
+                break;
+            case 'x':
+                base = 16;
+                break;
+            }
+        }
+    }
+
+    return parseUnsignedImpl((base == 10) ? value : value.substring(2), base);
+}
+
+String formatUnsigned(uint32_t value, int base) {
+    constexpr size_t BufferSize { 8 * sizeof(decltype(value)) };
+
+    String result;
+    if (base == 2) {
+        result += "0b";
+    } else if (base == 8) {
+        result += "0o";
+    } else if (base == 16) {
+        result += "0x";
+    }
+
+    char buffer[BufferSize + 1] = {0};
+    ultoa(value, buffer, base);
+    result += buffer;
+
+    return result;
+}
+
+namespace {
+
+// From a byte array to an hexa char array ("A220EE...", double the size)
 template <typename T>
 const uint8_t* hexEncodeImpl(const uint8_t* in_begin, const uint8_t* in_end, T&& callback) {
     static const char base16[] = "0123456789ABCDEF";
@@ -354,7 +421,6 @@ size_t hexEncode(const uint8_t* in, size_t in_size, char* out, size_t out_size)
 }
 
 // From an hexa char array ("A220EE...") to a byte array (half the size)
-
 uint8_t* hexDecode(const char* in_begin, const char* in_end, uint8_t* out_begin, uint8_t* out_end) {
     // We can only return small values (max 'z' aka 122)
     constexpr uint8_t InvalidByte { 255u };
diff --git a/code/espurna/utils.h b/code/espurna/utils.h
index d47c01f8..c1bed3a9 100644
--- a/code/espurna/utils.h
+++ b/code/espurna/utils.h
@@ -52,6 +52,10 @@ uint32_t randomNumber(uint32_t minimum, uint32_t maximum);
 
 double roundTo(double num, unsigned char positions);
 
+uint32_t parseUnsigned(const String&, int base);
+uint32_t parseUnsigned(const String&);
+String formatUnsigned(uint32_t value, int base);
+
 char* hexEncode(const uint8_t* in_begin, const uint8_t* in_end, char* out_begin, char* out_end);
 size_t hexEncode(const uint8_t* in, size_t in_size, char* out, size_t out_size);
 String hexEncode(const uint8_t* begin, const uint8_t* end);
diff --git a/code/espurna/wifi.cpp b/code/espurna/wifi.cpp
index 6df58478..0eeef5c9 100644
--- a/code/espurna/wifi.cpp
+++ b/code/espurna/wifi.cpp
@@ -46,26 +46,74 @@ extern "C" void netif_set_addr(netif* netif, ip4_addr_t*, ip4_addr_t*, ip4_addr_
 // -----------------------------------------------------------------------------
 
 namespace wifi {
-namespace {
 
 using Mac = std::array<uint8_t, 6>;
 
 namespace build {
+namespace {
+
+constexpr float txPower() {
+    return WIFI_OUTPUT_POWER_DBM;
+}
 
 constexpr WiFiSleepType_t sleep() {
     return WIFI_SLEEP_MODE;
 }
 
-constexpr float outputDbm() {
-    return WIFI_OUTPUT_POWER_DBM;
-}
-
-} // namespace build
 } // namespace
+} // namespace build
+
+namespace ap {
+namespace settings {
+namespace options {
+namespace {
+
+using ::settings::options::Enumeration;
+
+alignas(4) static constexpr char Disabled[] PROGMEM = "off";
+alignas(4) static constexpr char Enabled[] PROGMEM = "on";
+alignas(4) static constexpr char Fallback[] PROGMEM = "fallback";
+
+static constexpr Enumeration<wifi::ApMode> ApModeOptions[] PROGMEM {
+    {wifi::ApMode::Disabled, Disabled},
+    {wifi::ApMode::Enabled, Enabled},
+    {wifi::ApMode::Fallback, Fallback},
+};
+
+} // namespace
+} // namespace options
+} // namespace settings
+} // namespace ap
+
+namespace settings {
+namespace options {
+namespace {
+
+using ::settings::options::Enumeration;
+
+alignas(4) static constexpr char None[] PROGMEM = "none";
+alignas(4) static constexpr char Modem[] PROGMEM = "modem";
+alignas(4) static constexpr char Light[] PROGMEM = "light";
+
+static constexpr Enumeration<WiFiSleepType_t> WiFiSleepTypeOptions[] PROGMEM {
+    {WIFI_NONE_SLEEP, None},
+    {WIFI_MODEM_SLEEP, Modem},
+    {WIFI_LIGHT_SLEEP, Light},
+};
+
+} // namespace
+} // namespace options
+} // namespace settings
 } // namespace wifi
 
 namespace settings {
 namespace internal {
+namespace {
+
+using wifi::ap::settings::options::ApModeOptions;
+using wifi::settings::options::WiFiSleepTypeOptions;
+
+} // namespace
 
 template<>
 wifi::StaMode convert(const String& value) {
@@ -74,34 +122,26 @@ wifi::StaMode convert(const String& value) {
         : wifi::StaMode::Disabled;
 }
 
+String serialize(wifi::StaMode mode) {
+    return serialize(mode == wifi::StaMode::Enabled);
+}
+
 template<>
 wifi::ApMode convert(const String& value) {
-    alignas(4) static constexpr char Disabled[] PROGMEM = "off";
-    alignas(4) static constexpr char Enabled[] PROGMEM = "on";
-    alignas(4) static constexpr char Fallback[] PROGMEM = "fallback";
+    return convert(ApModeOptions, value, wifi::ApMode::Fallback);
+}
 
-    constexpr static const EnumOption<wifi::ApMode> options[] PROGMEM {
-        {wifi::ApMode::Disabled, Disabled},
-        {wifi::ApMode::Enabled, Enabled},
-        {wifi::ApMode::Fallback, Fallback},
-    };
-
-    return convert(options, value, wifi::ApMode::Fallback);
+String serialize(wifi::ApMode mode) {
+    return serialize(ApModeOptions, mode);
 }
 
 template <>
 WiFiSleepType_t convert(const String& value) {
-    alignas(4) static constexpr char None[] PROGMEM = "none";
-    alignas(4) static constexpr char Modem[] PROGMEM = "modem";
-    alignas(4) static constexpr char Light[] PROGMEM = "light";
+    return convert(WiFiSleepTypeOptions, value, wifi::build::sleep());
+}
 
-    constexpr static const EnumOption<WiFiSleepType_t> options[] PROGMEM {
-        {WIFI_NONE_SLEEP, None},
-        {WIFI_MODEM_SLEEP, Modem},
-        {WIFI_LIGHT_SLEEP, Light},
-    };
-
-    return convert(options, value, wifi::build::sleep());
+String serialize(WiFiSleepType_t sleep) {
+    return serialize(WiFiSleepTypeOptions, sleep);
 }
 
 template <>
@@ -152,6 +192,24 @@ String serialize(const IPAddress& ip) {
     return ip.isSet() ? ip.toString() : emptyString;
 }
 
+String serialize(wifi::Mac mac) {
+    String out;
+    out.reserve(18);
+
+    bool delim { false };
+    char buffer[3] = {0};
+    for (auto& byte : mac) {
+        hexEncode(&byte, 1, buffer, sizeof(buffer));
+        if (delim) {
+            out += ':';
+        }
+        out += buffer;
+        delim = true;
+    }
+
+    return out;
+}
+
 } // namespace internal
 } // namespace settings
 
@@ -203,7 +261,10 @@ enum class State {
     WaitConnected
 };
 
+} // namespace
+
 namespace internal {
+namespace {
 
 // Module actions are controled in a serialzed manner, when internal loop is done with the
 // current task and is free to take up another one. Allow to toggle OFF for the whole module,
@@ -212,8 +273,11 @@ namespace internal {
 bool enabled { true };
 ActionsQueue actions;
 
+} // namespace
 } // namespace internal
 
+namespace {
+
 uint8_t opmode() {
     return wifi_get_opmode();
 }
@@ -294,7 +358,10 @@ bool wakeup() {
     return false;
 }
 
+} // namespace
+
 namespace debug {
+namespace {
 
 String error(wifi::ScanError error) {
     const __FlashStringHelper* ptr { nullptr };
@@ -317,6 +384,10 @@ String error(wifi::ScanError error) {
     return ptr;
 }
 
+String mac(Mac mac) {
+    return ::settings::internal::serialize(mac);
+}
+
 String ip(const IPAddress& addr) {
     return addr.toString();
 }
@@ -337,24 +408,6 @@ String ip(ip4_addr_t addr) {
     return out;
 }
 
-String mac(const wifi::Mac& mac) {
-    String out;
-    out.reserve(18);
-
-    bool delim { false };
-    char buffer[3] = {0};
-    for (auto& byte : mac) {
-        hexEncode(&byte, 1, buffer, sizeof(buffer));
-        if (delim) {
-            out += ':';
-        }
-        out += buffer;
-        delim = true;
-    }
-
-    return out;
-}
-
 String authmode(AUTH_MODE mode) {
     const __FlashStringHelper* ptr { F("UNKNOWN") };
 
@@ -402,26 +455,55 @@ String opmode(uint8_t mode) {
     return ptr;
 }
 
+} // namespace
 } // namespace debug
 
 namespace settings {
+namespace keys {
+namespace {
 
-void migrate(int version) {
-    if (version < 5) {
-        moveSetting("apmode", "wifiApMode");
-    }
-}
+alignas(4) static constexpr char TxPower[] PROGMEM = "wifiTxPwr";
+alignas(4) static constexpr char Sleep[] PROGMEM = "wifiSleep";
+
+} // namespace
+} // namespace keys
+
+namespace {
 
 float txPower() {
-    return getSetting("wifiTxPwr", wifi::build::outputDbm());
+    return getSetting(keys::TxPower, wifi::build::txPower());
 }
 
 WiFiSleepType_t sleep() {
-    return getSetting("wifiSleep", wifi::build::sleep());
+    return getSetting(keys::Sleep, wifi::build::sleep());
 }
 
+} // namespace
+
+namespace query {
+namespace internal {
+namespace {
+
+#define EXACT_VALUE(NAME, FUNC)\
+String NAME () {\
+    return ::settings::internal::serialize(FUNC());\
+}
+
+#define ID_VALUE(NAME, FUNC)\
+String NAME (size_t id) {\
+    return ::settings::internal::serialize(FUNC(id));\
+}
+
+EXACT_VALUE(sleep, settings::sleep)
+EXACT_VALUE(txPower, settings::txPower)
+
+} // namespace
+} // namespace internal
+} // namespace query
 } // namespace settings
 
+namespace {
+
 // We are guaranteed to have '\0' when <32 b/c the SDK zeroes out the data
 // But, these are byte arrays, not C strings. When ssid_len is available, use it.
 // When not, we are still expecting the <32 arrays to have '\0' at the end and we manually
@@ -715,12 +797,15 @@ private:
 
 using Networks = std::list<Network>;
 
+} // namespace
+
 // -----------------------------------------------------------------------------
 // STATION
 // -----------------------------------------------------------------------------
 
 namespace sta {
 namespace build {
+namespace {
 
 static constexpr size_t NetworksMax { WIFI_MAX_NETWORKS };
 
@@ -777,7 +862,7 @@ const __FlashStringHelper* gateway(size_t index) {
     );
 }
 
-const __FlashStringHelper* mask(size_t index) {
+const __FlashStringHelper* netmask(size_t index) {
     return (
         (index == 0) ? F(WIFI1_MASK) :
         (index == 1) ? F(WIFI2_MASK) :
@@ -817,53 +902,109 @@ constexpr uint8_t channel(size_t index) {
     );
 }
 
+} // namespace
 } // namespace build
 
 namespace settings {
+namespace keys {
+namespace {
+
+alignas(4) static constexpr char Mode[] PROGMEM = "wifiStaMode";
+
+alignas(4) static constexpr char Ssid[] PROGMEM = "ssid";
+alignas(4) static constexpr char Passphrase[] PROGMEM = "pass";
+
+alignas(4) static constexpr char Ip[] PROGMEM = "ip";
+alignas(4) static constexpr char Gateway[] PROGMEM = "gw";
+alignas(4) static constexpr char Netmask[] PROGMEM = "mask";
+alignas(4) static constexpr char Dns[] PROGMEM = "dns";
+
+alignas(4) static constexpr char Bssid[] PROGMEM = "bssid";
+alignas(4) static constexpr char Channel[] PROGMEM = "chan";
+
+} // namespace
+} // namespace keys
+
+namespace {
 
 wifi::StaMode mode() {
-    return getSetting("wifiStaMode", build::mode());
+    return getSetting(keys::Mode, build::mode());
 }
 
 String ssid(size_t index) {
-    return getSetting({"ssid", index}, build::ssid(index));
+    return getSetting({keys::Ssid, index}, build::ssid(index));
 }
 
 String passphrase(size_t index) {
-    return getSetting({"pass", index}, build::passphrase(index));
+    return getSetting({keys::Passphrase, index}, build::passphrase(index));
 }
 
 IPAddress ip(size_t index) {
     return ::settings::internal::convert<IPAddress>(
-        getSetting({"ip", index}, build::ip(index)));
+        getSetting({keys::Ip, index}, build::ip(index)));
 }
 
 IPAddress gateway(size_t index) {
     return ::settings::internal::convert<IPAddress>(
-        getSetting({"gw", index}, build::gateway(index)));
+        getSetting({keys::Gateway, index}, build::gateway(index)));
 }
 
-IPAddress mask(size_t index) {
+IPAddress netmask(size_t index) {
     return ::settings::internal::convert<IPAddress>(
-        getSetting({"mask", index}, build::mask(index)));
+        getSetting({keys::Netmask, index}, build::netmask(index)));
 }
 
 IPAddress dns(size_t index) {
     return ::settings::internal::convert<IPAddress>(
-        getSetting({"dns", index}, build::dns(index)));
+        getSetting({keys::Dns, index}, build::dns(index)));
 }
 
 wifi::Mac bssid(size_t index) {
     return ::settings::internal::convert<wifi::Mac>(
-        getSetting({"bssid", index}, build::bssid(index)));
+        getSetting({keys::Bssid, index}, build::bssid(index)));
 }
 
 int8_t channel(size_t index) {
-    return getSetting({"chan", index}, build::channel(index));
+    return getSetting({keys::Channel, index}, build::channel(index));
 }
 
+} // namespace
+
+namespace query {
+namespace internal {
+namespace {
+
+ID_VALUE(ip, settings::ip)
+ID_VALUE(gateway, settings::gateway)
+ID_VALUE(netmask, settings::netmask)
+ID_VALUE(dns, settings::dns)
+ID_VALUE(bssid, settings::bssid)
+ID_VALUE(channel, settings::channel)
+
+EXACT_VALUE(mode, settings::mode)
+
+} // namespace
+} // namespace internal
+
+namespace {
+
+static constexpr std::array<::settings::query::IndexedSetting, 8> Settings PROGMEM {
+    {{keys::Ssid, settings::ssid},
+     {keys::Passphrase, settings::passphrase},
+     {keys::Ip, internal::ip},
+     {keys::Gateway, internal::gateway},
+     {keys::Netmask, internal::netmask},
+     {keys::Dns, internal::dns},
+     {keys::Bssid, internal::bssid},
+     {keys::Channel, internal::channel}}
+};
+
+} // namespace
+} // namespace query
 } // namespace settings
 
+namespace {
+
 uint8_t channel() {
     return wifi_get_channel();
 }
@@ -887,7 +1028,7 @@ wifi::Networks networks() {
         auto ipSettings = ip.isSet()
             ? wifi::IpSettings{
                 std::move(ip),
-                settings::mask(id),
+                settings::netmask(id),
                 settings::gateway(id),
                 settings::dns(id)}
             : wifi::IpSettings{};
@@ -950,8 +1091,11 @@ wifi::StaNetwork current() {
     return current(config);
 }
 
+} // namespace
+
 #if WIFI_GRATUITOUS_ARP_SUPPORT
 namespace garp {
+namespace {
 namespace build {
 
 static constexpr auto IntervalMin = espurna::duration::Milliseconds { WIFI_GRATUITOUS_ARP_INTERVAL_MIN };
@@ -1025,10 +1169,22 @@ void start(espurna::duration::Milliseconds next) {
     });
 }
 
+} // namespace
 } // namespace garp
 #endif
 
 namespace scan {
+namespace settings {
+namespace keys {
+namespace {
+
+alignas(4) static constexpr char Enabled[] PROGMEM = "wifiScan";
+
+} // namespace
+} // namespace keys
+} // namespace settings
+
+namespace {
 
 using SsidInfosPtr = std::shared_ptr<wifi::SsidInfos>;
 
@@ -1145,8 +1301,11 @@ SsidInfosPtr ssidinfos() {
     return infos;
 }
 
+} // namespace
 } // namespace scan
 
+namespace {
+
 bool enabled() {
     return wifi::opmode() & wifi::OpmodeSta;
 }
@@ -1191,8 +1350,11 @@ void disable() {
     }
 }
 
+} // namespace
+
 namespace connection {
 namespace internal {
+namespace {
 
 struct Task {
     static constexpr size_t SsidMax { sizeof(station_config::ssid) };
@@ -1383,8 +1545,11 @@ bool persist { false };
 using TaskPtr = std::unique_ptr<Task>;
 TaskPtr task;
 
+} // namespace
 } // namespace internal
 
+namespace {
+
 void persist(bool value) {
     internal::persist = value;
 }
@@ -1497,8 +1662,11 @@ bool prepared() {
     return internal::preparedNetworks.size();
 }
 
+} // namespace
 } // namespace connection
 
+namespace {
+
 bool connected() {
     return connection::connected();
 }
@@ -1543,25 +1711,32 @@ void toggle() {
         : wifi::Action::StationConnect);
 }
 
+} // namespace
+
 namespace scan {
 namespace build {
+namespace {
 
 constexpr bool enabled() {
     return 1 == WIFI_SCAN_NETWORKS;
 }
 
+} // namespace
 } // namespace build
 
 namespace settings {
+namespace {
 
 bool enabled() {
-    return getSetting("wifiScan", build::enabled());
+    return getSetting(keys::Enabled, build::enabled());
 }
 
+} // namespace
 } // namespace settings
 
 namespace periodic {
 namespace build {
+namespace {
 
 static constexpr auto Interval = espurna::duration::Milliseconds { WIFI_SCAN_RSSI_CHECK_INTERVAL };
 static constexpr int8_t Checks { WIFI_SCAN_RSSI_CHECKS };
@@ -1570,17 +1745,29 @@ constexpr int8_t threshold() {
     return WIFI_SCAN_RSSI_THRESHOLD;
 }
 
+} // namespace
 } // namespace build
 
 namespace settings {
+namespace keys {
+namespace {
+
+alignas(4) static constexpr char Threshold[] PROGMEM = "wifiScanRssi";
+
+} // namespace
+} // namespace keys
+
+namespace {
 
 int8_t threshold() {
-    return getSetting("wifiScanRssi", build::threshold());
+    return getSetting(FPSTR(keys::Threshold), build::threshold());
 }
 
+} // namespace
 } // namespace settings
 
 namespace internal {
+namespace {
 
 int8_t threshold { build::threshold() };
 int8_t counter { build::Checks };
@@ -1616,8 +1803,11 @@ void stop() {
     timer.detach();
 }
 
+} // namespace
 } // namespace internal
 
+namespace {
+
 void threshold(int8_t value) {
     internal::threshold = value;
 }
@@ -1639,10 +1829,12 @@ bool check() {
     return false;
 }
 
+} // namespace
 } // namespace periodic
 } // namespace scan
 
 namespace connection {
+namespace {
 
 // After scan attempt, generate a new networks list based on the results sorted by the rssi value.
 // For the initial connection, add every matching network with the scan result bssid and channel info.
@@ -1698,8 +1890,11 @@ bool scanProcessResults() {
     return scanProcessResults(0);
 }
 
+} // namespace
 } // namespace connection
 
+namespace {
+
 void configure() {
     auto enabled = (wifi::StaMode::Enabled == wifi::sta::settings::mode());
     connection::persist(enabled);
@@ -1720,6 +1915,7 @@ void configure() {
 #endif
 }
 
+} // namespace
 } // namespace sta
 
 // -----------------------------------------------------------------------------
@@ -1728,6 +1924,7 @@ void configure() {
 
 namespace ap {
 namespace build {
+namespace {
 
 static constexpr size_t SsidMax { sizeof(softap_config::ssid) };
 
@@ -1765,42 +1962,73 @@ constexpr uint8_t channel() {
     return WIFI_AP_CHANNEL;
 }
 
+} // namespace
 } // namespace build
 
 namespace settings {
+namespace keys {
+namespace {
+
+alignas(4) static constexpr char Mode[] PROGMEM = "wifiApMode";
+
+alignas(4) static constexpr char Ssid[] PROGMEM = "wifiApSsid";
+alignas(4) static constexpr char Passphrase[] PROGMEM = "wifiApPass";
+
+alignas(4) static constexpr char Channel[] PROGMEM = "wifiApChan";
+
+[[gnu::unused]] alignas(4) static constexpr char Captive[] PROGMEM = "wifiApCaptive";
+
+} // namespace
+} // namespace keys
+
+namespace {
+
+wifi::ApMode mode() {
+    return getSetting(FPSTR(keys::Mode), build::mode());
+}
 
 String defaultSsid() {
     return getIdentifier();
 }
 
 String ssid() {
-    return getSetting("wifiApSsid", build::hasSsid()
+    return getSetting(FPSTR(keys::Ssid), build::hasSsid()
         ? build::ssid()
         : getHostname());
 }
 
-wifi::ApMode mode() {
-    return getSetting("wifiApMode", build::mode());
-}
-
 String passphrase() {
-    return getSetting("wifiApPass", build::hasPassphrase()
+    return getSetting(FPSTR(keys::Passphrase), build::hasPassphrase()
         ? build::passphrase()
         : getAdminPass());
 }
 
-uint8_t channel() {
-    return getSetting("wifiApChannel", build::channel());
+int8_t channel() {
+    return getSetting(FPSTR(keys::Channel), build::channel());
 }
 
 [[gnu::unused]]
 bool captive() {
-    return getSetting("wifiApCaptive", build::captive());
+    return getSetting(FPSTR(keys::Captive), build::captive());
 }
 
+namespace query {
+namespace internal {
+
+EXACT_VALUE(captive, wifi::ap::settings::captive)
+EXACT_VALUE(channel, wifi::ap::settings::channel)
+EXACT_VALUE(mode, wifi::ap::settings::mode)
+
+#undef ID_VALUE
+#undef EXACT_VALUE
+
+} // namespace internal
+} // namespace query
+} // namespace
 } // namespace settings
 
 namespace internal {
+namespace {
 
 #if WIFI_AP_CAPTIVE_SUPPORT
 bool captive { build::captive() };
@@ -1828,8 +2056,11 @@ void start(String&& defaultSsid, String&& ssid, String&& passphrase, uint8_t cha
     WiFi.softAP(apSsid, apPass, channel, build::Hidden, build::ConnectionsMax);
 }
 
+} // namespace
 } // namespace internal
 
+namespace {
+
 #if WIFI_AP_CAPTIVE_SUPPORT
 
 void captive(bool value) {
@@ -1912,7 +2143,10 @@ size_t stations() {
     return WiFi.softAPgetStationNum();
 }
 
+} // namespace
+
 namespace fallback {
+namespace {
 namespace build {
 
 constexpr auto Timeout = espurna::duration::Milliseconds { WIFI_FALLBACK_TIMEOUT };
@@ -1962,8 +2196,11 @@ void check() {
     schedule();
 }
 
+} // namespace
 } // namespace fallback
 
+namespace {
+
 void configure() {
     auto current = settings::mode();
     if (wifi::ApMode::Fallback == current) {
@@ -1981,6 +2218,7 @@ void configure() {
 #endif
 }
 
+}
 } // namespace ap
 
 // -----------------------------------------------------------------------------
@@ -1988,6 +2226,66 @@ void configure() {
 // -----------------------------------------------------------------------------
 
 namespace settings {
+namespace query {
+namespace {
+
+static constexpr std::array<::settings::query::Setting, 8> Settings PROGMEM {
+    {{wifi::ap::settings::keys::Ssid, wifi::ap::settings::ssid},
+     {wifi::ap::settings::keys::Passphrase, wifi::ap::settings::passphrase},
+     {wifi::ap::settings::keys::Captive, wifi::ap::settings::query::internal::captive},
+     {wifi::ap::settings::keys::Channel, wifi::ap::settings::query::internal::channel},
+     {wifi::ap::settings::keys::Mode, wifi::ap::settings::query::internal::mode},
+     {wifi::sta::settings::keys::Mode, wifi::sta::settings::query::internal::mode},
+     {wifi::settings::keys::TxPower, ::wifi::settings::query::internal::txPower},
+     {wifi::settings::keys::Sleep, ::wifi::settings::query::internal::sleep}}
+};
+
+// indexed settings for 'sta' connections
+bool checkIndexedPrefix(::settings::StringView key) {
+    return ::settings::query::IndexedSetting::findSamePrefix(
+        ::wifi::sta::settings::query::Settings, key);
+}
+
+// generic 'ap' and 'modem' configuration
+bool checkExactPrefix(::settings::StringView key) {
+    alignas(4) static constexpr char Prefix[] PROGMEM = "wifi";
+    if (::settings::query::samePrefix(key, Prefix)) {
+        return true;
+    }
+
+    return false;
+}
+
+String findIndexedValueFrom(::settings::StringView key) {
+    using ::settings::query::IndexedSetting;
+    return IndexedSetting::findValueFrom(
+        wifi::sta::countNetworks(),
+        wifi::sta::settings::query::Settings, key);
+}
+
+String findValueFrom(::settings::StringView key) {
+    using ::settings::query::Setting;
+    return Setting::findValueFrom(Settings, key);
+}
+
+void setup() {
+    // TODO: small implementation detail - when searching, these
+    // should be registered like this so the 'exact' is processed first
+    settingsRegisterQueryHandler({
+        .check = checkIndexedPrefix,
+        .get = findIndexedValueFrom
+    });
+
+    settingsRegisterQueryHandler({
+        .check = checkExactPrefix,
+        .get = findValueFrom
+    });
+}
+
+} // namespace
+} // namespace query
+
+namespace {
 
 void configure() {
     wifi::ap::configure();
@@ -1997,6 +2295,7 @@ void configure() {
     WiFi.setOutputPower(wifi::settings::txPower());
 }
 
+} // namespace
 } // namespace settings
 
 // -----------------------------------------------------------------------------
@@ -2004,8 +2303,8 @@ void configure() {
 // -----------------------------------------------------------------------------
 
 #if TERMINAL_SUPPORT
-
 namespace terminal {
+namespace {
 
 void init() {
 
@@ -2132,8 +2431,8 @@ void init() {
 
 }
 
+} // namespace
 } // namespace terminal
-
 #endif
 
 // -----------------------------------------------------------------------------
@@ -2141,58 +2440,34 @@ void init() {
 // -----------------------------------------------------------------------------
 
 namespace web {
+namespace {
 
 #if WEB_SUPPORT
 
-bool onKeyCheck(const char * key, JsonVariant&) {
-    if (strncmp(key, "wifi", 4) == 0) return true;
-    if (strncmp(key, "ssid", 4) == 0) return true;
-    if (strncmp(key, "pass", 4) == 0) return true;
-    if (strncmp(key, "ip", 2) == 0) return true;
-    if (strncmp(key, "gw", 2) == 0) return true;
-    if (strncmp(key, "mask", 4) == 0) return true;
-    if (strncmp(key, "dns", 3) == 0) return true;
-    if (strncmp(key, "bssid", 5) == 0) return true;
-    if (strncmp(key, "chan", 4) == 0) return true;
-    return false;
-}
-
 void onConnected(JsonObject& root) {
-    root["wifiScan"] = wifi::sta::scan::settings::enabled();
-    root["wifiScanRssi"] = wifi::sta::scan::periodic::settings::threshold();
+    root[FPSTR(sta::scan::settings::keys::Enabled)] =
+        wifi::sta::scan::settings::enabled();
+    root[FPSTR(wifi::sta::scan::periodic::settings::keys::Threshold)] =
+        wifi::sta::scan::periodic::settings::threshold();
 
-    root["wifiApSsid"] = wifi::ap::settings::ssid();
-    root["wifiApPass"] = wifi::ap::settings::passphrase();
+    root[FPSTR(wifi::ap::settings::keys::Ssid)] =
+        wifi::ap::settings::ssid();
+    root[FPSTR(wifi::ap::settings::keys::Passphrase)] =
+        wifi::ap::settings::passphrase();
 
-    ::web::ws::EnumerableConfig config{root, F("wifiConfig")};
-
-    // TODO: notice that with the current model, *deleting* from settings or webui
-    //       will restore factory defaults and on the next reload if the index was not replaced
-    config(F("networks"), wifi::sta::countNetworks(), {
-        {F("ssid"), [](JsonArray& out, size_t index) {
-            out.add(wifi::sta::settings::ssid(index));
-        }},
-        {F("pass"), [](JsonArray& out, size_t index) {
-            out.add(wifi::sta::settings::passphrase(index));
-        }},
-        {F("ip"), [](JsonArray& out, size_t index) {
-            out.add(::settings::internal::serialize(wifi::sta::settings::ip(index)));
-        }},
-        {F("gw"), [](JsonArray& out, size_t index) {
-            out.add(::settings::internal::serialize(wifi::sta::settings::gateway(index)));
-        }},
-        {F("mask"), [](JsonArray& out, size_t index) {
-            out.add(::settings::internal::serialize(wifi::sta::settings::mask(index)));
-        }},
-        {F("dns"), [](JsonArray& out, size_t index) {
-            out.add(::settings::internal::serialize(wifi::sta::settings::dns(index)));
-        }},
-    });
+    ::web::ws::EnumerableConfig config{root, STRING_VIEW("wifiConfig")};
+    config(STRING_VIEW("networks"), wifi::sta::countNetworks(), wifi::sta::settings::query::Settings);
 
     auto& container = config.root();
     container[F("max")] = wifi::sta::build::NetworksMax;
 }
 
+bool onKeyCheck(const char* key, JsonVariant&) {
+    const auto key_view = ::settings::StringView { key };
+    return wifi::settings::query::checkExactPrefix(key_view)
+        || wifi::settings::query::checkIndexedPrefix(key_view);
+}
+
 void onScan(uint32_t client_id) {
     if (wifi::sta::scanning()) {
         return;
@@ -2227,13 +2502,27 @@ void onAction(uint32_t client_id, const char* action, JsonObject&) {
 
 #endif
 
+} // namespace
 } // namespace web
 
 // -----------------------------------------------------------------------------
 // INITIALIZATION
 // -----------------------------------------------------------------------------
 
+namespace settings {
+namespace {
+
+void migrate(int version) {
+    if (version < 5) {
+        moveSetting(F("apmode"), ap::settings::keys::Mode);
+    }
+}
+
+} // namespace
+} // namespace settings
+
 namespace debug {
+namespace {
 
 [[gnu::unused]]
 String event(wifi::Event value) {
@@ -2313,9 +2602,11 @@ const char* state(wifi::State value) {
     return "";
 }
 
+} // namespace
 } // namespace debug
 
 namespace internal {
+namespace {
 
 // STA + AP FALLBACK:
 // - try connection
@@ -2660,8 +2951,8 @@ void init() {
     wifi::sta::init();
 }
 
-} // namespace internal
 } // namespace
+} // namespace internal
 } // namespace wifi
 
 // -----------------------------------------------------------------------------
@@ -2738,6 +3029,7 @@ void wifiSetup() {
 
     migrateVersion(wifi::settings::migrate);
     wifi::settings::configure();
+    wifi::settings::query::setup();
 
 #if SYSTEM_CHECK_ENABLED
     if (!systemCheck()) {
diff --git a/code/espurna/ws.cpp b/code/espurna/ws.cpp
index ff6c6103..2175e138 100644
--- a/code/espurna/ws.cpp
+++ b/code/espurna/ws.cpp
@@ -32,42 +32,29 @@ namespace ws {
 namespace internal {
 namespace {
 
-template <typename T>
-void populateSchema(JsonArray& schema, const T& pairs) {
-    for (auto& pair : pairs) {
-        schema.add(pair.key);
-    }
-}
-
-template <typename T>
-void populateEntry(JsonArray& entry, const T& pairs, size_t index) {
-    for (auto& pair : pairs) {
-        pair.callback(entry, index);
-    }
-}
+alignas(4) static constexpr char SchemaKey[] PROGMEM = "schema";
 
 } // namespace
 } // namespace internal
 
-EnumerableConfig::EnumerableConfig(JsonObject& root, const __FlashStringHelper* name) :
-    _root(root.createNestedObject(name))
+EnumerableConfig::EnumerableConfig(JsonObject& root, Name name) :
+    _root(root.createNestedObject(FPSTR(name.c_str())))
 {}
 
-void EnumerableConfig::operator()(const __FlashStringHelper* name, settings::Iota iota, Check check, Pairs&& pairs)
-{
-    if (!iota) {
-        return;
-    }
+void EnumerableConfig::operator()(Name name, ::settings::Iota iota, Check check, Setting* begin, Setting* end) {
+    if (!_root.containsKey(FPSTR(internal::SchemaKey))) {
+        JsonArray& schema = _root.createNestedArray(FPSTR(internal::SchemaKey));
+        for (auto it = begin; it != end; ++it) {
+            schema.add(FPSTR((*it).prefix().c_str()));
+        }
 
-    if (!_root.containsKey(FPSTR(SchemaKey))) {
-        JsonArray& schema = _root.createNestedArray(FPSTR(SchemaKey));
-        internal::populateSchema(schema, pairs);
-
-        JsonArray& entries = _root.createNestedArray(name);
+        JsonArray& entries = _root.createNestedArray(FPSTR(name.c_str()));
         do {
             if (!check || check(*iota)) {
                 JsonArray& entry = entries.createNestedArray();
-                internal::populateEntry(entry, pairs, (*iota));
+                for (auto it = begin; it != end; ++it) {
+                    entry.add((*it).value(*iota));
+                }
             }
 
             ++iota;
@@ -75,8 +62,33 @@ void EnumerableConfig::operator()(const __FlashStringHelper* name, settings::Iot
     }
 }
 
-alignas(4) const char EnumerableConfig::SchemaKey[] PROGMEM = "schema";
-static_assert(alignof(EnumerableConfig::SchemaKey) == 4, "");
+EnumerablePayload::EnumerablePayload(JsonObject& root, Name name) :
+    _root(root.createNestedObject(FPSTR(name.c_str())))
+{}
+
+void EnumerablePayload::operator()(Name name, settings::Iota iota, Check check, Pairs&& pairs) {
+    if (!_root.containsKey(FPSTR(internal::SchemaKey))) {
+        JsonArray& schema = _root.createNestedArray(FPSTR(internal::SchemaKey));
+
+        const auto begin = std::begin(pairs);
+        const auto end = std::end(pairs);
+        for (auto it = begin; it != end; ++it) {
+            schema.add(FPSTR((*it).name.c_str()));
+        }
+
+        JsonArray& entries = _root.createNestedArray(FPSTR(name.c_str()));
+        do {
+            if (!check || check(*iota)) {
+                JsonArray& entry = entries.createNestedArray();
+                for (auto it = begin; it != end; ++it) {
+                    (*it).generate(entry, *iota);
+                }
+            }
+
+            ++iota;
+        } while (iota);
+    }
+}
 
 } // namespace ws
 } // namespace web
diff --git a/code/espurna/ws_utils.h b/code/espurna/ws_utils.h
index 186d0c0f..bf26de90 100644
--- a/code/espurna/ws_utils.h
+++ b/code/espurna/ws_utils.h
@@ -45,33 +45,61 @@ Copyright (C) 2019-2021 by Maxim Prokhorov <prokhorov dot max at outlook dot com
 namespace web {
 namespace ws {
 
-// TODO: use `const char*', but somehow force the arduinojson layer to *always* use flash funcs for reading them?
-// TODO: try to minimize the ROM by implementing things in .cpp
-// TODO: generic templated funcs instead of pointers? also, ROM...
-
-struct EnumerableConfig {
-    alignas(4)
-    static const char SchemaKey[];
-
+// generic way to set up iterable payload with a schema
+struct EnumerablePayload {
     using Check = bool(*)(size_t);
-    using Callback = void(*)(JsonArray&, size_t);
+    using Generator = void(*)(JsonArray&, size_t);
+    using Name = ::settings::StringView;
 
     struct Pair {
-        const __FlashStringHelper* key;
-        Callback callback;
+        Name name;
+        Generator generate;
     };
 
     using Pairs = std::initializer_list<Pair>;
 
-    EnumerableConfig(JsonObject& root, const __FlashStringHelper* name);
-    void operator()(const __FlashStringHelper* name, ::settings::Iota, Check, Pairs&&);
+    EnumerablePayload(JsonObject& root, Name name);
 
-    void operator()(const __FlashStringHelper* name, ::settings::Iota iota, Pairs&& pairs) {
-        (*this)(name, iota, nullptr, std::move(pairs));
+    void operator()(Name name, ::settings::Iota iota, Check, Pairs&&);
+    void operator()(Name name, size_t iota_end, Pairs&& pairs) {
+        (*this)(name, ::settings::Iota { iota_end }, nullptr, std::move(pairs));
     }
 
-    void operator()(const __FlashStringHelper* name, size_t end, Pairs&& pairs) {
-        (*this)(name, ::settings::Iota{end}, nullptr, std::move(pairs));
+    JsonObject& root() {
+        return _root;
+    }
+
+private:
+    JsonObject& _root;
+};
+
+// payload generator for IndexedSettings
+struct EnumerableConfig {
+    using Check = bool(*)(size_t);
+
+    using Name = ::settings::StringView;
+    using Setting = const ::settings::query::IndexedSetting;
+
+    EnumerableConfig(JsonObject& root, Name name);
+
+    void operator()(Name name, ::settings::Iota iota, Check check, Setting* begin, Setting* end);
+    void operator()(Name name, ::settings::Iota iota, Setting* begin, Setting* end) {
+        (*this)(name, iota, nullptr, begin, end);
+    }
+
+    template <typename T>
+    void operator()(Name name, ::settings::Iota iota, T&& settings) {
+        (*this)(name, iota, std::begin(settings), std::end(settings));
+    }
+
+    template <typename T>
+    void operator()(Name name, size_t iota_end, T&& settings) {
+        (*this)(name, ::settings::Iota{iota_end}, std::forward<T>(settings));
+    }
+
+    template <typename T>
+    void operator()(Name name, size_t iota_end, Check check, T&& settings) {
+        (*this)(name, ::settings::Iota{iota_end}, check, std::begin(settings), std::end(settings));
     }
 
     JsonObject& root() {
diff --git a/code/html/custom.js b/code/html/custom.js
index 56de7335..f7bd6fa7 100644
--- a/code/html/custom.js
+++ b/code/html/custom.js
@@ -1531,7 +1531,7 @@ function initRelayToggle(id, cfg) {
     let name = line.querySelector("span[data-key='relayName']");
     name.textContent = cfg.relayName;
     name.dataset["id"] = id;
-    name.setAttribute("title", cfg.relayDesc);
+    name.setAttribute("title", cfg.relayProv);
 
     let realId = "relay".concat(id);
 
@@ -2446,7 +2446,7 @@ function processData(data) {
 
                 relays.push({
                     "id": id,
-                    "name": `${cfg.relayName} (${cfg.relayDesc})`
+                    "name": `${cfg.relayName} (${cfg.relayProv})`
                 });
 
                 initRelayToggle(id, cfg);