Skip to content

A Hardware Hacking Tool with Web-Based CLI That Speaks Every Protocol

65.8 KB
Raw Blame
#pragma once
#include <vector>
#include <string>

// =============================================================
#ifndef UART_AT_EMOJI
  #define UART_AT_EMOJI 1
#endif
#if UART_AT_EMOJI
  #define E(x) x
#else
  #define E(x) ""
#endif

#ifndef AT_COUNT_OF
  #define AT_COUNT_OF(a) (sizeof(a)/sizeof((a)[0]))
#endif
#ifndef AT_NOARGS
  #define AT_NOARGS nullptr, 0
#endif
#ifndef AT_ACTION_OF
    #define AT_ACTIONS_OF(arr) AtActionSlice{ (arr), AT_COUNT_OF(arr) }
#endif

// =============================================================

enum class AtStandard { Hayes, ThreeGPP, SIMCom, Quectel };

enum class AtArgType {
    String,     // free text
    Uint,       // unsigned integer
    Int,        // signed integer
    Bool01,     // 0/1
    Phone,      // +33....
    HexBytes,   // "01 AA 03 ..."
    Choice,     // must be in 'choices' (pipe-separated)
    Regex       // must match 'pattern'
};

struct AtActionArg {
    const char* name;           // prompt label
    bool        required;
    const char* defaultValue;   // default if user enters empty (optional)
    const char* hint;           // help text / example

    // typing + optional constraints
    AtArgType   type;
    long long   minValue;
    long long   maxValue;
    const char* choices;
    const char* pattern;
};

struct AtActionItem {
    const char*  emoji;
    const char*  label;
    const char*  command;
    AtStandard   standard;
    const char*  example;
    bool         destructive;
    const AtActionArg* args;
    size_t       args_count;
};

enum class AtMode {
    Config, Info, SimPin, Network, Calls, Sms, Phonebook, Ussd, Data, TimeClock,
    TcpIp_Vendor, Http_Vendor, Gnss_Vendor, Lora, Audio, Power, Hardware, Mqtt, Files
};

struct AtModeOption {
    const char* emoji;
    const char* name;
    AtMode      mode;
};


struct AtActionSlice {
    const AtActionItem* data;
    std::size_t         size;
};

// ================== Modes ==================

inline constexpr AtModeOption kAtModes[] = {
    { E("🔧"), "Config",                 AtMode::Config },
    { E("📌"), "Info",                   AtMode::Info },
    { E("🔐"), "SIM & PIN",               AtMode::SimPin },
    { E("📶"), "Telephony Network",       AtMode::Network },
    { E("📞"), "Calls",                   AtMode::Calls },
    { E("📩"), "SMS",                    AtMode::Sms },
    { E("📒"), "Phonebook",               AtMode::Phonebook },
    { E("💱"), "USSD",                    AtMode::Ussd },
    { E("🌐"), "Data (PDP)",              AtMode::Data },
    { E("⏰"), "Time & Clock",            AtMode::TimeClock },
    { E("🌍"), "Internet TCP/IP",         AtMode::TcpIp_Vendor },
    { E("🔒"), "HTTP(S)",                AtMode::Http_Vendor },
    { E("🧭"), "GNSS/GPS",                AtMode::Gnss_Vendor },
    { E("📡"), "LoRa / LoRaWAN",          AtMode::Lora },
    { E("🔈"), "Audio",                   AtMode::Audio },
    { E("🔋"), "Power / PSM",             AtMode::Power },
    { E("🧰"), "Hardware I/O",            AtMode::Hardware },
    { E("🌪️"), "MQTT",                   AtMode::Mqtt },
    { E("📁"), "File Storage",            AtMode::Files },
};
inline constexpr size_t kAtModesCount = AT_COUNT_OF(kAtModes);


// ================== Actions per mode ==================

// CONFIG (universal)
inline constexpr AtActionArg kArgs_DeepSleep[] = {
  { "Duration (ms)", true, "1000", "sleep time (module-dependent)",
    AtArgType::Uint, 1, 86400000, nullptr, nullptr }
};

inline constexpr AtActionArg kArgs_UartCommon[] = {
  { "Baud",      true, "115200", nullptr,               AtArgType::Uint,   1200, 921600, nullptr, nullptr },
  { "Data bits", true, "8",      "5/6/7/8",             AtArgType::Choice, 0,    0,      "5|6|7|8", nullptr },
  { "Stop bits", true, "1",      "1/2",                 AtArgType::Choice, 0,    0,      "1|2",    nullptr },
  { "Parity",    true, "0",      "0=None,1=Odd,2=Even", AtArgType::Choice, 0,    0,      "0|1|2",  nullptr },
  { "FlowCtl",   true, "0",      "0=off,1=on",          AtArgType::Choice, 0,    0,      "0|1",    nullptr }
};

inline constexpr AtActionArg kArgs_SleepMode[] = {
  { "Mode", true, "1", "0=off,1=light,2=modem (module-dep.)",
    AtArgType::Choice, 0, 0, "0|1|2", nullptr }
};

inline constexpr AtActionArg kArgs_RfTxPower[] = {
  { "Level", true, "78", "module-dependent", AtArgType::Uint, 0, 100, nullptr, nullptr }
};

inline constexpr AtActionArg kArgs_BoolEnable[] = {
  { "Enable", true, "1", "0/1", AtArgType::Bool01, 0, 0, nullptr, nullptr }
};

inline constexpr AtActionArg kArgs_Ipr[] = {
  { "Baud rate", true, "115200", "9600 / 19200 / 115200 ...",
    AtArgType::Uint, 1200, 921600, nullptr, nullptr }
};

inline constexpr AtActionArg kArgs_Cmee[] = {
  { "Mode", true, "2", "0=off,1=basic,2=verbose",
    AtArgType::Choice, 0, 0, "0|1|2", nullptr }
};

inline constexpr AtActionArg kArgs_Cscs[] = {
  { "Charset", true, "GSM", "GSM/IRA/UCS2",
    AtArgType::Choice, 0, 0, "GSM|IRA|UCS2", nullptr }
};

inline constexpr AtActionArg kArgs_Ifc[] = {
  { "RX flow", true, "2", "0=off,1=hw,2=sw", AtArgType::Choice, 0, 0, "0|1|2", nullptr },
  { "TX flow", true, "2", "0=off,1=hw,2=sw", AtArgType::Choice, 0, 0, "0|1|2", nullptr }
};

inline constexpr AtActionArg kArgs_Profile01[] = {
  { "Profile", true, "1", "0 or 1", AtArgType::Choice, 0, 0, "0|1", nullptr }
};

inline constexpr AtActionArg kArgs_Quiet[] = {
  { "Quiet", true, "0", "0=off,1=on", AtArgType::Choice, 0, 0, "0|1", nullptr }
};

inline constexpr AtActionArg kArgs_Verbose[] = {
  { "Mode", true, "1", "0=numeric,1=verbose", AtArgType::Choice, 0, 0, "0|1", nullptr }
};

inline constexpr AtActionArg kArgs_DcdUsage[] = {
  { "Mode", true, "1", "0=always ON,1=follows carrier", AtArgType::Choice, 0, 0, "0|1", nullptr }
};

inline constexpr AtActionArg kArgs_DtrBehaviour[] = {
  { "Mode", true, "2", "0=ignore,2=hang up+CMD", AtArgType::Choice, 0, 0, "0|2", nullptr }
};

inline constexpr AtActionArg kArgs_Icf[] = {
  { "Format", true, "3", "module-specific", AtArgType::Uint, 0, 10, nullptr, nullptr },
  { "Parity", true, "0", "0=none,1=odd,2=even (module)", AtArgType::Uint, 0, 5, nullptr, nullptr }
};

// CONFIG (universal)
inline constexpr AtActionItem kAtConfigActions[] = {
    { E("⚡"), "Test communication", "AT",          AtStandard::Hayes,    "AT",                   false, AT_NOARGS},
    { E("🔈"), "Enable/Disable echo","ATE",         AtStandard::Hayes,    "ATE",                  false, AT_NOARGS},
    { E("🔇"), "Disable echo",       "ATE0",        AtStandard::Hayes,    "ATE0",                 false, AT_NOARGS},
    { E("🔊"), "Enable echo",        "ATE1",        AtStandard::Hayes,    "ATE1",                 false, AT_NOARGS},
    { E("🔄"), "Restart module",     "AT+RST",      AtStandard::Hayes,    "AT+RST",               false, AT_NOARGS},

    { E("💤"), "Deep sleep",         "AT+GSLP=%1",  AtStandard::Hayes,    "AT+GSLP=1000",         false,
      kArgs_DeepSleep, AT_COUNT_OF(kArgs_DeepSleep) },

    { E("🧼"), "Factory reset (ESP-AT)","AT+RESTORE", AtStandard::Hayes,  "AT+RESTORE",           true,  AT_NOARGS},

    // UART configuration (ESP-AT)
    { E("🔧"), "UART config (deprecated)", "AT+UART=%1,%2,%3,%4,%5",
      AtStandard::Hayes, "AT+UART=115200,8,1,0,0", false,
      kArgs_UartCommon, AT_COUNT_OF(kArgs_UartCommon) },

    { E("🔧"), "UART current (no save)", "AT+UART_CUR=%1,%2,%3,%4,%5",
      AtStandard::Hayes, "AT+UART_CUR=115200,8,1,0,0", false,
      kArgs_UartCommon, AT_COUNT_OF(kArgs_UartCommon) },

    { E("🔧"), "UART default (save)", "AT+UART_DEF=%1,%2,%3,%4,%5",
      AtStandard::Hayes, "AT+UART_DEF=115200,8,1,0,0", false,
      kArgs_UartCommon, AT_COUNT_OF(kArgs_UartCommon) },

    { E("🌙"), "Sleep mode",          "AT+SLEEP=%1", AtStandard::Hayes,   "AT+SLEEP=1",           false,
      kArgs_SleepMode, AT_COUNT_OF(kArgs_SleepMode) },

    { E("📶"), "Set RF TX power",     "AT+RFPOWER=%1", AtStandard::Hayes, "AT+RFPOWER=78",        false,
      kArgs_RfTxPower, AT_COUNT_OF(kArgs_RfTxPower) },

    { E("🔌"), "RF power by VDD",     "AT+RFVDD=%1", AtStandard::Hayes,   "AT+RFVDD=1",           false,
      kArgs_BoolEnable, AT_COUNT_OF(kArgs_BoolEnable) },

    { E("⚡"), "Soft reset (profile)","ATZ",        AtStandard::Hayes,   "ATZ",                  false, AT_NOARGS},
    { E("🏭"), "Factory defaults",    "AT&F",        AtStandard::Hayes,   "AT&F",                 true,  AT_NOARGS},
    { E("💾"), "Save profile",        "AT&W",        AtStandard::Hayes,   "AT&W",                 false, AT_NOARGS},

    { E("⏩"), "Set baud rate",       "AT+IPR=%1",   AtStandard::ThreeGPP,"AT+IPR=115200",        false,
      kArgs_Ipr, AT_COUNT_OF(kArgs_Ipr) },

    { E("🧩"), "Verbose errors",      "AT+CMEE=%1",  AtStandard::ThreeGPP,"AT+CMEE=2",            false,
      kArgs_Cmee, AT_COUNT_OF(kArgs_Cmee) },

    { E("🔤"), "Char set",            "AT+CSCS=\"%1\"", AtStandard::ThreeGPP, "AT+CSCS=\"GSM\"",  false,
      kArgs_Cscs, AT_COUNT_OF(kArgs_Cscs) },

    { E("🪛"), "Flow control",       "AT+IFC=%1,%2", AtStandard::ThreeGPP, "AT+IFC=2,2",         false,
      kArgs_Ifc, AT_COUNT_OF(kArgs_Ifc) },

    { E("🔍"), "View active config",  "AT&V",        AtStandard::Hayes,   "AT&V",                 false, AT_NOARGS},

    { E("🧭"), "Power-up profile",    "AT&Y%1",      AtStandard::Hayes,   "AT&Y1",                false,
      kArgs_Profile01, AT_COUNT_OF(kArgs_Profile01) },

    { E("🤫"), "Suppress result codes","ATQ%1",      AtStandard::Hayes,   "ATQ0",                 false,
      kArgs_Quiet, AT_COUNT_OF(kArgs_Quiet) },

    { E("🗨️"), "Response format",    "ATV%1",       AtStandard::Hayes,   "ATV1",                 false,
      kArgs_Verbose, AT_COUNT_OF(kArgs_Verbose) },

    { E("📎"), "DCD usage",           "AT&C%1",      AtStandard::Hayes,   "AT&C1",                false,
      kArgs_DcdUsage, AT_COUNT_OF(kArgs_DcdUsage) },

    { E("🗨️"), "DTR behaviour",      "AT&D%1",      AtStandard::Hayes,   "AT&D2",                false,
      kArgs_DtrBehaviour, AT_COUNT_OF(kArgs_DtrBehaviour) },

    { E("🧩"), "Char framing (ICF)",   "AT+ICF=%1,%2",AtStandard::ThreeGPP,"AT+ICF=3,1",          false,
      kArgs_Icf, AT_COUNT_OF(kArgs_Icf) },
};
inline constexpr size_t kAtConfigActionsCount =
    AT_COUNT_OF(kAtConfigActions);

