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);