// INFO (universal)
inline constexpr AtActionItem kAtInfoActions[] = {
    { E("📌"), "Module info",           "ATI",     AtStandard::Hayes,    "ATI",     false, AT_NOARGS},
    { E("📎"), "Manufacturer",          "AT+GMI",  AtStandard::Hayes,    "AT+GMI",  false, AT_NOARGS},
    { E("🔧"),  "Model",                 "AT+GMM",  AtStandard::Hayes,    "AT+GMM",  false, AT_NOARGS},
    { E("🔧"), "Firmware version",      "AT+GMR",  AtStandard::Hayes,    "AT+GMR",  false, AT_NOARGS},
    { E("🆔"),  "IMEI (GSN)",            "AT+GSN",  AtStandard::Hayes,    "AT+GSN",  false, AT_NOARGS},
    { E("🆔"),  "IMEI",                  "AT+CGSN", AtStandard::ThreeGPP, "AT+CGSN", false, AT_NOARGS},
    { E("🧩"),  "Capabilities",          "AT+GCAP", AtStandard::Hayes,    "AT+GCAP", false, AT_NOARGS},
    { E("📎"), "Manufacturer (CGMI)",   "AT+CGMI", AtStandard::ThreeGPP, "AT+CGMI", false, AT_NOARGS},
    { E("🔧"),  "Model (CGMM)",          "AT+CGMM", AtStandard::ThreeGPP, "AT+CGMM", false, AT_NOARGS},
    { E("🔧"), "Firmware (CGMR)",       "AT+CGMR", AtStandard::ThreeGPP, "AT+CGMR", false, AT_NOARGS},
};
inline constexpr size_t kAtInfoActionsCount =
    sizeof(kAtInfoActions) / sizeof(kAtInfoActions[0]);


// SIM & PIN
inline constexpr AtActionArg kArgs_CPIN_Enter[] = {
    { "PIN or PUK", true, nullptr, "1234 / PUK code",
      AtArgType::String, 0, 0, nullptr, nullptr }
};

inline constexpr AtActionArg kArgs_CLCK_Pin[] = {
    { "PIN", true, nullptr, "current PIN",
      AtArgType::String, 0, 0, nullptr, nullptr }
};

inline constexpr AtActionArg kArgs_CPWD[] = {
    { "Old PIN", true, nullptr, nullptr,
      AtArgType::String, 0, 0, nullptr, nullptr },
    { "New PIN", true, nullptr, nullptr,
      AtArgType::String, 0, 0, nullptr, nullptr }
};

inline constexpr AtActionItem kAtSimPinActions[] = {
    { E("🔍"), "PIN status",        "AT+CPIN?",                      AtStandard::ThreeGPP, "AT+CPIN?",                     false, AT_NOARGS },
    { E("🔓"), "Enter PIN/PUK",     "AT+CPIN=\"%1\"",                AtStandard::ThreeGPP, "AT+CPIN=\"1234\"",             true,  kArgs_CPIN_Enter, AT_COUNT_OF(kArgs_CPIN_Enter) },
    { E("🔐"), "Enable SIM lock",   "AT+CLCK=\"SC\",1,\"%1\"",       AtStandard::ThreeGPP, "AT+CLCK=\"SC\",1,\"1234\"",    true,  kArgs_CLCK_Pin,   AT_COUNT_OF(kArgs_CLCK_Pin)   },
    { E("🔓"), "Disable SIM lock",  "AT+CLCK=\"SC\",0,\"%1\"",       AtStandard::ThreeGPP, "AT+CLCK=\"SC\",0,\"1234\"",    true,  kArgs_CLCK_Pin,   AT_COUNT_OF(kArgs_CLCK_Pin)   },
    { E("⚡"), "Change PIN",       "AT+CPWD=\"SC\",\"%1\",\"%2\"",  AtStandard::ThreeGPP, "AT+CPWD=\"SC\",\"1234\",\"0000\"", true, kArgs_CPWD,      AT_COUNT_OF(kArgs_CPWD)       },
};
inline constexpr size_t kAtSimPinActionsCount = AT_COUNT_OF(kAtSimPinActions);


// TEL NETWORK
 constexpr AtActionArg kArgs_COPS_MccMnc[] = {
    { "MCCMNC", true, nullptr, "e.g. 20801",
      AtArgType::Regex, 0, 0, nullptr, "^[0-9]{5,6}$" }
};

inline constexpr AtActionArg kArgs_CNMP_3gpp_Mode[] = {
    { "Mode", true, "2", "module-dependent",
      AtArgType::Uint, 0, 100, nullptr, nullptr }
};

inline constexpr AtActionArg kArgs_QCFG_Nwscanmode[] = {
    { "Mode", true, "3", "0=auto,3=GSM/WCDMA/LTE",
      AtArgType::Uint, 0, 10, nullptr, nullptr }
};

inline constexpr AtActionArg kArgs_CFUN[] = {
    { "CFUN", true, "1", "0=minimal,1=full,4=airplane",
      AtArgType::Choice, 0, 0, "0|1|4", nullptr }
};

inline constexpr AtActionArg kArgs_CNMP_Simcom_Mode[] = {
    { "Mode", true, "2", "2=auto,13=GSM,38=LTE…",
      AtArgType::Uint, 0, 100, nullptr, nullptr }
};

inline constexpr AtActionArg kArgs_CMNB_Pref[] = {
    { "Pref", true, "1", "module-dependent",
      AtArgType::Uint, 0, 10, nullptr, nullptr }
};

inline constexpr AtActionItem kAtNetworkActions[] = {
    { E("📡"), "Signal quality",          "AT+CSQ",                       AtStandard::ThreeGPP, "AT+CSQ",                       false, AT_NOARGS },
    { E("📎"), "GSM reg status",          "AT+CREG?",                     AtStandard::ThreeGPP, "AT+CREG?",                     false, AT_NOARGS },
    { E("🪛"), "Packet reg status",       "AT+CGREG?",                    AtStandard::ThreeGPP, "AT+CGREG?",                    false, AT_NOARGS },
    { E("📌"), "LTE reg status",          "AT+CEREG?",                    AtStandard::ThreeGPP, "AT+CEREG?",                    false, AT_NOARGS },
    { E("🏢"),  "Current operator",        "AT+COPS?",                     AtStandard::ThreeGPP, "AT+COPS?",                     false, AT_NOARGS },
    { E("🧭"),  "List operators",          "AT+COPS=?",                    AtStandard::ThreeGPP, "AT+COPS=?",                    false, AT_NOARGS },
    { E("📶"),  "Extended signal quality", "AT+CESQ",                      AtStandard::ThreeGPP, "AT+CESQ",                      false, AT_NOARGS },
    { E("🔁"),  "Auto select operator",    "AT+COPS=0",                    AtStandard::ThreeGPP, "AT+COPS=0",                    false, AT_NOARGS },
    { E("🧯"),  "Extended error report",   "AT+CEER",                      AtStandard::ThreeGPP, "AT+CEER",                      false, AT_NOARGS },

    { E("📶"),  "Set operator",            "AT+COPS=1,2,\"%1\"",           AtStandard::ThreeGPP, "AT+COPS=1,2,\"20801\"",        false, kArgs_COPS_MccMnc,     AT_COUNT_OF(kArgs_COPS_MccMnc) },
    { E("🌐"), "Network mode",            "AT+CNMP=%1",                   AtStandard::ThreeGPP, "AT+CNMP=2",                    false, kArgs_CNMP_3gpp_Mode,  AT_COUNT_OF(kArgs_CNMP_3gpp_Mode) },
    { E("🌐"), "Network scan mode",       "AT+QCFG=\"nwscanmode\",%1",    AtStandard::Quectel,  "AT+QCFG=\"nwscanmode\",3",     false, kArgs_QCFG_Nwscanmode, AT_COUNT_OF(kArgs_QCFG_Nwscanmode) },
    { E("📌"),  "Manual operator (PLMN)",  "AT+COPS=1,2,\"%1\"",           AtStandard::ThreeGPP, "AT+ COPS=1,2,\"20801\"",       false, kArgs_COPS_MccMnc,     AT_COUNT_OF(kArgs_COPS_MccMnc) },
    { E("💫"), "Function level",          "AT+CFUN=%1",                   AtStandard::ThreeGPP, "AT+CFUN=1",                    false, kArgs_CFUN,            AT_COUNT_OF(kArgs_CFUN) },

    // Vendor (popular)
    { E("📶"),  "RAT mode (SIMCom)",       "AT+CNMP=%1",                   AtStandard::SIMCom,   "AT+CNMP=2",                    false, kArgs_CNMP_Simcom_Mode, AT_COUNT_OF(kArgs_CNMP_Simcom_Mode) },
    { E("🧱"),  "NB/LTE pref (SIMCom)",    "AT+CMNB=%1",                   AtStandard::SIMCom,   "AT+CMNB=1",                    false, kArgs_CMNB_Pref,        AT_COUNT_OF(kArgs_CMNB_Pref) },
    { E("🧭"),  "Scan mode (Quectel)",     "AT+QCFG=\"nwscanmode\",%1",    AtStandard::Quectel,  "AT+QCFG=\"nwscanmode\",3",     false, kArgs_QCFG_Nwscanmode, AT_COUNT_OF(kArgs_QCFG_Nwscanmode) },
};

inline constexpr size_t kAtNetworkActionsCount = AT_COUNT_OF(kAtNetworkActions);

// CALLS
inline constexpr AtActionArg kArgs_Dial_Number[] = {
    { "Number", true, nullptr, "+33...", AtArgType::Phone, 0, 0, nullptr, nullptr }
};

inline constexpr AtActionArg kArgs_CLIP[] = {
    { "CLIP", true, "1", "0/1", AtArgType::Bool01, 0, 0, nullptr, nullptr }
};

inline constexpr AtActionArg kArgs_CLIR[] = {
    { "CLIR", true, "1", "0/1", AtArgType::Bool01, 0, 0, nullptr, nullptr }
};

inline constexpr AtActionArg kArgs_VTS_Digits[] = {
    { "Digits", true, nullptr, "0-9 * #", AtArgType::Regex, 0, 0, nullptr, "^[0-9*#]+$" }
};

inline constexpr AtActionArg kArgs_VTD_Units[] = {
    { "Units", true, "4", "1..255 (dépend module)", AtArgType::Uint, 1, 255, nullptr, nullptr }
};

inline constexpr AtActionArg kArgs_COLP_Enable[] = {
    { "Enable", true, "1", "0/1", AtArgType::Bool01, 0, 0, nullptr, nullptr }
};

inline constexpr AtActionArg kArgs_CSTA_Type[] = {
    { "Type", true, "145", "129=national,145=international", AtArgType::Choice, 0, 0, "129|145", nullptr }
};

// --- CALLS : actions  ---
inline constexpr AtActionItem kAtCallsActions[] = {
    { E("📲"), "Dial (voice)","ATD%1;",      AtStandard::Hayes,    "ATD+33123456789;", false, kArgs_Dial_Number, AT_COUNT_OF(kArgs_Dial_Number) },
    { E("✅"), "Answer",      "ATA",         AtStandard::Hayes,    "ATA",              false, AT_NOARGS },
    { E("📴"), "Hang up",     "ATH",         AtStandard::Hayes,    "ATH",              false, AT_NOARGS },
    { E("📃"), "List current calls","AT+CLCC", AtStandard::ThreeGPP, "AT+CLCC",       false, AT_NOARGS },
    { E("🆔"), "Caller ID presentation","AT+CLIP=%1", AtStandard::ThreeGPP, "AT+CLIP=1", false, kArgs_CLIP, AT_COUNT_OF(kArgs_CLIP) },
    { E("🙈"), "Caller ID restriction","AT+CLIR=%1",  AtStandard::ThreeGPP, "AT+CLIR=1", false, kArgs_CLIR, AT_COUNT_OF(kArgs_CLIR) },
    { E("🔊"), "DTMF tone",   "AT+VTS=\"%1\"", AtStandard::ThreeGPP, "AT+VTS=\"123#\"", false, kArgs_VTS_Digits, AT_COUNT_OF(kArgs_VTS_Digits) },
    { E("🕐"), "DTMF duration","AT+VTD=%1", AtStandard::ThreeGPP, "AT+VTD=4",         false, kArgs_VTD_Units, AT_COUNT_OF(kArgs_VTD_Units) },
    { E("🖲️"), "Connected line ID (COLP)","AT+COLP=%1", AtStandard::ThreeGPP, "AT+COLP=1", false, kArgs_COLP_Enable, AT_COUNT_OF(kArgs_COLP_Enable) },
    { E("🖲️"), "Connected line ID (COLP)","AT+COLP=%1", AtStandard::ThreeGPP, "AT+COLP=1", false, kArgs_COLP_Enable, AT_COUNT_OF(kArgs_COLP_Enable) }, // (doublon volontaire, comme l’original)
    { E("📎"), "Default dial TOA","AT+CSTA=%1", AtStandard::ThreeGPP, "AT+CSTA=145", false, kArgs_CSTA_Type, AT_COUNT_OF(kArgs_CSTA_Type) },
    { E("📱"), "Phone activity status","AT+CPAS", AtStandard::ThreeGPP, "AT+CPAS",     false, AT_NOARGS },
};

inline constexpr size_t kAtCallsActionsCount = AT_COUNT_OF(kAtCallsActions);


// // SMS
inline constexpr AtActionArg kArgs_CMGS_Phone[] = {
    { "Phone number", true, nullptr, "+33...", AtArgType::Phone, 0, 0, nullptr, nullptr }
};

inline constexpr AtActionArg kArgs_CMGR_Index[] = {
    { "Index", true, "1", "message index", AtArgType::Uint, 1, 1000, nullptr, nullptr }
};

inline constexpr AtActionArg kArgs_CMGL_Filter[] = {
    { "Filter", true, "ALL",
      "REC UNREAD|REC READ|STO UNSENT|STO SENT|ALL",
      AtArgType::Choice, 0, 0, "REC UNREAD|REC READ|STO UNSENT|STO SENT|ALL", nullptr }
};

inline constexpr AtActionArg kArgs_CMGD_Index[] = {
    { "Index", true, nullptr, "message index", AtArgType::Uint, 0, 1000, nullptr, nullptr }
};

inline constexpr AtActionArg kArgs_CNMI[] = {
    { "mode", true, "2", nullptr, AtArgType::Uint, 0, 3, nullptr, nullptr },
    { "mt",   true, "1", nullptr, AtArgType::Uint, 0, 3, nullptr, nullptr },
    { "bm",   true, "0", nullptr, AtArgType::Uint, 0, 3, nullptr, nullptr },
    { "ds",   true, "0", nullptr, AtArgType::Uint, 0, 3, nullptr, nullptr },
    { "bfr",  true, "0", nullptr, AtArgType::Uint, 0, 3, nullptr, nullptr },
};

inline constexpr AtActionArg kArgs_CSMP[] = {
    { "FO",  true, "17",  nullptr, AtArgType::Uint, 0, 255, nullptr, nullptr },
    { "VP",  true, "167", nullptr, AtArgType::Uint, 0, 255, nullptr, nullptr },
    { "PID", true, "0",   nullptr, AtArgType::Uint, 0, 255, nullptr, nullptr },
    { "DCS", true, "0",   nullptr, AtArgType::Uint, 0, 255, nullptr, nullptr },
};

inline constexpr AtActionArg kArgs_CMGW_Dest[] = {
    { "Destination (opt.)", false, nullptr, "Could be empty for draft",
      AtArgType::Phone, 0, 0, nullptr, nullptr }
};

inline constexpr AtActionArg kArgs_CMSS_IndexOverride[] = {
    { "Index", true, "1", nullptr, AtArgType::Uint, 1, 1000, nullptr, nullptr },
    { "Override number (opt.)", false, nullptr, "optionnel", AtArgType::Phone, 0, 0, nullptr, nullptr },
};

inline constexpr AtActionArg kArgs_CSMS_Service[] = {
    { "Service", true, "1", "module-dependent", AtArgType::Uint, 0, 3, nullptr, nullptr }
};

inline constexpr AtActionArg kArgs_CSDH_Show[] = {
    { "Show", true, "1", "0/1", AtArgType::Bool01, 0, 0, nullptr, nullptr }
};

inline constexpr AtActionArg kArgs_CSCB[] = {
    { "Mode", true, "0", "0=accept all,1=reject", AtArgType::Choice, 0, 0, "0|1", nullptr },
    { "MIDs", true, "",  "IDs list",              AtArgType::String, 0, 0, nullptr, nullptr },
    { "DCS",  true, "",  "DCS list",              AtArgType::String, 0, 0, nullptr, nullptr },
};

// --- SMS actions ---
inline constexpr AtActionItem kAtSmsActions[] = {
    { E("🧰"), "PDU mode",              "AT+CMGF=0",                    AtStandard::ThreeGPP, "AT+CMGF=0",                    false, AT_NOARGS },
    { E("✉️"), "Text mode",             "AT+CMGF=1",                    AtStandard::ThreeGPP, "AT+CMGF=1",                    false, AT_NOARGS },
    { E("📮"), "SMSC address",          "AT+CSCA?",                     AtStandard::ThreeGPP, "AT+CSCA?",                     false, AT_NOARGS },
    { E("📤"), "Send SMS (text)",       "AT+CMGS=\"%1\"",               AtStandard::ThreeGPP, "AT+CMGS=\"+33123456789\"",     false, kArgs_CMGS_Phone,           AT_COUNT_OF(kArgs_CMGS_Phone) },
    { E("📥"), "Read SMS",              "AT+CMGR=%1",                   AtStandard::ThreeGPP, "AT+CMGR=1",                    false, kArgs_CMGR_Index,           AT_COUNT_OF(kArgs_CMGR_Index) },
    { E("📜"), "List SMS",              "AT+CMGL=\"%1\"",               AtStandard::ThreeGPP, "AT+CMGL=\"ALL\"",              false, kArgs_CMGL_Filter,          AT_COUNT_OF(kArgs_CMGL_Filter) },
    { E("✂️"), "Delete SMS",           "AT+CMGD=%1",                   AtStandard::ThreeGPP, "AT+CMGD=1",                    true,  kArgs_CMGD_Index,           AT_COUNT_OF(kArgs_CMGD_Index) },
    { E("🔔"), "New SMS indications",   "AT+CNMI=%1,%2,%3,%4,%5",       AtStandard::ThreeGPP, "AT+CNMI=2,1,0,0,0",            false, kArgs_CNMI,                 AT_COUNT_OF(kArgs_CNMI) },
    { E("🔧"), "SMS params (CSMP)",     "AT+CSMP=%1,%2,%3,%4",          AtStandard::ThreeGPP, "AT+CSMP=17,167,0,0",           false, kArgs_CSMP,                 AT_COUNT_OF(kArgs_CSMP) },
    { E("💾"), "Write SMS to mem",      "AT+CMGW=\"%1\"",               AtStandard::ThreeGPP, "AT+CMGW=\"+33123456789\"",     false, kArgs_CMGW_Dest,            AT_COUNT_OF(kArgs_CMGW_Dest) },
    { E("📤"), "Send SMS from mem",     "AT+CMSS=%1,\"%2\"",            AtStandard::ThreeGPP, "AT+CMSS=1,\"+33123456789\"",   false, kArgs_CMSS_IndexOverride,   AT_COUNT_OF(kArgs_CMSS_IndexOverride) },
    { E("✅"), "Ack incoming SMS",      "AT+CNMA",                      AtStandard::ThreeGPP, "AT+CNMA",                      false, AT_NOARGS },
    { E("📦"), "Storage status",        "AT+CPMS?",                     AtStandard::ThreeGPP, "AT+CPMS?",                     false, AT_NOARGS },
    { E("🧭"), "Select message service","AT+CSMS=%1",                   AtStandard::ThreeGPP, "AT+CSMS=1",                     false, kArgs_CSMS_Service,         AT_COUNT_OF(kArgs_CSMS_Service) },
    { E("🔎"), "Show text params",      "AT+CSDH=%1",                   AtStandard::ThreeGPP, "AT+CSDH=1",                     false, kArgs_CSDH_Show,            AT_COUNT_OF(kArgs_CSDH_Show) },
    { E("📢"), "Cell broadcast filter", "AT+CSCB=%1,\"%2\",\"%3\"",     AtStandard::ThreeGPP, "AT+CSCB=0,\"\",\"\"",           false, kArgs_CSCB,                 AT_COUNT_OF(kArgs_CSCB) },
    { E("💾"), "Save SMS settings",     "AT+CSAS",                      AtStandard::ThreeGPP, "AT+CSAS",                      false, AT_NOARGS },
    { E("♻️"), "Restore SMS settings",  "AT+CRES",                      AtStandard::ThreeGPP, "AT+CRES",                      false, AT_NOARGS },
};
inline constexpr size_t kAtSmsActionsCount = AT_COUNT_OF(kAtSmsActions);

            
// PHONEBOOK
inline constexpr AtActionArg kArgs_CPBS_Storage[] = {
    { "Storage", true, "SM", "SM/ME", AtArgType::Choice, 0, 0, "SM|ME", nullptr }
};

inline constexpr AtActionArg kArgs_CPBR_Indices[] = {
    { "Start index", true, "1",  nullptr, AtArgType::Uint, 1, 250, nullptr, nullptr },
    { "End index",   true, "10", nullptr, AtArgType::Uint, 1, 250, nullptr, nullptr },
};

inline constexpr AtActionArg kArgs_CPBF_Query[] = {
    { "Query", true, nullptr, "substring", AtArgType::String, 0, 0, nullptr, nullptr }
};

inline constexpr AtActionArg kArgs_CPBW_WriteUpdate[] = {
    { "Index",  true, nullptr, nullptr, AtArgType::Uint,   1, 250, nullptr, nullptr },
    { "Number", true, nullptr, "+33...", AtArgType::Phone,  0,   0, nullptr, nullptr },
    { "Type",   true, "145",   "129=national,145=international",
                                 AtArgType::Choice, 0, 0, "129|145", nullptr },
    { "Name",   true, nullptr, nullptr,  AtArgType::String, 0,   0, nullptr, nullptr },
};

// --- PHONEBOOK actions ---
inline constexpr AtActionItem kAtPhonebookActions[] = {
    { E("📚"), "Select storage",   "AT+CPBS=\"%1\"",       AtStandard::ThreeGPP, "AT+CPBS=\"SM\"",
      false, kArgs_CPBS_Storage,     AT_COUNT_OF(kArgs_CPBS_Storage) },

    { E("📖"), "Read entries",     "AT+CPBR=%1,%2",        AtStandard::ThreeGPP, "AT+CPBR=1,10",
      false, kArgs_CPBR_Indices,     AT_COUNT_OF(kArgs_CPBR_Indices) },

    { E("🔎"), "Find by name",     "AT+CPBF=\"%1\"",       AtStandard::ThreeGPP, "AT+CPBF=\"ALICE\"",
      false, kArgs_CPBF_Query,       AT_COUNT_OF(kArgs_CPBF_Query) },

    { E("🪛"), "Write/Update entry","AT+CPBW=%1,\"%2\",%3,\"%4\"", AtStandard::ThreeGPP,
      "AT+CPBW=1,\"+33123456789\",145,\"ALICE\"",
      true,  kArgs_CPBW_WriteUpdate, AT_COUNT_OF(kArgs_CPBW_WriteUpdate) },
};
inline constexpr size_t kAtPhonebookActionsCount = AT_COUNT_OF(kAtPhonebookActions);

// USSD
inline constexpr AtActionArg kArgs_CUSD_Request[] = {
    { "USSD code", true, nullptr, "*100#", AtArgType::Regex, 0, 0, nullptr, "^[*#0-9]+#$" },
    { "DCS",       true, "15",    "15=GSM 7-bit",           AtArgType::Uint,  0, 255, nullptr, nullptr }
};

// --- USSD actions ---
inline constexpr AtActionItem kAtUssdActions[] = {
    { E("💱"), "USSD request", "AT+CUSD=1,\"%1\",%2", AtStandard::ThreeGPP,
      "AT+CUSD=1,\"*100#\",15", false,
      kArgs_CUSD_Request, AT_COUNT_OF(kArgs_CUSD_Request) },

    { E("🛑"), "Cancel USSD",  "AT+CUSD=2",            AtStandard::ThreeGPP,
      "AT+CUSD=2",            false, AT_NOARGS }
};

inline constexpr size_t kAtUssdActionsCount = AT_COUNT_OF(kAtUssdActions);


// DATA / PDP
inline constexpr AtActionArg kArgs_CGATT_Attach[] = {
    { "Attach", true, "1", "0/1", AtArgType::Bool01, 0, 0, nullptr, nullptr }
};

inline constexpr AtActionArg kArgs_CGAUTH[] = {
    { "CID",   true, "1",  nullptr,                 AtArgType::Uint,   1, 16, nullptr, nullptr },
    { "Type",  true, "1",  "0=None,1=PAP,2=CHAP",   AtArgType::Choice, 0,  0, "0|1|2",  nullptr },
    { "User",  true, nullptr, nullptr,              AtArgType::String, 0,  0, nullptr,  nullptr },
    { "Pass",  true, nullptr, nullptr,              AtArgType::String, 0,  0, nullptr,  nullptr },
};

inline constexpr AtActionArg kArgs_CGDCONT[] = {
    { "CID", true, "1",        nullptr,        AtArgType::Uint,  1, 16, nullptr, nullptr },
    { "APN", true, "internet", "APN name",     AtArgType::Regex, 0,  0, nullptr, "^[A-Za-z0-9._-]+$" },
};

inline constexpr AtActionArg kArgs_CID_1_16[] = {
    { "CID", true, "1", nullptr, AtArgType::Uint, 1, 16, nullptr, nullptr }
};

inline constexpr AtActionArg kArgs_CGCONTRDP_OptCid[] = {
    { "CID (or empty)", false, nullptr, "leave empty for all", AtArgType::String, 0, 0, nullptr, nullptr }
};

// --- DATA / PDP actions ---
inline constexpr AtActionItem kAtDataActions[] = {
    { E("🔌"), "Attach packet svc", "AT+CGATT=%1",              AtStandard::ThreeGPP,
      "AT+CGATT=1", false, kArgs_CGATT_Attach,     AT_COUNT_OF(kArgs_CGATT_Attach) },

    { E("🔒"), "PDP auth (PAP/CHAP)", "AT+CGAUTH=%1,%2,\"%3\",\"%4\"", AtStandard::ThreeGPP,
      "AT+CGAUTH=1,1,\"user\",\"pass\"", false, kArgs_CGAUTH, AT_COUNT_OF(kArgs_CGAUTH) },

    { E("📑"), "Define PDP context", "AT+CGDCONT=%1,\"IP\",\"%2\"", AtStandard::ThreeGPP,
      "AT+CGDCONT=1,\"IP\",\"internet\"", false, kArgs_CGDCONT, AT_COUNT_OF(kArgs_CGDCONT) },

    { E("⚡"), "Activate PDP",     "AT+CGACT=1,%1",           AtStandard::ThreeGPP,
      "AT+CGACT=1,1", false, kArgs_CID_1_16, AT_COUNT_OF(kArgs_CID_1_16) },

    { E("⚡"), "Deactivate PDP",   "AT+CGACT=0,%1",           AtStandard::ThreeGPP,
      "AT+CGACT=0,1", false, kArgs_CID_1_16, AT_COUNT_OF(kArgs_CID_1_16) },

    { E("🌍"), "Show IP address",   "AT+CGPADDR=%1",           AtStandard::ThreeGPP,
      "AT+CGPADDR=1", false, kArgs_CID_1_16, AT_COUNT_OF(kArgs_CID_1_16) },

    { E("📘"), "Context readback",  "AT+CGCONTRDP=%1",         AtStandard::ThreeGPP,
      "AT+CGCONTRDP=1", false, kArgs_CGCONTRDP_OptCid, AT_COUNT_OF(kArgs_CGCONTRDP_OptCid) },
};
inline constexpr size_t kAtDataActionsCount = AT_COUNT_OF(kAtDataActions);


// TIME & CLOCK
inline constexpr AtActionArg kArgs_CCLK_Set[] = {
    { "Datetime (yy/MM/dd,hh:mm:ss±tz)", true, nullptr, "25/08/11,12:00:00+08",
      AtArgType::Regex, 0, 0, nullptr,
      "^[0-9]{2}/[0-9]{2}/[0-9]{2},[0-9]{2}:[0-9]{2}:[0-9]{2}[+-][0-9]{2}$" }
};

inline constexpr AtActionArg kArgs_EnableBool[] = {
    { "Enable", true, "1", "0/1", AtArgType::Bool01, 0, 0, nullptr, nullptr }
};

// --- TIME & CLOCK ---
inline constexpr AtActionItem kAtTimeClockActions[] = {
    { E("⏰"), "Read clock",            "AT+CCLK?",                AtStandard::ThreeGPP,
      "AT+CCLK?", false, AT_NOARGS },

    { E("🕒"), "Set clock",             "AT+CCLK=\"%1\"",          AtStandard::ThreeGPP,
      "AT+CCLK=\"25/08/11,12:00:00+08\"", true,
      kArgs_CCLK_Set, AT_COUNT_OF(kArgs_CCLK_Set) },

    { E("💫"), "Auto TZ update (NITZ)", "AT+CTZU=%1",             AtStandard::ThreeGPP,
      "AT+CTZU=1", false,
      kArgs_EnableBool, AT_COUNT_OF(kArgs_EnableBool) },

    { E("💫"), "TZ URC reporting",     "AT+CTZR=%1",             AtStandard::ThreeGPP,
      "AT+CTZR=1", false,
      kArgs_EnableBool, AT_COUNT_OF(kArgs_EnableBool) },
};

inline constexpr size_t kAtTimeClockActionsCount = AT_COUNT_OF(kAtTimeClockActions);


// INTERNET TCP/IP
inline constexpr AtActionArg kArgs_Mode_STA_AP[] = {
    { "Mode", true, "1", "1=STA,2=AP,3=STA+AP",
      AtArgType::Choice, 0, 0, "1|2|3", nullptr }
};

inline constexpr AtActionArg kArgs_SSID_Password[] = {
    { "SSID",     true, nullptr, "network SSID",     AtArgType::String, 0, 0, nullptr, nullptr },
    { "Password", true, nullptr, "network password", AtArgType::String, 0, 0, nullptr, nullptr },
};

inline constexpr AtActionArg kArgs_SoftAP[] = {
    { "SSID",     true, "MyAP",   nullptr, AtArgType::String, 0, 0, nullptr, nullptr },
    { "Password", true, "apPass", nullptr, AtArgType::String, 0, 0, nullptr, nullptr },
    { "Channel",  true, "6",      nullptr, AtArgType::Uint,   1, 13, nullptr, nullptr },
    { "Ecn",      true, "4", "0=OPEN,1=WEP,2=WPA_PSK,3=WPA2_PSK,4=WPA_WPA2_PSK",
                   AtArgType::Choice, 0, 0, "0|1|2|3|4", nullptr },
};

inline constexpr AtActionArg kArgs_DHCP_Mode_Enable[] = {
    { "Mode",   true, "1", "0=STA,1=AP,2=BOTH", AtArgType::Choice, 0, 0, "0|1|2", nullptr },
    { "Enable", true, "1", "0/1",               AtArgType::Bool01, 0, 0, nullptr, nullptr },
};

inline constexpr AtActionArg kArgs_EnableBool2[] = {
    { "Enable", true, "1", "0/1", AtArgType::Bool01, 0, 0, nullptr, nullptr }
};

inline constexpr AtActionArg kArgs_MAC[] = {
    { "MAC", true, nullptr, "AA:BB:CC:DD:EE:FF",
      AtArgType::Regex, 0, 0, nullptr, "^([0-9A-Fa-f]{2}:){5}[0-9A-Fa-f]{2}$" }
};

inline constexpr AtActionArg kArgs_StaIP[] = {
    { "IP",      true, nullptr, "e.g. 192.168.1.100", AtArgType::String, 0, 0, nullptr, nullptr },
    { "Gateway", true, nullptr, "e.g. 192.168.1.1",   AtArgType::String, 0, 0, nullptr, nullptr },
    { "Netmask", true, nullptr, "e.g. 255.255.255.0", AtArgType::String, 0, 0, nullptr, nullptr },
};

inline constexpr AtActionArg kArgs_ApIP_Defaults[] = {
    { "IP",      true, "192.168.4.1",   nullptr, AtArgType::String, 0, 0, nullptr, nullptr },
    { "Gateway", true, "192.168.4.1",   nullptr, AtArgType::String, 0, 0, nullptr, nullptr },
    { "Netmask", true, "255.255.255.0", nullptr, AtArgType::String, 0, 0, nullptr, nullptr },
};

inline constexpr AtActionArg kArgs_Length_2048[] = {
    { "Length", true, "12", nullptr, AtArgType::Uint, 1, 2048, nullptr, nullptr }
};

inline constexpr AtActionArg kArgs_Length_4096[] = {
    { "Length", true, "64", nullptr, AtArgType::Uint, 1, 4096, nullptr, nullptr }
};

inline constexpr AtActionArg kArgs_SegmentID[] = {
    { "SegmentID", true, "1", nullptr, AtArgType::Uint, 0, 65535, nullptr, nullptr }
};

inline constexpr AtActionArg kArgs_ServerMode_Port[] = {
    { "Mode", true, "1", "0=stop,1=start", AtArgType::Bool01, 0, 0, nullptr, nullptr },
    { "Port", true, "8080", nullptr,       AtArgType::Uint,   1, 65535, nullptr, nullptr },
};

inline constexpr AtActionArg kArgs_TransparentMode[] = {
    { "Mode", true, "1", "0=normal,1=transparent", AtArgType::Bool01, 0, 0, nullptr, nullptr }
};

inline constexpr AtActionArg kArgs_SaveTransLink[] = {
    { "Enable", true, "1",            "0/1",         AtArgType::Bool01, 0, 0, nullptr, nullptr },
    { "Host",   true, "example.com",  nullptr,       AtArgType::String, 0, 0, nullptr, nullptr },
    { "Port",   true, "80",           nullptr,       AtArgType::Uint,   1, 65535,       nullptr, nullptr },
};

inline constexpr AtActionArg kArgs_TimeoutSec[] = {
    { "Seconds", true, "300", nullptr, AtArgType::Uint, 0, 7200, nullptr, nullptr }
};

inline constexpr AtActionArg kArgs_HostOnly[] = {
    { "Host", true, "example.com", nullptr, AtArgType::String, 0, 0, nullptr, nullptr }
};

inline constexpr AtActionArg kArgs_HostPort[] = {
    { "Host", true, nullptr, "example.com", AtArgType::String, 0, 0, nullptr, nullptr },
    { "Port", true, "80",    nullptr,       AtArgType::Uint,   1, 65535,       nullptr, nullptr },
};

inline constexpr AtActionArg kArgs_CID_Only[] = {
    { "CID", true, "1", nullptr, AtArgType::Uint, 1, 16, nullptr, nullptr }
};

inline constexpr AtActionArg kArgs_CID_APN[] = {
    { "CID", true, "1",        nullptr, AtArgType::Uint, 1, 16, nullptr, nullptr },
    { "APN", true, "internet", "APN name / regex", AtArgType::Regex, 0, 0, nullptr, "^[A-Za-z0-9._-]+$" },
};

inline constexpr AtActionArg kArgs_QIOPEN[] = {
    { "ContextId", true, "1",  nullptr, AtArgType::Uint, 1, 16,    nullptr, nullptr },
    { "ConnId",    true, "0",  nullptr, AtArgType::Uint, 0, 11,    nullptr, nullptr },
    { "Host",      true, nullptr, "example.com", AtArgType::String, 0, 0, nullptr, nullptr },
    { "Port",      true, "80",  nullptr, AtArgType::Uint, 1, 65535, nullptr, nullptr },
};

inline constexpr AtActionArg kArgs_QISEND[] = {
    { "ConnId", true, "0",  nullptr, AtArgType::Uint, 0, 11,   nullptr, nullptr },
    { "Length", true, "12", nullptr, AtArgType::Uint, 1, 1500, nullptr, nullptr },
};

inline constexpr AtActionArg kArgs_QIRD[] = {
    { "ConnId", true, "0",   nullptr, AtArgType::Uint, 0, 11,   nullptr, nullptr },
    { "Length", true, "512", nullptr, AtArgType::Uint, 1, 1500, nullptr, nullptr },
};

inline constexpr AtActionArg kArgs_ConnIdOnly[] = {
    { "ConnId", true, "0", nullptr, AtArgType::Uint, 0, 11, nullptr, nullptr }
};

// ---------- INTERNET TCP/IP ----------
inline constexpr AtActionItem kAtTcpIpActions[] = {
    // Wi-Fi (ESP-AT)
    { E("📶"), "Wi-Fi mode (STA/AP)",     "AT+CWMODE=%1",             AtStandard::Hayes,
      "AT+CWMODE=1", false, kArgs_Mode_STA_AP, AT_COUNT_OF(kArgs_Mode_STA_AP) },

    { E("🔎"), "Wi-Fi scan",              "AT+CWLAP",                 AtStandard::Hayes,
      "AT+CWLAP",   false, AT_NOARGS },

    { E("🔗"), "Wi-Fi join AP",           "AT+CWJAP=\"%1\",\"%2\"",   AtStandard::Hayes,
      "AT+CWJAP=\"MySSID\",\"MyPass\"", false, kArgs_SSID_Password, AT_COUNT_OF(kArgs_SSID_Password) },

    { E("🧹"), "Wi-Fi disconnect",        "AT+CWQAP",                 AtStandard::Hayes,
      "AT+CWQAP", false, AT_NOARGS },

    { E("🌐"), "IP local addr",           "AT+CIFSR",                 AtStandard::SIMCom,
      "AT+CIFSR", false, AT_NOARGS },

    { E("📶"), "Wi-Fi mode (DEF)",        "AT+CWMODE_DEF=%1",         AtStandard::Hayes,
      "AT+CWMODE_DEF=1", false, kArgs_Mode_STA_AP, AT_COUNT_OF(kArgs_Mode_STA_AP) },

    { E("🔗"), "Wi-Fi join AP (CUR)",     "AT+CWJAP_CUR=\"%1\",\"%2\"", AtStandard::Hayes,
      "AT+CWJAP_CUR=\"MySSID\",\"MyPass\"", false, kArgs_SSID_Password, AT_COUNT_OF(kArgs_SSID_Password) },

    { E("🔗"), "Wi-Fi join AP (DEF)",     "AT+CWJAP_DEF=\"%1\",\"%2\"", AtStandard::Hayes,
      "AT+CWJAP_DEF=\"MySSID\",\"MyPass\"", false, kArgs_SSID_Password, AT_COUNT_OF(kArgs_SSID_Password) },

    { E("🛜"), "SoftAP config (CUR)",     "AT+CWSAP_CUR=\"%1\",\"%2\",%3,%4", AtStandard::Hayes,
      "AT+CWSAP_CUR=\"MyAP\",\"apPass\",6,4", false, kArgs_SoftAP, AT_COUNT_OF(kArgs_SoftAP) },

    { E("🛜"), "SoftAP config (DEF)",     "AT+CWSAP_DEF=\"%1\",\"%2\",%3,%4", AtStandard::Hayes,
      "AT+CWSAP_DEF=\"MyAP\",\"apPass\",6,4", false, kArgs_SoftAP, AT_COUNT_OF(kArgs_SoftAP) },

    { E("👥"), "List STA on softAP",      "AT+CWLIF",                 AtStandard::Hayes,
      "AT+CWLIF", false, AT_NOARGS },

    { E("🔧"), "DHCP (CUR)",             "AT+CWDHCP_CUR=%1,%2",      AtStandard::Hayes,
      "AT+CWDHCP_CUR=1,1", false, kArgs_DHCP_Mode_Enable, AT_COUNT_OF(kArgs_DHCP_Mode_Enable) },

    { E("🔧"), "DHCP (DEF)",             "AT+CWDHCP_DEF=%1,%2",      AtStandard::Hayes,
      "AT+CWDHCP_DEF=1,1", false, kArgs_DHCP_Mode_Enable, AT_COUNT_OF(kArgs_DHCP_Mode_Enable) },

    { E("🔁"), "Auto-connect on boot",    "AT+CWAUTOCONN=%1",         AtStandard::Hayes,
      "AT+CWAUTOCONN=1", false, kArgs_EnableBool2, AT_COUNT_OF(kArgs_EnableBool) },

    { E("🆔"), "STA MAC (CUR)",           "AT+CIPSTAMAC_CUR=\"%1\"",  AtStandard::Hayes,
      "AT+CIPSTAMAC_CUR=\"AA:BB:CC:DD:EE:FF\"", false, kArgs_MAC, AT_COUNT_OF(kArgs_MAC) },

    { E("🆔"), "STA MAC (DEF)",           "AT+CIPSTAMAC_DEF=\"%1\"",  AtStandard::Hayes,
      "AT+CIPSTAMAC_DEF=\"AA:BB:CC:DD:EE:FF\"", false, kArgs_MAC, AT_COUNT_OF(kArgs_MAC) },

    { E("🆔"), "AP  MAC (CUR)",           "AT+CIPAPMAC_CUR=\"%1\"",   AtStandard::Hayes,
      "AT+CIPAPMAC_CUR=\"AA:BB:CC:DD:EE:FF\"", false, kArgs_MAC, AT_COUNT_OF(kArgs_MAC) },

    { E("🆔"), "AP  MAC (DEF)",           "AT+CIPAPMAC_DEF=\"%1\"",   AtStandard::Hayes,
      "AT+CIPAPMAC_DEF=\"AA:BB:CC:DD:EE:FF\"", false, kArgs_MAC, AT_COUNT_OF(kArgs_MAC) },

    { E("🌐"), "STA IP (CUR)",            "AT+CIPSTA_CUR=\"%1\",\"%2\",\"%3\"", AtStandard::Hayes,
      "AT+CIPSTA_CUR=\"192.168.1.100\",\"192.168.1.1\",\"255.255.255.0\"", false,
      kArgs_StaIP, AT_COUNT_OF(kArgs_StaIP) },

    { E("🌐"), "STA IP (DEF)",            "AT+CIPSTA_DEF=\"%1\",\"%2\",\"%3\"", AtStandard::Hayes,
      "AT+CIPSTA_DEF=\"192.168.1.100\",\"192.168.1.1\",\"255.255.255.0\"", false,
      kArgs_StaIP, AT_COUNT_OF(kArgs_StaIP) },

    { E("🏠"), "AP  IP (CUR)",            "AT+CIPAP_CUR=\"%1\",\"%2\",\"%3\"",  AtStandard::Hayes,
      "AT+CIPAP_CUR=\"192.168.4.1\",\"192.168.4.1\",\"255.255.255.0\"", false,
      kArgs_ApIP_Defaults, AT_COUNT_OF(kArgs_ApIP_Defaults) },

    { E("🏠"), "AP  IP (DEF)",            "AT+CIPAP_DEF=\"%1\",\"%2\",\"%3\"",  AtStandard::Hayes,
      "AT+CIPAP_DEF=\"192.168.4.1\",\"192.168.4.1\",\"255.255.255.0\"", false,
      kArgs_ApIP_Defaults, AT_COUNT_OF(kArgs_ApIP_Defaults) },

    { E("🧠"), "SmartConfig start",       "AT+CWSTARTSMART=%1",       AtStandard::Hayes,
      "AT+CWSTARTSMART=1", false,
      (AtActionArg[]){
        { "Type", true, "1", "0=ESP-TOUCH,1=AIRKISS,3=BOTH", AtArgType::Choice, 0, 0, "0|1|3", nullptr }
      }, 1 },

    { E("🧠"), "SmartConfig stop",        "AT+CWSTOPSMART",           AtStandard::Hayes,
      "AT+CWSTOPSMART", false, AT_NOARGS },

    { E("📌"), "Conn status",            "AT+CIPSTATUS",             AtStandard::Hayes,
      "AT+CIPSTATUS", false, AT_NOARGS },

    { E("📩"), "Send (CIPSENDEX)",       "AT+CIPSENDEX=%1",          AtStandard::Hayes,
      "AT+CIPSENDEX=12", false, kArgs_Length_2048, AT_COUNT_OF(kArgs_Length_2048) },

    { E("📦"),  "Send to buffer",         "AT+CIPSENDBUF=%1",         AtStandard::Hayes,
      "AT+CIPSENDBUF=64", false, kArgs_Length_4096, AT_COUNT_OF(kArgs_Length_4096) },

    { E("⚡"), "Reset seg IDs",          "AT+CIPBUFRESET",           AtStandard::Hayes,
      "AT+CIPBUFRESET", false, AT_NOARGS },

    { E("📊"),  "Buffer status",          "AT+CIPBUFSTATUS",          AtStandard::Hayes,
      "AT+CIPBUFSTATUS", false, AT_NOARGS },

    { E("🔎"),  "Check segment",          "AT+CIPCHECKSEQ=%1",        AtStandard::Hayes,
      "AT+CIPCHECKSEQ=1", false, kArgs_SegmentID, AT_COUNT_OF(kArgs_SegmentID) },

    { E("🔀"),  "Multi-conn (CIPMUX)",    "AT+CIPMUX=%1",             AtStandard::Hayes,
      "AT+CIPMUX=1", false, kArgs_EnableBool, AT_COUNT_OF(kArgs_EnableBool) },

    { E("🏠"), "Server mode",            "AT+CIPSERVER=%1,%2",       AtStandard::Hayes,
      "AT+CIPSERVER=1,8080", false, kArgs_ServerMode_Port, AT_COUNT_OF(kArgs_ServerMode_Port) },

    { E("🔁"),  "Transparent mode",       "AT+CIPMODE=%1",            AtStandard::Hayes,
      "AT+CIPMODE=1", false, kArgs_TransparentMode, AT_COUNT_OF(kArgs_TransparentMode) },

    { E("💾"),  "Save trans link",        "AT+SAVETRANSLINK=%1,\"%2\",%3", AtStandard::Hayes,
      "AT+SAVETRANSLINK=1,\"example.com\",80", false, kArgs_SaveTransLink, AT_COUNT_OF(kArgs_SaveTransLink) },

    { E("🕐"), "Server timeout",         "AT+CIPSTO=%1",             AtStandard::Hayes,
      "AT+CIPSTO=300", false, kArgs_TimeoutSec, AT_COUNT_OF(kArgs_TimeoutSec) },

    { E("📩"), "Firmware update (net)",  "AT+CIUPDATE",              AtStandard::Hayes,
      "AT+CIUPDATE", true, AT_NOARGS },

    { E("🏓"),  "Ping host",              "AT+PING=\"%1\"",           AtStandard::Hayes,
      "AT+PING=\"example.com\"", false, kArgs_HostOnly, AT_COUNT_OF(kArgs_HostOnly) },

    // SIMCom TCP
    { E("🔁"),  "Open TCP",               "AT+CIPSTART=\"TCP\",\"%1\",%2", AtStandard::SIMCom,
      "AT+CIPSTART=\"TCP\",\"example.com\",80", false, kArgs_HostPort, AT_COUNT_OF(kArgs_HostPort) },

    { E("📩"), "Send (enter data)",      "AT+CIPSEND",               AtStandard::SIMCom,
      "AT+CIPSEND", false, AT_NOARGS },

    { E("🧹"),  "Close",                  "AT+CIPCLOSE",              AtStandard::SIMCom,
      "AT+CIPCLOSE", false, AT_NOARGS },

    { E("🧯"),  "Shutdown stack",         "AT+CIPSHUT",               AtStandard::SIMCom,
      "AT+CIPSHUT", false, AT_NOARGS },

    // Quectel QI*
    { E("🔧"), "Define PDP (QI)",        "AT+QICSGP=%1,1,\"%2\",\"\",\"\",1", AtStandard::Quectel,
      "AT+QICSGP=1,1,\"internet\",\"\",\"\",1", false, kArgs_CID_APN, AT_COUNT_OF(kArgs_CID_APN) },

    { E("⚡"), "Activate PDP (QI)",      "AT+QIACT=%1",              AtStandard::Quectel,
      "AT+QIACT=1", false, kArgs_CID_Only, AT_COUNT_OF(kArgs_CID_Only) },

    { E("⚡"),  "Open socket",            "AT+QIOPEN=%1,%2,\"TCP\",\"%3\",%4,0,1", AtStandard::Quectel,
      "AT+QIOPEN=1,0,\"TCP\",\"example.com\",80,0,1", false, kArgs_QIOPEN, AT_COUNT_OF(kArgs_QIOPEN) },

    { E("📩"), "Send len",               "AT+QISEND=%1,%2",          AtStandard::Quectel,
      "AT+QISEND=0,12", false, kArgs_QISEND, AT_COUNT_OF(kArgs_QISEND) },

    { E("📥"),  "Read len",               "AT+QIRD=%1,%2",            AtStandard::Quectel,
      "AT+QIRD=0,512", false, kArgs_QIRD, AT_COUNT_OF(kArgs_QIRD) },

    { E("🧹"),  "Close",                  "AT+QICLOSE=%1",            AtStandard::Quectel,
      "AT+QICLOSE=0", false, kArgs_ConnIdOnly, AT_COUNT_OF(kArgs_ConnIdOnly) },
};

inline constexpr size_t kAtTcpIpActionsCount = AT_COUNT_OF(kAtTcpIpActions);

// HTTP(S)
inline constexpr AtActionArg kArgs_HTTPPARA_URL[] = {
  { "URL", true, nullptr, "http://...", AtArgType::String, 0, 0, nullptr, nullptr }
};

inline constexpr AtActionArg kArgs_HTTPACTION[] = {
  { "Method", true, "0", "0=GET,1=POST,2=HEAD", AtArgType::Choice, 0, 0, "0|1|2", nullptr }
};

inline constexpr AtActionArg kArgs_QHTTPGET[] = {
  { "URL",        true, nullptr, "http://...", AtArgType::String, 0, 0, nullptr, nullptr },
  { "Timeout (s)",true, "60",    nullptr,      AtArgType::Uint,   1, 600, nullptr, nullptr }
};

inline constexpr AtActionArg kArgs_QHTTPPOST[] = {
  { "URL",         true, nullptr, "http://...",                 AtArgType::String, 0, 0,      nullptr, nullptr },
  { "CT length",   true, "9",     "e.g. length of 'text/plain'",AtArgType::Uint,   1, 4096,  nullptr, nullptr },
  { "Data length", true, "128",   nullptr,                      AtArgType::Uint,   1, 1048576,nullptr, nullptr },
  { "Timeout (s)", true, "60",    nullptr,                      AtArgType::Uint,   1, 600,   nullptr, nullptr }
};

inline constexpr AtActionArg kArgs_QHTTPREAD[] = {
  { "Timeout (s)", true, "60", nullptr, AtArgType::Uint, 1, 600, nullptr, nullptr }
};

inline constexpr AtActionItem kAtHttpActions[] = {
  { E("🚀"), "HTTP init",           "AT+HTTPINIT",                     AtStandard::SIMCom,
    "AT+HTTPINIT", false, AT_NOARGS },

  { E("🔧"), "HTTP param URL",     "AT+HTTPPARA=\"URL\",\"%1\"",      AtStandard::SIMCom,
    "AT+HTTPPARA=\"URL\",\"http://example.com/\"", false,
    kArgs_HTTPPARA_URL, AT_COUNT_OF(kArgs_HTTPPARA_URL) },

  { E("📌"), "HTTP action",        "AT+HTTPACTION=%1",                AtStandard::SIMCom,
    "AT+HTTPACTION=0", false,
    kArgs_HTTPACTION, AT_COUNT_OF(kArgs_HTTPACTION) },

  { E("📥"), "HTTP read",           "AT+HTTPREAD",                     AtStandard::SIMCom,
    "AT+HTTPREAD", false, AT_NOARGS },

  { E("🧹"), "HTTP term",           "AT+HTTPTERM",                     AtStandard::SIMCom,
    "AT+HTTPTERM", false, AT_NOARGS },

  { E("🚀"), "HTTP GET",            "AT+QHTTPGET=\"%1\",%2",           AtStandard::Quectel,
    "AT+QHTTPGET=\"http://example.com\",60", false,
    kArgs_QHTTPGET, AT_COUNT_OF(kArgs_QHTTPGET) },

  { E("📩"), "HTTP POST",          "AT+QHTTPPOST=\"%1\",%2,%3,%4",    AtStandard::Quectel,
    "AT+QHTTPPOST=\"http://example.com\",9,128,60", false,
    kArgs_QHTTPPOST, AT_COUNT_OF(kArgs_QHTTPPOST) },

  { E("📥"), "HTTP read",           "AT+QHTTPREAD=%1",                 AtStandard::Quectel,
    "AT+QHTTPREAD=60", false,
    kArgs_QHTTPREAD, AT_COUNT_OF(kArgs_QHTTPREAD) },
};
inline constexpr size_t kAtHttpActionsCount = AT_COUNT_OF(kAtHttpActions);

// GNSS
inline constexpr AtActionArg kArgs_CGNSPWR[] = {
  { "Power", true, "1", "0/1", AtArgType::Bool01, 0, 0, nullptr, nullptr }
};

inline constexpr AtActionArg kArgs_CGNSLOC[] = {
  { "Mode", true, "2", "module-specific", AtArgType::Uint, 0, 10, nullptr, nullptr }
};

inline constexpr AtActionArg kArgs_QGPS[] = {
  { "Power", true, "1", "0/1", AtArgType::Bool01, 0, 0, nullptr, nullptr }
};

inline constexpr AtActionArg kArgs_QGPSCFG[] = {
  { "Item",  true, "gnssconfig", nullptr, AtArgType::String, 0, 0, nullptr, nullptr },
  { "Value", true, "3",          nullptr, AtArgType::Uint,   0, 100, nullptr, nullptr }
};

inline constexpr AtActionArg kArgs_QGPSLOC[] = {
  { "Timeout (s)", true, "30", nullptr, AtArgType::Uint, 1, 600, nullptr, nullptr }
};

inline constexpr AtActionArg kArgs_QGPSGNMEA[] = {
  { "Sentence", true, "GGA", "GGA/RMC/GSV/...", AtArgType::Choice, 0, 0, "GGA|RMC|GSV|GSA|VTG|GLL", nullptr }
};

// ---- GNSS actions (flash) ----
inline constexpr AtActionItem kAtGnssActions[] = {
  { E("🧭"), "GNSS power",    "AT+CGNSPWR=%1",          AtStandard::SIMCom,
    "AT+CGNSPWR=1", false, kArgs_CGNSPWR,  AT_COUNT_OF(kArgs_CGNSPWR) },

  { E("📡"), "GNSS info",     "AT+CGNSINF",             AtStandard::SIMCom,
    "AT+CGNSINF",  false, AT_NOARGS },

  { E("📍"), "GNSS location", "AT+CGNSLOC=%1",          AtStandard::SIMCom,
    "AT+CGNSLOC=2", false, kArgs_CGNSLOC,   AT_COUNT_OF(kArgs_CGNSLOC) },

  { E("🧭"), "GPS on/off",    "AT+QGPS=%1",             AtStandard::Quectel,
    "AT+QGPS=1",   false, kArgs_QGPS,       AT_COUNT_OF(kArgs_QGPS) },

  { E("🔧"), "GPS config",   "AT+QGPSCFG=\"%1\",%2",   AtStandard::Quectel,
    "AT+QGPSCFG=\"gnssconfig\",3", false, kArgs_QGPSCFG, AT_COUNT_OF(kArgs_QGPSCFG) },

  { E("📍"), "GPS location",  "AT+QGPSLOC=%1",          AtStandard::Quectel,
    "AT+QGPSLOC=30", false, kArgs_QGPSLOC,  AT_COUNT_OF(kArgs_QGPSLOC) },

  { E("🧾"), "NMEA output",   "AT+QGPSGNMEA=\"%1\"",    AtStandard::Quectel,
    "AT+QGPSGNMEA=\"GGA\"", false, kArgs_QGPSGNMEA, AT_COUNT_OF(kArgs_QGPSGNMEA) },
};
inline constexpr size_t kAtGnssActionsCount = AT_COUNT_OF(kAtGnssActions);


// LoRa
inline constexpr AtActionArg kArgs_REGION[] = {
    { "Region", true, "EU868",
      "EU868/US915/AS923/AU915/KR920/IN865",
      AtArgType::Choice, 0, 0,
      "EU868|US915|AS923|AU915|KR920|IN865", nullptr }
};

inline constexpr AtActionArg kArgs_DEVEUI[] = {
    { "DevEUI hex", true, nullptr, "16 hex (8B), no spaces",
      AtArgType::Regex, 0, 0, nullptr, "^[0-9A-Fa-f]{16}$" }
};

inline constexpr AtActionArg kArgs_APPEUI[] = {
    { "AppEUI hex", true, nullptr, "16 hex (8B), no spaces",
      AtArgType::Regex, 0, 0, nullptr, "^[0-9A-Fa-f]{16}$" }
};

inline constexpr AtActionArg kArgs_APPKEY[] = {
    { "AppKey hex", true, nullptr, "32 hex (16B), no spaces",
      AtArgType::Regex, 0, 0, nullptr, "^[0-9A-Fa-f]{32}$" }
};

inline constexpr AtActionArg kArgs_DEVADDR[] = {
    { "DevAddr hex", true, nullptr, "8 hex (4B), no spaces",
      AtArgType::Regex, 0, 0, nullptr, "^[0-9A-Fa-f]{8}$" }
};

inline constexpr AtActionArg kArgs_NWKSKEY[] = {
    { "NwkSKey hex", true, nullptr, "32 hex (16B), no spaces",
      AtArgType::Regex, 0, 0, nullptr, "^[0-9A-Fa-f]{32}$" }
};

inline constexpr AtActionArg kArgs_APPSKEY[] = {
    { "AppSKey hex", true, nullptr, "32 hex (16B), no spaces",
      AtArgType::Regex, 0, 0, nullptr, "^[0-9A-Fa-f]{32}$" }
};

inline constexpr AtActionArg kArgs_BOOL01[] = {
    { "ADR", true, "1", "0/1",
      AtArgType::Bool01, 0, 0, nullptr, nullptr }
};

inline constexpr AtActionArg kArgs_DR[] = {
    { "DR index", true, "5", "0..15 (region-dependent)",
      AtArgType::Uint, 0, 15, nullptr, nullptr }
};

inline constexpr AtActionArg kArgs_CLASS[] = {
    { "Class", true, "A", "A/B/C",
      AtArgType::Choice, 0, 0, "A|B|C", nullptr }
};

inline constexpr AtActionArg kArgs_SEND[] = {
    { "FPort", true, "1", "1..223",
      AtArgType::Uint, 1, 223, nullptr, nullptr },
    { "Payload (hex bytes)", true, nullptr, "e.g. 01 AA 02",
      AtArgType::HexBytes, 0, 0, nullptr, nullptr }
};

inline constexpr AtActionItem kAtLoraActions[] = {
    { E("📌"), "Module version",     "AT+VER",               AtStandard::Hayes,
      "AT+VER", false, AT_NOARGS },

    { E("🌍"),  "Set region",         "AT+REGION=\"%1\"",     AtStandard::Hayes,
      "AT+REGION=\"EU868\"", false,
      kArgs_REGION,  AT_COUNT_OF(kArgs_REGION) },

    { E("🪛"), "Set DevEUI (OTAA)", "AT+DEVEUI=%1",         AtStandard::Hayes,
      "AT+DEVEUI=0011223344556677", false,
      kArgs_DEVEUI,  AT_COUNT_OF(kArgs_DEVEUI) },

    { E("🪛"), "Set AppEUI (OTAA)", "AT+APPEUI=%1",         AtStandard::Hayes,
      "AT+APPEUI=0102030405060708", false,
      kArgs_APPEUI,  AT_COUNT_OF(kArgs_APPEUI) },

    { E("🔑"),  "Set AppKey (OTAA)",  "AT+APPKEY=%1",         AtStandard::Hayes,
      "AT+APPKEY=00112233445566778899AABBCCDDEEFF", false,
      kArgs_APPKEY,  AT_COUNT_OF(kArgs_APPKEY) },

    { E("📎"), "Set DevAddr (ABP)", "AT+DEVADDR=%1",        AtStandard::Hayes,
      "AT+DEVADDR=26011BDA", false,
      kArgs_DEVADDR, AT_COUNT_OF(kArgs_DEVADDR) },

    { E("🔑"), "Set NwkSKey (ABP)", "AT+NWKSKEY=%1",        AtStandard::Hayes,
      "AT+NWKSKEY=00112233445566778899AABBCCDDEEFF", false,
      kArgs_NWKSKEY, AT_COUNT_OF(kArgs_NWKSKEY) },

    { E("🔑"), "Set AppSKey (ABP)", "AT+APPSKEY=%1",        AtStandard::Hayes,
      "AT+APPSKEY=00112233445566778899AABBCCDDEEFF", false,
      kArgs_APPSKEY, AT_COUNT_OF(kArgs_APPSKEY) },

    { E("🔗"),  "Join (OTAA)",        "AT+JOIN",              AtStandard::Hayes,
      "AT+JOIN", false, AT_NOARGS },

    { E("🔁"),  "ADR on/off",         "AT+ADR=%1",            AtStandard::Hayes,
      "AT+ADR=1", false,
      kArgs_BOOL01, AT_COUNT_OF(kArgs_BOOL01) },

    { E("📶"),  "Data rate (DR)",     "AT+DR=%1",             AtStandard::Hayes,
      "AT+DR=5", false,
      kArgs_DR, AT_COUNT_OF(kArgs_DR) },

    { E("📎"), "Device class",       "AT+CLASS=%1",          AtStandard::Hayes,
      "AT+CLASS=A", false,
      kArgs_CLASS, AT_COUNT_OF(kArgs_CLASS) },

    { E("📩"), "Send (unconfirmed)","AT+SEND=%1,%2",         AtStandard::Hayes,
      "AT+SEND=1,01 AA 02", false,
      kArgs_SEND, AT_COUNT_OF(kArgs_SEND) },

    { E("✅"),  "Send (confirmed)",    "AT+CSEND=%1,%2",       AtStandard::Hayes,
      "AT+CSEND=1,01 AA 02", false,
      kArgs_SEND, AT_COUNT_OF(kArgs_SEND) },

    { E("🔍"),  "Join status",         "AT+NJS?",             AtStandard::Hayes,
      "AT+NJS?", false, AT_NOARGS },
};
inline constexpr size_t kAtLoraActionsCount = AT_COUNT_OF(kAtLoraActions);


// Audio (3GPP)
inline constexpr AtActionArg kArgs_CLVL_Level[] = {
    { "Level", true, "5", "0..15 (module-dependent)",
      AtArgType::Uint, 0, 15, nullptr, nullptr }
};

inline constexpr AtActionArg kArgs_CMUT_Mute[] = {
    { "Mute", true, "1", "0=off,1=on",
      AtArgType::Bool01, 0, 0, nullptr, nullptr }
};

inline constexpr AtActionArg kArgs_CRSL_Level[] = {
    { "Level", true, "2", "0..5/7/100 (depends module)",
      AtArgType::Uint, 0, 100, nullptr, nullptr }
};

inline constexpr AtActionArg kArgs_CHFA_Path[] = {
    { "Path", true, "1", "0=handset,1=speaker,2=headset",
      AtArgType::Choice, 0, 0, "0|1|2", nullptr }
};

inline constexpr AtActionItem kAtAudioActions[] = {
    { E("🔊"), "Speaker volume",          "AT+CLVL=%1", AtStandard::ThreeGPP,
      "AT+CLVL=5", false,
      kArgs_CLVL_Level, AT_COUNT_OF(kArgs_CLVL_Level) },

    { E("🤫"), "Mic mute",                 "AT+CMUT=%1", AtStandard::ThreeGPP,
      "AT+CMUT=1", false,
      kArgs_CMUT_Mute, AT_COUNT_OF(kArgs_CMUT_Mute) },

    { E("🔔"), "Ring volume",              "AT+CRSL=%1", AtStandard::ThreeGPP,
      "AT+CRSL=2", false,
      kArgs_CRSL_Level, AT_COUNT_OF(kArgs_CRSL_Level) },

    { E("🔈"), "Audio route (SIMCom)",     "AT+CHFA=%1", AtStandard::SIMCom,
      "AT+CHFA=1", false,
      kArgs_CHFA_Path, AT_COUNT_OF(kArgs_CHFA_Path) },
};
inline constexpr size_t kAtAudioActionsCount = AT_COUNT_OF(kAtAudioActions);


// Power / PSM (3GPP + 2G vendor)
inline constexpr AtActionArg kArgs_CPSMS_Timers[] = {
    { "TAU (T3412 bin8)",  true, "00100001", "8 bits binaires",
      AtArgType::Regex, 0, 0, nullptr, "^[01]{8}$" },
    { "ActiveTime (T3324)", true, "00000101", "8 bits binaires",
      AtArgType::Regex, 0, 0, nullptr, "^[01]{8}$" }
};

inline constexpr AtActionArg kArgs_CEDRXS_Set[] = {
    { "Mode",  true, "2",  "0=off,2=on",
      AtArgType::Choice, 0, 0, "0|2", nullptr },
    { "AcT",   true, "4",  "4=LTE-M,5=NB-IoT",
      AtArgType::Choice, 0, 0, "4|5", nullptr },
    { "eDRX",  true, "0101", "4 bits binaires",
      AtArgType::Regex, 0, 0, nullptr, "^[01]{4}$" }
};

// --- Power / PSM (constexpr, pas de heap) ---
inline constexpr AtActionItem kAtPowerActions[] = {
    { E("💤"), "PSM on/off",              "AT+CPSMS=%1",                  AtStandard::ThreeGPP,
      "AT+CPSMS=1", false,
      kArgs_EnableBool, AT_COUNT_OF(kArgs_EnableBool) },

    { E("🕒"), "PSM timers",             "AT+CPSMS=1,,,\"%1\",\"%2\"",   AtStandard::ThreeGPP,
      "AT+CPSMS=1,,,\"00100001\",\"00000101\"", false,
      kArgs_CPSMS_Timers, AT_COUNT_OF(kArgs_CPSMS_Timers) },

    { E("🧩"), "eDRX set",                "AT+CEDRXS=%1,%2,\"%3\"",       AtStandard::ThreeGPP,
      "AT+CEDRXS=2,4,\"0101\"", false,
      kArgs_CEDRXS_Set, AT_COUNT_OF(kArgs_CEDRXS_Set) },

    { E("🔎"), "eDRX readback",           "AT+CEDRXRDP",                  AtStandard::ThreeGPP,
      "AT+CEDRXRDP", false, AT_NOARGS },

    { E("🌙"), "2G sleep (SIMCom)",       "AT+CSCLK=%1",                  AtStandard::SIMCom,
      "AT+CSCLK=1", false,
      kArgs_EnableBool, AT_COUNT_OF(kArgs_EnableBool) },
};

inline constexpr size_t kAtPowerActionsCount = AT_COUNT_OF(kAtPowerActions);


// Hardware I/O & Status
inline constexpr AtActionItem kAtHardwareActions[] = {
    { E("🔋"), "Battery status",        "AT+CBC",   AtStandard::ThreeGPP, "AT+CBC",   false, AT_NOARGS },
    { E("💳"), "SIM ICCID",             "AT+CCID",  AtStandard::ThreeGPP, "AT+CCID",  false, AT_NOARGS },
    { E("🧾"), "IMSI",                  "AT+CIMI",  AtStandard::ThreeGPP, "AT+CIMI",  false, AT_NOARGS },
    { E("📈"), "ADC read (SIMCom)",     "AT+CADC?", AtStandard::SIMCom,   "AT+CADC?", false, AT_NOARGS },
    { E("📇"), "Subscriber number",     "AT+CNUM",  AtStandard::ThreeGPP, "AT+CNUM",  false, AT_NOARGS },
};

inline constexpr size_t kAtHardwareActionsCount = AT_COUNT_OF(kAtHardwareActions);


// MQTT (Quectel + SIMCom)
inline constexpr AtActionArg kArgs_QMTOPEN[] = {
    { "ClientIdx", true, "0",     nullptr, AtArgType::Uint,   0,     5,     nullptr, nullptr },
    { "Host",      true, nullptr, "broker",AtArgType::String, 0,     0,     nullptr, nullptr },
    { "Port",      true, "1883",  nullptr, AtArgType::Uint,   1, 65535,     nullptr, nullptr },
};

inline constexpr AtActionArg kArgs_QMTCONN[] = {
    { "ClientIdx", true, "0",         nullptr, AtArgType::Uint,   0, 5, nullptr, nullptr },
    { "ClientID",  true, "client123", nullptr, AtArgType::String, 0, 0, nullptr, nullptr },
};

inline constexpr AtActionArg kArgs_QMTPUB[] = {
    { "ClientIdx", true, "0",          nullptr, AtArgType::Uint,   0, 5,     nullptr, nullptr },
    { "MsgId",     true, "1",          nullptr, AtArgType::Uint,   1, 65535, nullptr, nullptr },
    { "QoS",       true, "0",          "0/1/2", AtArgType::Choice, 0, 0,     "0|1|2", nullptr },
    { "Retain",    true, "0",          "0/1",   AtArgType::Bool01, 0, 0,     nullptr, nullptr },
    { "Topic",     true, "test/topic", nullptr, AtArgType::String, 0, 0,     nullptr, nullptr },
};

inline constexpr AtActionArg kArgs_QMTSUB[] = {
    { "ClientIdx", true, "0",          nullptr, AtArgType::Uint,   0, 5,     nullptr, nullptr },
    { "MsgId",     true, "2",          nullptr, AtArgType::Uint,   1, 65535, nullptr, nullptr },
    { "Topic",     true, "test/topic", nullptr, AtArgType::String, 0, 0,     nullptr, nullptr },
    { "QoS",       true, "0",          "0/1/2", AtArgType::Choice, 0, 0,     "0|1|2", nullptr },
};

inline constexpr AtActionArg kArgs_QMTDISC[] = {
    { "ClientIdx", true, "0", nullptr, AtArgType::Uint, 0, 5, nullptr, nullptr },
};

inline constexpr AtActionArg kArgs_SMPUB[] = {
    { "Topic",  true, "test/topic", nullptr, AtArgType::String, 0,       0,       nullptr, nullptr },
    { "Length", true, "5",          nullptr, AtArgType::Uint,   1, 1048576,       nullptr, nullptr },
    { "QoS",    true, "0",          "0/1/2", AtArgType::Choice, 0,       0,       "0|1|2", nullptr },
    { "Retain", true, "0",          "0/1",   AtArgType::Bool01, 0,       0,       nullptr, nullptr },
};

// --- Actions ---
inline constexpr AtActionItem kAtMqttActions[] = {
    // Quectel QMT*
    { E("🔌"), "QMT open",      "AT+QMTOPEN=%1,\"%2\",%3", AtStandard::Quectel,
      "AT+QMTOPEN=0,\"broker.hivemq.com\",1883", false,
      kArgs_QMTOPEN, AT_COUNT_OF(kArgs_QMTOPEN) },

    { E("🔐"), "QMT connect",   "AT+QMTCONN=%1,\"%2\"",    AtStandard::Quectel,
      "AT+QMTCONN=0,\"client123\"", false,
      kArgs_QMTCONN, AT_COUNT_OF(kArgs_QMTCONN) },

    { E("📨"), "QMT publish",   "AT+QMTPUB=%1,%2,%3,%4,\"%5\"", AtStandard::Quectel,
      "AT+QMTPUB=0,1,0,0,\"test/topic\"", false,
      kArgs_QMTPUB, AT_COUNT_OF(kArgs_QMTPUB) },

    { E("📥"), "QMT subscribe", "AT+QMTSUB=%1,%2,\"%3\",%4", AtStandard::Quectel,
      "AT+QMTSUB=0,2,\"test/topic\",0", false,
      kArgs_QMTSUB, AT_COUNT_OF(kArgs_QMTSUB) },

    { E("🧹"), "QMT disconnect","AT+QMTDISC=%1",          AtStandard::Quectel,
      "AT+QMTDISC=0", false,
      kArgs_QMTDISC, AT_COUNT_OF(kArgs_QMTDISC) },

    // SIMCom SM*
    { E("🔗"), "SM connect",    "AT+SMCONN",              AtStandard::SIMCom,
      "AT+SMCONN", false, AT_NOARGS },

    { E("📨"), "SM publish",    "AT+SMPUB=\"%1\",%2,%3,%4", AtStandard::SIMCom,
      "AT+SMPUB=\"test/topic\",5,0,0", false,
      kArgs_SMPUB, AT_COUNT_OF(kArgs_SMPUB) },

    { E("🧹"), "SM disconnect", "AT+SMDISC",              AtStandard::SIMCom,
      "AT+SMDISC", false, AT_NOARGS },
};
inline constexpr size_t kAtMqttActionsCount = AT_COUNT_OF(kAtMqttActions);

// File Storage (Quectel + SIMCom)
inline constexpr AtActionArg kArgs_QFUPL[] = {
    { "Path",  true, "/dat/file.bin", nullptr, AtArgType::String, 0,        0,        nullptr, nullptr },
    { "Bytes", true, "1024",          nullptr, AtArgType::Uint,   1,  10485760,        nullptr, nullptr },
};

inline constexpr AtActionArg kArgs_QFDWL[] = {
    { "Path",  true, "/dat/file.bin", nullptr, AtArgType::String, 0,        0,        nullptr, nullptr },
};

inline constexpr AtActionArg kArgs_QFDEL[] = {
    { "Path",  true, "/dat/file.bin", nullptr, AtArgType::String, 0,        0,        nullptr, nullptr },
};

inline constexpr AtActionArg kArgs_CFSWFILE[] = {
    { "Path",   true, "/c/file.bin",  nullptr, AtArgType::String, 0,        0,        nullptr, nullptr },
    { "Offset", true, "0",            nullptr, AtArgType::Uint,   0,  10485760,        nullptr, nullptr },
    { "Length", true, "512",          nullptr, AtArgType::Uint,   1,  10485760,        nullptr, nullptr },
    { "Mode",   true, "10",  "vendor-defined", AtArgType::Uint,   0,       255,        nullptr, nullptr },
};

inline constexpr AtActionArg kArgs_CFSRFILE[] = {
    { "Path",   true, "/c/file.bin",  nullptr, AtArgType::String, 0,        0,        nullptr, nullptr },
    { "Offset", true, "0",            nullptr, AtArgType::Uint,   0,  10485760,        nullptr, nullptr },
    { "Length", true, "512",          nullptr, AtArgType::Uint,   1,  10485760,        nullptr, nullptr },
};

// --- Actions ---
inline constexpr AtActionItem kAtFsActions[] = {
    // Quectel QF*
    { E("📂"), "List files (Quectel)",     "AT+QFLST",                 AtStandard::Quectel,
      "AT+QFLST", false, AT_NOARGS },

    { E("🔧"), "Upload UART (Quectel)",   "AT+QFUPL=\"%1\",%2",       AtStandard::Quectel,
      "AT+QFUPL=\"/dat/cert.pem\",1024",   false,
      kArgs_QFUPL,   AT_COUNT_OF(kArgs_QFUPL) },

    { E("🔧"), "Download UART (Quectel)", "AT+QFDWL=\"%1\"",          AtStandard::Quectel,
      "AT+QFDWL=\"/dat/file.bin\"",        false,
      kArgs_QFDWL,   AT_COUNT_OF(kArgs_QFDWL) },

    { E("💣"), "Delete file (Quectel)",   "AT+QFDEL=\"%1\"",          AtStandard::Quectel,
      "AT+QFDEL=\"/dat/file.bin\"",        false,
      kArgs_QFDEL,   AT_COUNT_OF(kArgs_QFDEL) },

    // SIMCom CFS*
    { E("📌"), "Write file (SIMCom)",     "AT+CFSWFILE=\"%1\",%2,%3,%4", AtStandard::SIMCom,
      "AT+CFSWFILE=\"/c/cert.pem\",0,512,10", false,
      kArgs_CFSWFILE, AT_COUNT_OF(kArgs_CFSWFILE) },

    { E("📖"), "Read file (SIMCom)",       "AT+CFSRFILE=\"%1\",%2,%3", AtStandard::SIMCom,
      "AT+CFSRFILE=\"/c/file.bin\",0,512", false,
      kArgs_CFSRFILE, AT_COUNT_OF(kArgs_CFSRFILE) },
};
inline constexpr size_t kAtFsActionsCount = AT_COUNT_OF(kAtFsActions);

// ================== Selector ==================

inline AtActionSlice getAtActionsFor(AtMode m) noexcept {
    switch (m) {
        case AtMode::Config:        return AT_ACTIONS_OF(kAtConfigActions);
        case AtMode::Info:          return AT_ACTIONS_OF(kAtInfoActions);
        case AtMode::SimPin:        return AT_ACTIONS_OF(kAtSimPinActions);
        case AtMode::Network:       return AT_ACTIONS_OF(kAtNetworkActions);
        case AtMode::Calls:         return AT_ACTIONS_OF(kAtCallsActions);
        case AtMode::Sms:           return AT_ACTIONS_OF(kAtSmsActions);
        case AtMode::Phonebook:     return AT_ACTIONS_OF(kAtPhonebookActions);
        case AtMode::Ussd:          return AT_ACTIONS_OF(kAtUssdActions);
        case AtMode::Data:          return AT_ACTIONS_OF(kAtDataActions);
        case AtMode::TimeClock:     return AT_ACTIONS_OF(kAtTimeClockActions);
        case AtMode::TcpIp_Vendor:  return AT_ACTIONS_OF(kAtTcpIpActions);
        case AtMode::Http_Vendor:   return AT_ACTIONS_OF(kAtHttpActions);
        case AtMode::Gnss_Vendor:   return AT_ACTIONS_OF(kAtGnssActions);
        case AtMode::Lora:          return AT_ACTIONS_OF(kAtLoraActions);
        case AtMode::Audio:         return AT_ACTIONS_OF(kAtAudioActions);
        case AtMode::Power:         return AT_ACTIONS_OF(kAtPowerActions);
        case AtMode::Hardware:      return AT_ACTIONS_OF(kAtHardwareActions);
        case AtMode::Mqtt:          return AT_ACTIONS_OF(kAtMqttActions);
        case AtMode::Files:         return AT_ACTIONS_OF(kAtFsActions);
    }
    return AT_ACTIONS_OF(kAtConfigActions); // fallback
}