protobufs v2.8.0

bin/inject_nanopb_options.py

@@ -26,6 +26,13 @@ from typing import Any, Dict, List, Tuple
 # IntSize enum values from nanopb.proto
 INT_SIZE_ENUM = {8: "IS_8", 16: "IS_16", 32: "IS_32", 64: "IS_64"}
 
+# FieldType enum names from nanopb.proto.  Only FT_IGNORE carries meaning for a
+# Python client (the firmware omits the field entirely); the rest describe C
+# storage class, but are passed through so the descriptor mirrors the .options.
+FIELD_TYPE_ENUM = frozenset(
+    {"FT_DEFAULT", "FT_CALLBACK", "FT_POINTER", "FT_STATIC", "FT_IGNORE", "FT_INLINE"}
+)
+
 # Options that are valid proto FieldOptions and useful outside of C code generation.
 # We skip C-only options (anonymous_oneof, no_unions, skip_message, packed_struct,
 # packed_enum, mangle_names, callback_datatype, callback_function, descriptorsize,
@@ -36,6 +43,7 @@ FIELD_OPTIONS = frozenset(
         "max_length",
         "max_count",
         "int_size",
+        "type",
         "fixed_length",
         "fixed_count",
         "long_names",
@@ -122,6 +130,10 @@ def format_nanopb_opts(opts: Dict[str, Any]) -> str:
         if k == "int_size":
             enum_val = INT_SIZE_ENUM.get(v, f"IS_{v}")
             parts.append(f"(nanopb).int_size = {enum_val}")
+        elif k == "type":
+            if v not in FIELD_TYPE_ENUM:
+                raise ValueError(f"unknown nanopb field type {v!r}")
+            parts.append(f"(nanopb).type = {v}")
         elif isinstance(v, bool):
             parts.append(f"(nanopb).{k} = {'true' if v else 'false'}")
         else:

meshtastic/protobuf/admin_pb2.pyi

@@ -236,6 +236,10 @@ class AdminMessage(google.protobuf.message.Message):
         """
         TAK module config
         """
+        MESHBEACON_CONFIG: AdminMessage._ModuleConfigType.ValueType  # 16
+        """
+        Mesh Beacon module config
+        """
 
     class ModuleConfigType(_ModuleConfigType, metaclass=_ModuleConfigTypeEnumTypeWrapper):
         """
@@ -306,6 +310,10 @@ class AdminMessage(google.protobuf.message.Message):
     """
     TAK module config
     """
+    MESHBEACON_CONFIG: AdminMessage.ModuleConfigType.ValueType  # 16
+    """
+    Mesh Beacon module config
+    """
 
     class _BackupLocation:
         ValueType = typing.NewType("ValueType", builtins.int)
@@ -851,6 +859,8 @@ class LockdownAuth(google.protobuf.message.Message):
     BOOTS_REMAINING_FIELD_NUMBER: builtins.int
     VALID_UNTIL_EPOCH_FIELD_NUMBER: builtins.int
     LOCK_NOW_FIELD_NUMBER: builtins.int
+    MAX_SESSION_SECONDS_FIELD_NUMBER: builtins.int
+    DISABLE_FIELD_NUMBER: builtins.int
     passphrase: builtins.bytes
     """
     Passphrase bytes (1-32). Empty when lock_now is true.
@@ -876,6 +886,67 @@ class LockdownAuth(google.protobuf.message.Message):
     connection-level admin authorization, and reboot the device into
     the locked state. Always honoured regardless of current lock state.
     """
+    max_session_seconds: builtins.int
+    """
+    Optional per-boot uptime cap on the unlocked session, in seconds.
+    0 = unlimited (token-only enforcement, suitable for unattended
+    tower / infrastructure nodes).
+
+    When non-zero, the firmware arms an uptime timer at unlock. On
+    each expiry, while there is still boot-count budget, the firmware
+    decrements the on-flash boot count in place, revokes per-
+    connection admin auth (clients must re-authenticate to see
+    content), re-engages the screen lock, and re-arms the timer
+    without rebooting. Mesh routing keeps running across session
+    boundaries; only when the boot-count budget reaches zero does
+    the device hard-lock and reboot.
+
+    Total exposure ceiling = ((resolved boot count) + 1) * max_session_seconds.
+    The +1 accounts for the initial passphrase-unlocked session
+    itself, since boots_remaining is the number of subsequent
+    session rolls (each consuming one boot from the rollback ledger).
+    The resolved boot count is the value the firmware writes into the
+    token at unlock time: the client-supplied boots_remaining when
+    non-zero, otherwise the firmware default (TOKEN_DEFAULT_BOOTS).
+    Note that boots_remaining == 0 in this message means "use firmware
+    default", NOT "zero boots" — a client computing the ceiling for
+    display should mirror that resolution rather than multiplying the
+    raw request value.
+
+    The cap is persisted in the token, so it survives token-based
+    auto-unlock across reboots. Explicit operator Lock Now still
+    deletes the token and forces passphrase re-entry.
+
+    Uses millis() (CPU uptime), not wall-clock time, so the cap is
+    immune to GPS spoofing, RTC backup-battery removal, and Faraday
+    cage isolation — none of those move the uptime counter. The only
+    way to reset the session clock is a reboot, which costs a boot
+    from the on-flash, HMAC-bound counter.
+    """
+    disable: builtins.bool
+    """
+    Disable lockdown mode. Requires a valid passphrase in the same
+    message (the device must prove the operator owns it before
+    reverting at-rest encryption). On success the firmware decrypts
+    every stored config / channel / nodedb file back to plaintext,
+    removes the wrapped DEK, unlock token, monotonic-counter, and
+    backoff files, and reboots out of lockdown.
+
+    This is the inverse of the provision/unlock path: it is how the
+    client app's "lockdown mode" toggle returns a device to normal
+    operation.
+
+    NOT reversed by this operation: APPROTECT. Once the debug port
+    lockout has been burned (on silicon where it is effective) it is
+    permanent — disabling lockdown decrypts your data and removes the
+    access gates, but the SWD/JTAG port stays locked for the life of
+    the device (recoverable only via a full chip erase over a debug
+    probe, which destroys all data). Clients should make this
+    irreversibility clear at the moment lockdown is first enabled.
+
+    When true the passphrase field is still required; boots_remaining,
+    valid_until_epoch, max_session_seconds, and lock_now are ignored.
+    """
     def __init__(
         self,
         *,
@@ -883,8 +954,10 @@ class LockdownAuth(google.protobuf.message.Message):
         boots_remaining: builtins.int = ...,
         valid_until_epoch: builtins.int = ...,
         lock_now: builtins.bool = ...,
+        max_session_seconds: builtins.int = ...,
+        disable: builtins.bool = ...,
     ) -> None: ...
-    def ClearField(self, field_name: typing.Literal["boots_remaining", b"boots_remaining", "lock_now", b"lock_now", "passphrase", b"passphrase", "valid_until_epoch", b"valid_until_epoch"]) -> None: ...
+    def ClearField(self, field_name: typing.Literal["boots_remaining", b"boots_remaining", "disable", b"disable", "lock_now", b"lock_now", "max_session_seconds", b"max_session_seconds", "passphrase", b"passphrase", "valid_until_epoch", b"valid_until_epoch"]) -> None: ...
 
 global___LockdownAuth = LockdownAuth
 
@@ -900,6 +973,7 @@ class HamParameters(google.protobuf.message.Message):
     TX_POWER_FIELD_NUMBER: builtins.int
     FREQUENCY_FIELD_NUMBER: builtins.int
     SHORT_NAME_FIELD_NUMBER: builtins.int
+    LONG_NAME_FIELD_NUMBER: builtins.int
     call_sign: builtins.str
     """
     Amateur radio call sign, eg. KD2ABC
@@ -918,6 +992,11 @@ class HamParameters(google.protobuf.message.Message):
     """
     Optional short name of user
     """
+    long_name: builtins.str
+    """
+    Optional long name of user
+    Appended to callsign
+    """
     def __init__(
         self,
         *,
@@ -925,8 +1004,9 @@ class HamParameters(google.protobuf.message.Message):
         tx_power: builtins.int = ...,
         frequency: builtins.float = ...,
         short_name: builtins.str = ...,
+        long_name: builtins.str = ...,
     ) -> None: ...
-    def ClearField(self, field_name: typing.Literal["call_sign", b"call_sign", "frequency", b"frequency", "short_name", b"short_name", "tx_power", b"tx_power"]) -> None: ...
+    def ClearField(self, field_name: typing.Literal["call_sign", b"call_sign", "frequency", b"frequency", "long_name", b"long_name", "short_name", b"short_name", "tx_power", b"tx_power"]) -> None: ...
 
 global___HamParameters = HamParameters
 
@@ -1087,6 +1167,9 @@ class SensorConfig(google.protobuf.message.Message):
     SEN5X_CONFIG_FIELD_NUMBER: builtins.int
     SCD30_CONFIG_FIELD_NUMBER: builtins.int
     SHTXX_CONFIG_FIELD_NUMBER: builtins.int
+    DS248X_CONFIG_FIELD_NUMBER: builtins.int
+    SEN6X_CONFIG_FIELD_NUMBER: builtins.int
+    AS3935_CONFIG_FIELD_NUMBER: builtins.int
     @property
     def scd4x_config(self) -> global___SCD4X_config:
         """
@@ -1111,6 +1194,24 @@ class SensorConfig(google.protobuf.message.Message):
         SHTXX temperature and relative humidity sensor configuration
         """
 
+    @property
+    def ds248x_config(self) -> global___DS248X_config:
+        """
+        DS248X-800 temperature sensor configuration
+        """
+
+    @property
+    def sen6x_config(self) -> global___SEN6X_config:
+        """
+        SEN6X PM/RHT/VOC/NOx/CO2/HCHO Sensor configuration
+        """
+
+    @property
+    def as3935_config(self) -> global___AS3935_config:
+        """
+        AS3935 lightning sensor configuration
+        """
+
     def __init__(
         self,
         *,
@@ -1118,9 +1219,12 @@ class SensorConfig(google.protobuf.message.Message):
         sen5x_config: global___SEN5X_config | None = ...,
         scd30_config: global___SCD30_config | None = ...,
         shtxx_config: global___SHTXX_config | None = ...,
+        ds248x_config: global___DS248X_config | None = ...,
+        sen6x_config: global___SEN6X_config | None = ...,
+        as3935_config: global___AS3935_config | None = ...,
     ) -> None: ...
-    def HasField(self, field_name: typing.Literal["scd30_config", b"scd30_config", "scd4x_config", b"scd4x_config", "sen5x_config", b"sen5x_config", "shtxx_config", b"shtxx_config"]) -> builtins.bool: ...
-    def ClearField(self, field_name: typing.Literal["scd30_config", b"scd30_config", "scd4x_config", b"scd4x_config", "sen5x_config", b"sen5x_config", "shtxx_config", b"shtxx_config"]) -> None: ...
+    def HasField(self, field_name: typing.Literal["as3935_config", b"as3935_config", "ds248x_config", b"ds248x_config", "scd30_config", b"scd30_config", "scd4x_config", b"scd4x_config", "sen5x_config", b"sen5x_config", "sen6x_config", b"sen6x_config", "shtxx_config", b"shtxx_config"]) -> builtins.bool: ...
+    def ClearField(self, field_name: typing.Literal["as3935_config", b"as3935_config", "ds248x_config", b"ds248x_config", "scd30_config", b"scd30_config", "scd4x_config", b"scd4x_config", "sen5x_config", b"sen5x_config", "sen6x_config", b"sen6x_config", "shtxx_config", b"shtxx_config"]) -> None: ...
 
 global___SensorConfig = SensorConfig
 
@@ -1199,6 +1303,7 @@ class SEN5X_config(google.protobuf.message.Message):
 
     SET_TEMPERATURE_FIELD_NUMBER: builtins.int
     SET_ONE_SHOT_MODE_FIELD_NUMBER: builtins.int
+    START_FAN_CLEANING_FIELD_NUMBER: builtins.int
     set_temperature: builtins.float
     """
     Reference temperature in degC
@@ -1207,21 +1312,105 @@ class SEN5X_config(google.protobuf.message.Message):
     """
     One-shot mode (true for low power - one-shot mode, false for normal - continuous mode)
     """
+    start_fan_cleaning: builtins.bool
+    """
+    Trigger a fan cleaning cycle
+    """
     def __init__(
         self,
         *,
         set_temperature: builtins.float | None = ...,
         set_one_shot_mode: builtins.bool | None = ...,
+        start_fan_cleaning: builtins.bool | None = ...,
     ) -> None: ...
-    def HasField(self, field_name: typing.Literal["_set_one_shot_mode", b"_set_one_shot_mode", "_set_temperature", b"_set_temperature", "set_one_shot_mode", b"set_one_shot_mode", "set_temperature", b"set_temperature"]) -> builtins.bool: ...
-    def ClearField(self, field_name: typing.Literal["_set_one_shot_mode", b"_set_one_shot_mode", "_set_temperature", b"_set_temperature", "set_one_shot_mode", b"set_one_shot_mode", "set_temperature", b"set_temperature"]) -> None: ...
+    def HasField(self, field_name: typing.Literal["_set_one_shot_mode", b"_set_one_shot_mode", "_set_temperature", b"_set_temperature", "_start_fan_cleaning", b"_start_fan_cleaning", "set_one_shot_mode", b"set_one_shot_mode", "set_temperature", b"set_temperature", "start_fan_cleaning", b"start_fan_cleaning"]) -> builtins.bool: ...
+    def ClearField(self, field_name: typing.Literal["_set_one_shot_mode", b"_set_one_shot_mode", "_set_temperature", b"_set_temperature", "_start_fan_cleaning", b"_start_fan_cleaning", "set_one_shot_mode", b"set_one_shot_mode", "set_temperature", b"set_temperature", "start_fan_cleaning", b"start_fan_cleaning"]) -> None: ...
     @typing.overload
     def WhichOneof(self, oneof_group: typing.Literal["_set_one_shot_mode", b"_set_one_shot_mode"]) -> typing.Literal["set_one_shot_mode"] | None: ...
     @typing.overload
     def WhichOneof(self, oneof_group: typing.Literal["_set_temperature", b"_set_temperature"]) -> typing.Literal["set_temperature"] | None: ...
+    @typing.overload
+    def WhichOneof(self, oneof_group: typing.Literal["_start_fan_cleaning", b"_start_fan_cleaning"]) -> typing.Literal["start_fan_cleaning"] | None: ...
 
 global___SEN5X_config = SEN5X_config
 
+@typing.final
+class SEN6X_config(google.protobuf.message.Message):
+    DESCRIPTOR: google.protobuf.descriptor.Descriptor
+
+    SET_TEMPERATURE_FIELD_NUMBER: builtins.int
+    SET_ONE_SHOT_MODE_FIELD_NUMBER: builtins.int
+    START_FAN_CLEANING_FIELD_NUMBER: builtins.int
+    SET_ASC_FIELD_NUMBER: builtins.int
+    SET_TARGET_CO2_CONC_FIELD_NUMBER: builtins.int
+    SET_ALTITUDE_FIELD_NUMBER: builtins.int
+    SET_AMBIENT_PRESSURE_FIELD_NUMBER: builtins.int
+    FACTORY_RESET_FIELD_NUMBER: builtins.int
+    set_temperature: builtins.float
+    """
+    Reference temperature in degC
+    """
+    set_one_shot_mode: builtins.bool
+    """
+    One-shot mode (true for low power - one-shot mode, false for normal - continuous mode)
+    """
+    start_fan_cleaning: builtins.bool
+    """
+    Trigger a fan cleaning cycle
+    """
+    set_asc: builtins.bool
+    """
+    Set Automatic self-calibration enabled (CO2-capable variants only: SEN63C, SEN66, SEN69C)
+    """
+    set_target_co2_conc: builtins.int
+    """
+    Recalibration target CO2 concentration in ppm (FRC only), CO2-capable variants only
+    """
+    set_altitude: builtins.int
+    """
+    Altitude of sensor in meters above sea level. 0 - 3000m (overrides ambient pressure), CO2-capable variants only
+    """
+    set_ambient_pressure: builtins.int
+    """
+    Sensor ambient pressure in Pa. 70000 - 120000 Pa (overrides altitude), CO2-capable variants only
+    """
+    factory_reset: builtins.bool
+    """
+    Perform a factory reset of the CO2 sensor's calibration, CO2-capable variants only
+    """
+    def __init__(
+        self,
+        *,
+        set_temperature: builtins.float | None = ...,
+        set_one_shot_mode: builtins.bool | None = ...,
+        start_fan_cleaning: builtins.bool | None = ...,
+        set_asc: builtins.bool | None = ...,
+        set_target_co2_conc: builtins.int | None = ...,
+        set_altitude: builtins.int | None = ...,
+        set_ambient_pressure: builtins.int | None = ...,
+        factory_reset: builtins.bool | None = ...,
+    ) -> None: ...
+    def HasField(self, field_name: typing.Literal["_factory_reset", b"_factory_reset", "_set_altitude", b"_set_altitude", "_set_ambient_pressure", b"_set_ambient_pressure", "_set_asc", b"_set_asc", "_set_one_shot_mode", b"_set_one_shot_mode", "_set_target_co2_conc", b"_set_target_co2_conc", "_set_temperature", b"_set_temperature", "_start_fan_cleaning", b"_start_fan_cleaning", "factory_reset", b"factory_reset", "set_altitude", b"set_altitude", "set_ambient_pressure", b"set_ambient_pressure", "set_asc", b"set_asc", "set_one_shot_mode", b"set_one_shot_mode", "set_target_co2_conc", b"set_target_co2_conc", "set_temperature", b"set_temperature", "start_fan_cleaning", b"start_fan_cleaning"]) -> builtins.bool: ...
+    def ClearField(self, field_name: typing.Literal["_factory_reset", b"_factory_reset", "_set_altitude", b"_set_altitude", "_set_ambient_pressure", b"_set_ambient_pressure", "_set_asc", b"_set_asc", "_set_one_shot_mode", b"_set_one_shot_mode", "_set_target_co2_conc", b"_set_target_co2_conc", "_set_temperature", b"_set_temperature", "_start_fan_cleaning", b"_start_fan_cleaning", "factory_reset", b"factory_reset", "set_altitude", b"set_altitude", "set_ambient_pressure", b"set_ambient_pressure", "set_asc", b"set_asc", "set_one_shot_mode", b"set_one_shot_mode", "set_target_co2_conc", b"set_target_co2_conc", "set_temperature", b"set_temperature", "start_fan_cleaning", b"start_fan_cleaning"]) -> None: ...
+    @typing.overload
+    def WhichOneof(self, oneof_group: typing.Literal["_factory_reset", b"_factory_reset"]) -> typing.Literal["factory_reset"] | None: ...
+    @typing.overload
+    def WhichOneof(self, oneof_group: typing.Literal["_set_altitude", b"_set_altitude"]) -> typing.Literal["set_altitude"] | None: ...
+    @typing.overload
+    def WhichOneof(self, oneof_group: typing.Literal["_set_ambient_pressure", b"_set_ambient_pressure"]) -> typing.Literal["set_ambient_pressure"] | None: ...
+    @typing.overload
+    def WhichOneof(self, oneof_group: typing.Literal["_set_asc", b"_set_asc"]) -> typing.Literal["set_asc"] | None: ...
+    @typing.overload
+    def WhichOneof(self, oneof_group: typing.Literal["_set_one_shot_mode", b"_set_one_shot_mode"]) -> typing.Literal["set_one_shot_mode"] | None: ...
+    @typing.overload
+    def WhichOneof(self, oneof_group: typing.Literal["_set_target_co2_conc", b"_set_target_co2_conc"]) -> typing.Literal["set_target_co2_conc"] | None: ...
+    @typing.overload
+    def WhichOneof(self, oneof_group: typing.Literal["_set_temperature", b"_set_temperature"]) -> typing.Literal["set_temperature"] | None: ...
+    @typing.overload
+    def WhichOneof(self, oneof_group: typing.Literal["_start_fan_cleaning", b"_start_fan_cleaning"]) -> typing.Literal["start_fan_cleaning"] | None: ...
+
+global___SEN6X_config = SEN6X_config
+
 @typing.final
 class SCD30_config(google.protobuf.message.Message):
     DESCRIPTOR: google.protobuf.descriptor.Descriptor
@@ -1302,3 +1491,44 @@ class SHTXX_config(google.protobuf.message.Message):
     def WhichOneof(self, oneof_group: typing.Literal["_set_accuracy", b"_set_accuracy"]) -> typing.Literal["set_accuracy"] | None: ...
 
 global___SHTXX_config = SHTXX_config
+
+@typing.final
+class DS248X_config(google.protobuf.message.Message):
+    DESCRIPTOR: google.protobuf.descriptor.Descriptor
+
+    MAIN_TEMPERATURE_CHANNEL_FIELD_NUMBER: builtins.int
+    main_temperature_channel: builtins.int
+    """
+    Main channel for temperature reporting (0-7)
+    """
+    def __init__(
+        self,
+        *,
+        main_temperature_channel: builtins.int | None = ...,
+    ) -> None: ...
+    def HasField(self, field_name: typing.Literal["_main_temperature_channel", b"_main_temperature_channel", "main_temperature_channel", b"main_temperature_channel"]) -> builtins.bool: ...
+    def ClearField(self, field_name: typing.Literal["_main_temperature_channel", b"_main_temperature_channel", "main_temperature_channel", b"main_temperature_channel"]) -> None: ...
+    def WhichOneof(self, oneof_group: typing.Literal["_main_temperature_channel", b"_main_temperature_channel"]) -> typing.Literal["main_temperature_channel"] | None: ...
+
+global___DS248X_config = DS248X_config
+
+@typing.final
+class AS3935_config(google.protobuf.message.Message):
+    DESCRIPTOR: google.protobuf.descriptor.Descriptor
+
+    SET_TUNING_CAP_PF_FIELD_NUMBER: builtins.int
+    set_tuning_cap_pf: builtins.int
+    """
+    Antenna tuning capacitance in pF, 0 to 120 in steps of 8. The antenna tank must
+    resonate within 3.5% of 500kHz; the correct trim is specific to the sensor board.
+    """
+    def __init__(
+        self,
+        *,
+        set_tuning_cap_pf: builtins.int | None = ...,
+    ) -> None: ...
+    def HasField(self, field_name: typing.Literal["_set_tuning_cap_pf", b"_set_tuning_cap_pf", "set_tuning_cap_pf", b"set_tuning_cap_pf"]) -> builtins.bool: ...
+    def ClearField(self, field_name: typing.Literal["_set_tuning_cap_pf", b"_set_tuning_cap_pf", "set_tuning_cap_pf", b"set_tuning_cap_pf"]) -> None: ...
+    def WhichOneof(self, oneof_group: typing.Literal["_set_tuning_cap_pf", b"_set_tuning_cap_pf"]) -> typing.Literal["set_tuning_cap_pf"] | None: ...
+
+global___AS3935_config = AS3935_config

meshtastic/protobuf/clientonly_pb2.py

@@ -16,7 +16,7 @@ from meshtastic.protobuf import mesh_pb2 as meshtastic_dot_protobuf_dot_mesh__pb
 from meshtastic.protobuf import nanopb_pb2 as meshtastic_dot_protobuf_dot_nanopb__pb2
 
 
-DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n$meshtastic/protobuf/clientonly.proto\x12\x13meshtastic.protobuf\x1a#meshtastic/protobuf/localonly.proto\x1a\x1emeshtastic/protobuf/mesh.proto\x1a meshtastic/protobuf/nanopb.proto\"\xe2\x03\n\rDeviceProfile\x12\x1d\n\tlong_name\x18\x01 \x01(\tB\x05\x92?\x02\x08(H\x00\x88\x01\x01\x12\x1e\n\nshort_name\x18\x02 \x01(\tB\x05\x92?\x02\x08\x05H\x01\x88\x01\x01\x12\x18\n\x0b\x63hannel_url\x18\x03 \x01(\tH\x02\x88\x01\x01\x12\x35\n\x06\x63onfig\x18\x04 \x01(\x0b\x32 .meshtastic.protobuf.LocalConfigH\x03\x88\x01\x01\x12\x42\n\rmodule_config\x18\x05 \x01(\x0b\x32&.meshtastic.protobuf.LocalModuleConfigH\x04\x88\x01\x01\x12:\n\x0e\x66ixed_position\x18\x06 \x01(\x0b\x32\x1d.meshtastic.protobuf.PositionH\x05\x88\x01\x01\x12\x1d\n\x08ringtone\x18\x07 \x01(\tB\x06\x92?\x03\x08\xe7\x01H\x06\x88\x01\x01\x12$\n\x0f\x63\x61nned_messages\x18\x08 \x01(\tB\x06\x92?\x03\x08\xc9\x01H\x07\x88\x01\x01\x42\x0c\n\n_long_nameB\r\n\x0b_short_nameB\x0e\n\x0c_channel_urlB\t\n\x07_configB\x10\n\x0e_module_configB\x11\n\x0f_fixed_positionB\x0b\n\t_ringtoneB\x12\n\x10_canned_messagesBf\n\x14org.meshtastic.protoB\x10\x43lientOnlyProtosZ\"github.com/meshtastic/go/generated\xaa\x02\x14Meshtastic.Protobufs\xba\x02\x00\x62\x06proto3')
+DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n$meshtastic/protobuf/clientonly.proto\x12\x13meshtastic.protobuf\x1a#meshtastic/protobuf/localonly.proto\x1a\x1emeshtastic/protobuf/mesh.proto\x1a meshtastic/protobuf/nanopb.proto\"\xbe\x04\n\rDeviceProfile\x12\x1d\n\tlong_name\x18\x01 \x01(\tB\x05\x92?\x02\x08\x19H\x00\x88\x01\x01\x12\x1e\n\nshort_name\x18\x02 \x01(\tB\x05\x92?\x02\x08\x05H\x01\x88\x01\x01\x12\x18\n\x0b\x63hannel_url\x18\x03 \x01(\tH\x02\x88\x01\x01\x12\x35\n\x06\x63onfig\x18\x04 \x01(\x0b\x32 .meshtastic.protobuf.LocalConfigH\x03\x88\x01\x01\x12\x42\n\rmodule_config\x18\x05 \x01(\x0b\x32&.meshtastic.protobuf.LocalModuleConfigH\x04\x88\x01\x01\x12:\n\x0e\x66ixed_position\x18\x06 \x01(\x0b\x32\x1d.meshtastic.protobuf.PositionH\x05\x88\x01\x01\x12\x1d\n\x08ringtone\x18\x07 \x01(\tB\x06\x92?\x03\x08\xe7\x01H\x06\x88\x01\x01\x12$\n\x0f\x63\x61nned_messages\x18\x08 \x01(\tB\x06\x92?\x03\x08\xc9\x01H\x07\x88\x01\x01\x12\x1c\n\x0fis_unmessagable\x18\t \x01(\x08H\x08\x88\x01\x01\x12\x18\n\x0bis_licensed\x18\n \x01(\x08H\t\x88\x01\x01\x42\x0c\n\n_long_nameB\r\n\x0b_short_nameB\x0e\n\x0c_channel_urlB\t\n\x07_configB\x10\n\x0e_module_configB\x11\n\x0f_fixed_positionB\x0b\n\t_ringtoneB\x12\n\x10_canned_messagesB\x12\n\x10_is_unmessagableB\x0e\n\x0c_is_licensedBf\n\x14org.meshtastic.protoB\x10\x43lientOnlyProtosZ\"github.com/meshtastic/go/generated\xaa\x02\x14Meshtastic.Protobufs\xba\x02\x00\x62\x06proto3')
 
 _globals = globals()
 _builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals)
@@ -25,7 +25,7 @@ if _descriptor._USE_C_DESCRIPTORS == False:
   DESCRIPTOR._options = None
   DESCRIPTOR._serialized_options = b'\n\024org.meshtastic.protoB\020ClientOnlyProtosZ\"github.com/meshtastic/go/generated\252\002\024Meshtastic.Protobufs\272\002\000'
   _DEVICEPROFILE.fields_by_name['long_name']._options = None
-  _DEVICEPROFILE.fields_by_name['long_name']._serialized_options = b'\222?\002\010('
+  _DEVICEPROFILE.fields_by_name['long_name']._serialized_options = b'\222?\002\010\031'
   _DEVICEPROFILE.fields_by_name['short_name']._options = None
   _DEVICEPROFILE.fields_by_name['short_name']._serialized_options = b'\222?\002\010\005'
   _DEVICEPROFILE.fields_by_name['ringtone']._options = None
@@ -33,5 +33,5 @@ if _descriptor._USE_C_DESCRIPTORS == False:
   _DEVICEPROFILE.fields_by_name['canned_messages']._options = None
   _DEVICEPROFILE.fields_by_name['canned_messages']._serialized_options = b'\222?\003\010\311\001'
   _globals['_DEVICEPROFILE']._serialized_start=165
-  _globals['_DEVICEPROFILE']._serialized_end=647
+  _globals['_DEVICEPROFILE']._serialized_end=739
 # @@protoc_insertion_point(module_scope)

meshtastic/protobuf/clientonly_pb2.pyi

@@ -29,6 +29,8 @@ class DeviceProfile(google.protobuf.message.Message):
     FIXED_POSITION_FIELD_NUMBER: builtins.int
     RINGTONE_FIELD_NUMBER: builtins.int
     CANNED_MESSAGES_FIELD_NUMBER: builtins.int
+    IS_UNMESSAGABLE_FIELD_NUMBER: builtins.int
+    IS_LICENSED_FIELD_NUMBER: builtins.int
     long_name: builtins.str
     """
     Long name for the node
@@ -49,6 +51,14 @@ class DeviceProfile(google.protobuf.message.Message):
     """
     Predefined messages for CannedMessage
     """
+    is_unmessagable: builtins.bool
+    """
+    Is the node unmessagable
+    """
+    is_licensed: builtins.bool
+    """
+    Is this node in licensed user mode
+    """
     @property
     def config(self) -> meshtastic.protobuf.localonly_pb2.LocalConfig:
         """
@@ -78,9 +88,11 @@ class DeviceProfile(google.protobuf.message.Message):
         fixed_position: meshtastic.protobuf.mesh_pb2.Position | None = ...,
         ringtone: builtins.str | None = ...,
         canned_messages: builtins.str | None = ...,
+        is_unmessagable: builtins.bool | None = ...,
+        is_licensed: builtins.bool | None = ...,
     ) -> None: ...
-    def HasField(self, field_name: typing.Literal["_canned_messages", b"_canned_messages", "_channel_url", b"_channel_url", "_config", b"_config", "_fixed_position", b"_fixed_position", "_long_name", b"_long_name", "_module_config", b"_module_config", "_ringtone", b"_ringtone", "_short_name", b"_short_name", "canned_messages", b"canned_messages", "channel_url", b"channel_url", "config", b"config", "fixed_position", b"fixed_position", "long_name", b"long_name", "module_config", b"module_config", "ringtone", b"ringtone", "short_name", b"short_name"]) -> builtins.bool: ...
-    def ClearField(self, field_name: typing.Literal["_canned_messages", b"_canned_messages", "_channel_url", b"_channel_url", "_config", b"_config", "_fixed_position", b"_fixed_position", "_long_name", b"_long_name", "_module_config", b"_module_config", "_ringtone", b"_ringtone", "_short_name", b"_short_name", "canned_messages", b"canned_messages", "channel_url", b"channel_url", "config", b"config", "fixed_position", b"fixed_position", "long_name", b"long_name", "module_config", b"module_config", "ringtone", b"ringtone", "short_name", b"short_name"]) -> None: ...
+    def HasField(self, field_name: typing.Literal["_canned_messages", b"_canned_messages", "_channel_url", b"_channel_url", "_config", b"_config", "_fixed_position", b"_fixed_position", "_is_licensed", b"_is_licensed", "_is_unmessagable", b"_is_unmessagable", "_long_name", b"_long_name", "_module_config", b"_module_config", "_ringtone", b"_ringtone", "_short_name", b"_short_name", "canned_messages", b"canned_messages", "channel_url", b"channel_url", "config", b"config", "fixed_position", b"fixed_position", "is_licensed", b"is_licensed", "is_unmessagable", b"is_unmessagable", "long_name", b"long_name", "module_config", b"module_config", "ringtone", b"ringtone", "short_name", b"short_name"]) -> builtins.bool: ...
+    def ClearField(self, field_name: typing.Literal["_canned_messages", b"_canned_messages", "_channel_url", b"_channel_url", "_config", b"_config", "_fixed_position", b"_fixed_position", "_is_licensed", b"_is_licensed", "_is_unmessagable", b"_is_unmessagable", "_long_name", b"_long_name", "_module_config", b"_module_config", "_ringtone", b"_ringtone", "_short_name", b"_short_name", "canned_messages", b"canned_messages", "channel_url", b"channel_url", "config", b"config", "fixed_position", b"fixed_position", "is_licensed", b"is_licensed", "is_unmessagable", b"is_unmessagable", "long_name", b"long_name", "module_config", b"module_config", "ringtone", b"ringtone", "short_name", b"short_name"]) -> None: ...
     @typing.overload
     def WhichOneof(self, oneof_group: typing.Literal["_canned_messages", b"_canned_messages"]) -> typing.Literal["canned_messages"] | None: ...
     @typing.overload
@@ -90,6 +102,10 @@ class DeviceProfile(google.protobuf.message.Message):
     @typing.overload
     def WhichOneof(self, oneof_group: typing.Literal["_fixed_position", b"_fixed_position"]) -> typing.Literal["fixed_position"] | None: ...
     @typing.overload
+    def WhichOneof(self, oneof_group: typing.Literal["_is_licensed", b"_is_licensed"]) -> typing.Literal["is_licensed"] | None: ...
+    @typing.overload
+    def WhichOneof(self, oneof_group: typing.Literal["_is_unmessagable", b"_is_unmessagable"]) -> typing.Literal["is_unmessagable"] | None: ...
+    @typing.overload
     def WhichOneof(self, oneof_group: typing.Literal["_long_name", b"_long_name"]) -> typing.Literal["long_name"] | None: ...
     @typing.overload
     def WhichOneof(self, oneof_group: typing.Literal["_module_config", b"_module_config"]) -> typing.Literal["module_config"] | None: ...

meshtastic/protobuf/config_pb2.pyi

@@ -1402,6 +1402,27 @@ class Config(google.protobuf.message.Message):
             """
             ITU Region 3 Amateur Radio 2m band (144-148 MHz)
             """
+            ITU1_70CM: Config.LoRaConfig._RegionCode.ValueType  # 34
+            """
+            ITU Region 1 Amateur Radio 70cm band (430-440 MHz)
+            """
+            ITU2_70CM: Config.LoRaConfig._RegionCode.ValueType  # 35
+            """
+            ITU Region 2 Amateur Radio 70cm band (420-450 MHz)
+            Note: Some countries do not allocate 420-430 MHz or 440-450 MHz.
+            Check local law!
+            """
+            ITU3_70CM: Config.LoRaConfig._RegionCode.ValueType  # 36
+            """
+            ITU Region 3 Amateur Radio 70cm band (430-450 MHz)
+            Note: Some countries do not allocate 440-450 MHz. Check local law!
+            """
+            ITU2_125CM: Config.LoRaConfig._RegionCode.ValueType  # 37
+            """
+            ITU Region 2 Amateur Radio 1.25m '125cm' band (220-225 MHz)
+            Note: Some countries do not allocate 220-222 MHz (Ex: USA/Canada).
+            Check local law!
+            """
 
         class RegionCode(_RegionCode, metaclass=_RegionCodeEnumTypeWrapper): ...
         UNSET: Config.LoRaConfig.RegionCode.ValueType  # 0
@@ -1537,6 +1558,27 @@ class Config(google.protobuf.message.Message):
         """
         ITU Region 3 Amateur Radio 2m band (144-148 MHz)
         """
+        ITU1_70CM: Config.LoRaConfig.RegionCode.ValueType  # 34
+        """
+        ITU Region 1 Amateur Radio 70cm band (430-440 MHz)
+        """
+        ITU2_70CM: Config.LoRaConfig.RegionCode.ValueType  # 35
+        """
+        ITU Region 2 Amateur Radio 70cm band (420-450 MHz)
+        Note: Some countries do not allocate 420-430 MHz or 440-450 MHz.
+        Check local law!
+        """
+        ITU3_70CM: Config.LoRaConfig.RegionCode.ValueType  # 36
+        """
+        ITU Region 3 Amateur Radio 70cm band (430-450 MHz)
+        Note: Some countries do not allocate 440-450 MHz. Check local law!
+        """
+        ITU2_125CM: Config.LoRaConfig.RegionCode.ValueType  # 37
+        """
+        ITU Region 2 Amateur Radio 1.25m '125cm' band (220-225 MHz)
+        Note: Some countries do not allocate 220-222 MHz (Ex: USA/Canada).
+        Check local law!
+        """
 
         class _ModemPreset:
             ValueType = typing.NewType("ValueType", builtins.int)
@@ -1614,6 +1656,30 @@ class Config(google.protobuf.message.Message):
             Moderate range preset optimized for EU 868MHz band with 62.5kHz bandwidth.
             Comparable link budget and data rate to LONG_FAST.
             """
+            TINY_FAST: Config.LoRaConfig._ModemPreset.ValueType  # 14
+            """
+            Tiny Fast
+            Preset optimized for compliance with Amateur Radio restrictions with 20kHz bandwidth.
+            Many regions limit data transmission bandwidth in lower amateur bands (2 Meter).
+            Note: TCXO with tight tolerances (±5 ppm or better) is *absolutely required* at these narrow bandwidths.
+            Only compatible with SX127x and SX126x chipsets.
+            Comparable link budget and data rate to LONG_FAST.
+            """
+            TINY_SLOW: Config.LoRaConfig._ModemPreset.ValueType  # 15
+            """
+            Tiny Slow
+            Preset optimized for compliance with Amateur Radio restrictions with 20kHz bandwidth.
+            Many regions limit data transmission bandwidth in lower amateur bands (2 Meter).
+            Note: TCXO with tight tolerances (±5 ppm or better) is *absolutely required* at these narrow bandwidths.
+            Only compatible with SX127x and SX126x chipsets.
+            Comparable link budget and data rate to LONG_MODERATE.
+            """
+            MEDIUM_TURBO: Config.LoRaConfig._ModemPreset.ValueType  # 16
+            """
+            Medium Range - Turbo
+            This preset performs similarly to MEDIUM_FAST, but with 500kHz bandwidth.
+            It is not legal to use in all regions due to this wider bandwidth.
+            """
 
         class ModemPreset(_ModemPreset, metaclass=_ModemPresetEnumTypeWrapper):
             """
@@ -1691,6 +1757,30 @@ class Config(google.protobuf.message.Message):
         Moderate range preset optimized for EU 868MHz band with 62.5kHz bandwidth.
         Comparable link budget and data rate to LONG_FAST.
         """
+        TINY_FAST: Config.LoRaConfig.ModemPreset.ValueType  # 14
+        """
+        Tiny Fast
+        Preset optimized for compliance with Amateur Radio restrictions with 20kHz bandwidth.
+        Many regions limit data transmission bandwidth in lower amateur bands (2 Meter).
+        Note: TCXO with tight tolerances (±5 ppm or better) is *absolutely required* at these narrow bandwidths.
+        Only compatible with SX127x and SX126x chipsets.
+        Comparable link budget and data rate to LONG_FAST.
+        """
+        TINY_SLOW: Config.LoRaConfig.ModemPreset.ValueType  # 15
+        """
+        Tiny Slow
+        Preset optimized for compliance with Amateur Radio restrictions with 20kHz bandwidth.
+        Many regions limit data transmission bandwidth in lower amateur bands (2 Meter).
+        Note: TCXO with tight tolerances (±5 ppm or better) is *absolutely required* at these narrow bandwidths.
+        Only compatible with SX127x and SX126x chipsets.
+        Comparable link budget and data rate to LONG_MODERATE.
+        """
+        MEDIUM_TURBO: Config.LoRaConfig.ModemPreset.ValueType  # 16
+        """
+        Medium Range - Turbo
+        This preset performs similarly to MEDIUM_FAST, but with 500kHz bandwidth.
+        It is not legal to use in all regions due to this wider bandwidth.
+        """
 
         class _FEM_LNA_Mode:
             ValueType = typing.NewType("ValueType", builtins.int)
@@ -1949,6 +2039,49 @@ class Config(google.protobuf.message.Message):
     class SecurityConfig(google.protobuf.message.Message):
         DESCRIPTOR: google.protobuf.descriptor.Descriptor
 
+        class _PacketSignaturePolicy:
+            ValueType = typing.NewType("ValueType", builtins.int)
+            V: typing_extensions.TypeAlias = ValueType
+
+        class _PacketSignaturePolicyEnumTypeWrapper(google.protobuf.internal.enum_type_wrapper._EnumTypeWrapper[Config.SecurityConfig._PacketSignaturePolicy.ValueType], builtins.type):
+            DESCRIPTOR: google.protobuf.descriptor.EnumDescriptor
+            PACKET_SIGNATURE_POLICY_COMPATIBLE: Config.SecurityConfig._PacketSignaturePolicy.ValueType  # 0
+            """
+            Accept unsigned packets for maximum compatibility while still rejecting malformed or invalid signatures.
+            This is the default to avoid legacy nodes dropping signed packets during rebroadcast.
+            """
+            PACKET_SIGNATURE_POLICY_BALANCED: Config.SecurityConfig._PacketSignaturePolicy.ValueType  # 1
+            """
+            Prefer authenticated packets while retaining compatibility with unsigned packets from nodes not known to sign.
+            Rejects unsigned, signable broadcasts from nodes that have previously signed.
+            """
+            PACKET_SIGNATURE_POLICY_STRICT: Config.SecurityConfig._PacketSignaturePolicy.ValueType  # 2
+            """
+            Accept only packets authenticated by a verified XEdDSA signature or successful PKI decryption.
+            Unsigned, malformed, invalid, or unverifiable packets are ignored.
+            """
+
+        class PacketSignaturePolicy(_PacketSignaturePolicy, metaclass=_PacketSignaturePolicyEnumTypeWrapper):
+            """
+            Controls how the device authenticates remotely received mesh packets.
+            """
+
+        PACKET_SIGNATURE_POLICY_COMPATIBLE: Config.SecurityConfig.PacketSignaturePolicy.ValueType  # 0
+        """
+        Accept unsigned packets for maximum compatibility while still rejecting malformed or invalid signatures.
+        This is the default to avoid legacy nodes dropping signed packets during rebroadcast.
+        """
+        PACKET_SIGNATURE_POLICY_BALANCED: Config.SecurityConfig.PacketSignaturePolicy.ValueType  # 1
+        """
+        Prefer authenticated packets while retaining compatibility with unsigned packets from nodes not known to sign.
+        Rejects unsigned, signable broadcasts from nodes that have previously signed.
+        """
+        PACKET_SIGNATURE_POLICY_STRICT: Config.SecurityConfig.PacketSignaturePolicy.ValueType  # 2
+        """
+        Accept only packets authenticated by a verified XEdDSA signature or successful PKI decryption.
+        Unsigned, malformed, invalid, or unverifiable packets are ignored.
+        """
+
         PUBLIC_KEY_FIELD_NUMBER: builtins.int
         PRIVATE_KEY_FIELD_NUMBER: builtins.int
         ADMIN_KEY_FIELD_NUMBER: builtins.int
@@ -1956,6 +2089,7 @@ class Config(google.protobuf.message.Message):
         SERIAL_ENABLED_FIELD_NUMBER: builtins.int
         DEBUG_LOG_API_ENABLED_FIELD_NUMBER: builtins.int
         ADMIN_CHANNEL_ENABLED_FIELD_NUMBER: builtins.int
+        PACKET_SIGNATURE_POLICY_FIELD_NUMBER: builtins.int
         public_key: builtins.bytes
         """
         The public key of the user's device.
@@ -1984,6 +2118,10 @@ class Config(google.protobuf.message.Message):
         """
         Allow incoming device control over the insecure legacy admin channel.
         """
+        packet_signature_policy: global___Config.SecurityConfig.PacketSignaturePolicy.ValueType
+        """
+        Determines the packet signature policy applied to remotely received mesh packets.
+        """
         @property
         def admin_key(self) -> google.protobuf.internal.containers.RepeatedScalarFieldContainer[builtins.bytes]:
             """
@@ -2000,8 +2138,9 @@ class Config(google.protobuf.message.Message):
             serial_enabled: builtins.bool = ...,
             debug_log_api_enabled: builtins.bool = ...,
             admin_channel_enabled: builtins.bool = ...,
+            packet_signature_policy: global___Config.SecurityConfig.PacketSignaturePolicy.ValueType = ...,
         ) -> None: ...
-        def ClearField(self, field_name: typing.Literal["admin_channel_enabled", b"admin_channel_enabled", "admin_key", b"admin_key", "debug_log_api_enabled", b"debug_log_api_enabled", "is_managed", b"is_managed", "private_key", b"private_key", "public_key", b"public_key", "serial_enabled", b"serial_enabled"]) -> None: ...
+        def ClearField(self, field_name: typing.Literal["admin_channel_enabled", b"admin_channel_enabled", "admin_key", b"admin_key", "debug_log_api_enabled", b"debug_log_api_enabled", "is_managed", b"is_managed", "packet_signature_policy", b"packet_signature_policy", "private_key", b"private_key", "public_key", b"public_key", "serial_enabled", b"serial_enabled"]) -> None: ...
 
     @typing.final
     class SessionkeyConfig(google.protobuf.message.Message):

meshtastic/protobuf/deviceonly_legacy_pb2.py

@@ -0,0 +1,39 @@
+# -*- coding: utf-8 -*-
+# Generated by the protocol buffer compiler.  DO NOT EDIT!
+# source: meshtastic/protobuf/deviceonly_legacy.proto
+"""Generated protocol buffer code."""
+from google.protobuf import descriptor as _descriptor
+from google.protobuf import descriptor_pool as _descriptor_pool
+from google.protobuf import symbol_database as _symbol_database
+from google.protobuf.internal import builder as _builder
+# @@protoc_insertion_point(imports)
+
+_sym_db = _symbol_database.Default()
+
+
+from meshtastic.protobuf import deviceonly_pb2 as meshtastic_dot_protobuf_dot_deviceonly__pb2
+from meshtastic.protobuf import telemetry_pb2 as meshtastic_dot_protobuf_dot_telemetry__pb2
+from meshtastic.protobuf import nanopb_pb2 as meshtastic_dot_protobuf_dot_nanopb__pb2
+
+
+DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n+meshtastic/protobuf/deviceonly_legacy.proto\x12\x13meshtastic.protobuf\x1a$meshtastic/protobuf/deviceonly.proto\x1a#meshtastic/protobuf/telemetry.proto\x1a meshtastic/protobuf/nanopb.proto\"\x8c\x03\n\x13NodeInfoLite_Legacy\x12\x0b\n\x03num\x18\x01 \x01(\r\x12+\n\x04user\x18\x02 \x01(\x0b\x32\x1d.meshtastic.protobuf.UserLite\x12\x33\n\x08position\x18\x03 \x01(\x0b\x32!.meshtastic.protobuf.PositionLite\x12\x0b\n\x03snr\x18\x04 \x01(\x02\x12\x12\n\nlast_heard\x18\x05 \x01(\x07\x12:\n\x0e\x64\x65vice_metrics\x18\x06 \x01(\x0b\x32\".meshtastic.protobuf.DeviceMetrics\x12\x16\n\x07\x63hannel\x18\x07 \x01(\rB\x05\x92?\x02\x38\x08\x12\x10\n\x08via_mqtt\x18\x08 \x01(\x08\x12\x1d\n\thops_away\x18\t \x01(\rB\x05\x92?\x02\x38\x08H\x00\x88\x01\x01\x12\x13\n\x0bis_favorite\x18\n \x01(\x08\x12\x12\n\nis_ignored\x18\x0b \x01(\x08\x12\x17\n\x08next_hop\x18\x0c \x01(\rB\x05\x92?\x02\x38\x08\x12\x10\n\x08\x62itfield\x18\r \x01(\rB\x0c\n\n_hops_away\"\x92\x01\n\x13NodeDatabase_Legacy\x12\x0f\n\x07version\x18\x01 \x01(\r\x12j\n\x05nodes\x18\x02 \x03(\x0b\x32(.meshtastic.protobuf.NodeInfoLite_LegacyB1\x92?.\x92\x01+std::vector<meshtastic_NodeInfoLite_Legacy>Bt\n\x14org.meshtastic.protoB\x10\x44\x65viceOnlyLegacyZ\"github.com/meshtastic/go/generated\xaa\x02\x14Meshtastic.Protobufs\xba\x02\x00\x92?\x0b\xc2\x01\x08<vector>b\x06proto3')
+
+_globals = globals()
+_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals)
+_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'meshtastic.protobuf.deviceonly_legacy_pb2', _globals)
+if _descriptor._USE_C_DESCRIPTORS == False:
+  DESCRIPTOR._options = None
+  DESCRIPTOR._serialized_options = b'\n\024org.meshtastic.protoB\020DeviceOnlyLegacyZ\"github.com/meshtastic/go/generated\252\002\024Meshtastic.Protobufs\272\002\000\222?\013\302\001\010<vector>'
+  _NODEINFOLITE_LEGACY.fields_by_name['channel']._options = None
+  _NODEINFOLITE_LEGACY.fields_by_name['channel']._serialized_options = b'\222?\0028\010'
+  _NODEINFOLITE_LEGACY.fields_by_name['hops_away']._options = None
+  _NODEINFOLITE_LEGACY.fields_by_name['hops_away']._serialized_options = b'\222?\0028\010'
+  _NODEINFOLITE_LEGACY.fields_by_name['next_hop']._options = None
+  _NODEINFOLITE_LEGACY.fields_by_name['next_hop']._serialized_options = b'\222?\0028\010'
+  _NODEDATABASE_LEGACY.fields_by_name['nodes']._options = None
+  _NODEDATABASE_LEGACY.fields_by_name['nodes']._serialized_options = b'\222?.\222\001+std::vector<meshtastic_NodeInfoLite_Legacy>'
+  _globals['_NODEINFOLITE_LEGACY']._serialized_start=178
+  _globals['_NODEINFOLITE_LEGACY']._serialized_end=574
+  _globals['_NODEDATABASE_LEGACY']._serialized_start=577
+  _globals['_NODEDATABASE_LEGACY']._serialized_end=723
+# @@protoc_insertion_point(module_scope)

meshtastic/protobuf/deviceonly_legacy_pb2.pyi

@@ -0,0 +1,106 @@
+"""
+@generated by mypy-protobuf.  Do not edit manually!
+isort:skip_file
+"""
+
+import builtins
+import collections.abc
+import google.protobuf.descriptor
+import google.protobuf.internal.containers
+import google.protobuf.message
+import meshtastic.protobuf.deviceonly_pb2
+import meshtastic.protobuf.telemetry_pb2
+import typing
+
+DESCRIPTOR: google.protobuf.descriptor.FileDescriptor
+
+@typing.final
+class NodeInfoLite_Legacy(google.protobuf.message.Message):
+    """
+    Legacy NodeInfoLite descriptor used only to decode pre-split
+    /prefs/nodes.proto saves during the v24 -> v25 migration boot.
+    This preserves the original NodeInfoLite-compatible field numbers needed
+    to parse old wire bytes cleanly, including user (2), position (3),
+    device_metrics (6), and the legacy-only compatibility fields via_mqtt (8),
+    is_favorite (10), and is_ignored (11). Steady-state code does not use
+    this struct; it is dropped after migration completes. This file should be
+    removed once DEVICESTATE_MIN_VER advances past 24.
+    """
+
+    DESCRIPTOR: google.protobuf.descriptor.Descriptor
+
+    NUM_FIELD_NUMBER: builtins.int
+    USER_FIELD_NUMBER: builtins.int
+    POSITION_FIELD_NUMBER: builtins.int
+    SNR_FIELD_NUMBER: builtins.int
+    LAST_HEARD_FIELD_NUMBER: builtins.int
+    DEVICE_METRICS_FIELD_NUMBER: builtins.int
+    CHANNEL_FIELD_NUMBER: builtins.int
+    VIA_MQTT_FIELD_NUMBER: builtins.int
+    HOPS_AWAY_FIELD_NUMBER: builtins.int
+    IS_FAVORITE_FIELD_NUMBER: builtins.int
+    IS_IGNORED_FIELD_NUMBER: builtins.int
+    NEXT_HOP_FIELD_NUMBER: builtins.int
+    BITFIELD_FIELD_NUMBER: builtins.int
+    num: builtins.int
+    snr: builtins.float
+    last_heard: builtins.int
+    channel: builtins.int
+    via_mqtt: builtins.bool
+    hops_away: builtins.int
+    is_favorite: builtins.bool
+    is_ignored: builtins.bool
+    next_hop: builtins.int
+    bitfield: builtins.int
+    @property
+    def user(self) -> meshtastic.protobuf.deviceonly_pb2.UserLite: ...
+    @property
+    def position(self) -> meshtastic.protobuf.deviceonly_pb2.PositionLite: ...
+    @property
+    def device_metrics(self) -> meshtastic.protobuf.telemetry_pb2.DeviceMetrics: ...
+    def __init__(
+        self,
+        *,
+        num: builtins.int = ...,
+        user: meshtastic.protobuf.deviceonly_pb2.UserLite | None = ...,
+        position: meshtastic.protobuf.deviceonly_pb2.PositionLite | None = ...,
+        snr: builtins.float = ...,
+        last_heard: builtins.int = ...,
+        device_metrics: meshtastic.protobuf.telemetry_pb2.DeviceMetrics | None = ...,
+        channel: builtins.int = ...,
+        via_mqtt: builtins.bool = ...,
+        hops_away: builtins.int | None = ...,
+        is_favorite: builtins.bool = ...,
+        is_ignored: builtins.bool = ...,
+        next_hop: builtins.int = ...,
+        bitfield: builtins.int = ...,
+    ) -> None: ...
+    def HasField(self, field_name: typing.Literal["_hops_away", b"_hops_away", "device_metrics", b"device_metrics", "hops_away", b"hops_away", "position", b"position", "user", b"user"]) -> builtins.bool: ...
+    def ClearField(self, field_name: typing.Literal["_hops_away", b"_hops_away", "bitfield", b"bitfield", "channel", b"channel", "device_metrics", b"device_metrics", "hops_away", b"hops_away", "is_favorite", b"is_favorite", "is_ignored", b"is_ignored", "last_heard", b"last_heard", "next_hop", b"next_hop", "num", b"num", "position", b"position", "snr", b"snr", "user", b"user", "via_mqtt", b"via_mqtt"]) -> None: ...
+    def WhichOneof(self, oneof_group: typing.Literal["_hops_away", b"_hops_away"]) -> typing.Literal["hops_away"] | None: ...
+
+global___NodeInfoLite_Legacy = NodeInfoLite_Legacy
+
+@typing.final
+class NodeDatabase_Legacy(google.protobuf.message.Message):
+    """
+    Legacy NodeDatabase shape: one repeated array of fat NodeInfoLite_Legacy
+    with no satellite position/telemetry arrays.
+    """
+
+    DESCRIPTOR: google.protobuf.descriptor.Descriptor
+
+    VERSION_FIELD_NUMBER: builtins.int
+    NODES_FIELD_NUMBER: builtins.int
+    version: builtins.int
+    @property
+    def nodes(self) -> google.protobuf.internal.containers.RepeatedCompositeFieldContainer[global___NodeInfoLite_Legacy]: ...
+    def __init__(
+        self,
+        *,
+        version: builtins.int = ...,
+        nodes: collections.abc.Iterable[global___NodeInfoLite_Legacy] | None = ...,
+    ) -> None: ...
+    def ClearField(self, field_name: typing.Literal["nodes", b"nodes", "version", b"version"]) -> None: ...
+
+global___NodeDatabase_Legacy = NodeDatabase_Legacy

meshtastic/protobuf/deviceonly_pb2.pyi

@@ -30,6 +30,7 @@ class PositionLite(google.protobuf.message.Message):
     ALTITUDE_FIELD_NUMBER: builtins.int
     TIME_FIELD_NUMBER: builtins.int
     LOCATION_SOURCE_FIELD_NUMBER: builtins.int
+    PRECISION_BITS_FIELD_NUMBER: builtins.int
     latitude_i: builtins.int
     """
     The new preferred location encoding, multiply by 1e-7 to get degrees
@@ -55,6 +56,10 @@ class PositionLite(google.protobuf.message.Message):
     """
     TODO: REPLACE
     """
+    precision_bits: builtins.int
+    """
+    Indicates the bits of precision set by the sending node
+    """
     def __init__(
         self,
         *,
@@ -63,8 +68,9 @@ class PositionLite(google.protobuf.message.Message):
         altitude: builtins.int = ...,
         time: builtins.int = ...,
         location_source: meshtastic.protobuf.mesh_pb2.Position.LocSource.ValueType = ...,
+        precision_bits: builtins.int = ...,
     ) -> None: ...
-    def ClearField(self, field_name: typing.Literal["altitude", b"altitude", "latitude_i", b"latitude_i", "location_source", b"location_source", "longitude_i", b"longitude_i", "time", b"time"]) -> None: ...
+    def ClearField(self, field_name: typing.Literal["altitude", b"altitude", "latitude_i", b"latitude_i", "location_source", b"location_source", "longitude_i", b"longitude_i", "precision_bits", b"precision_bits", "time", b"time"]) -> None: ...
 
 global___PositionLite = PositionLite
 
@@ -142,26 +148,26 @@ class NodeInfoLite(google.protobuf.message.Message):
     DESCRIPTOR: google.protobuf.descriptor.Descriptor
 
     NUM_FIELD_NUMBER: builtins.int
-    USER_FIELD_NUMBER: builtins.int
-    POSITION_FIELD_NUMBER: builtins.int
     SNR_FIELD_NUMBER: builtins.int
     LAST_HEARD_FIELD_NUMBER: builtins.int
-    DEVICE_METRICS_FIELD_NUMBER: builtins.int
     CHANNEL_FIELD_NUMBER: builtins.int
-    VIA_MQTT_FIELD_NUMBER: builtins.int
     HOPS_AWAY_FIELD_NUMBER: builtins.int
-    IS_FAVORITE_FIELD_NUMBER: builtins.int
-    IS_IGNORED_FIELD_NUMBER: builtins.int
     NEXT_HOP_FIELD_NUMBER: builtins.int
     BITFIELD_FIELD_NUMBER: builtins.int
+    LONG_NAME_FIELD_NUMBER: builtins.int
+    SHORT_NAME_FIELD_NUMBER: builtins.int
+    HW_MODEL_FIELD_NUMBER: builtins.int
+    ROLE_FIELD_NUMBER: builtins.int
+    PUBLIC_KEY_FIELD_NUMBER: builtins.int
+    SNR_Q4_FIELD_NUMBER: builtins.int
     num: builtins.int
     """
     The node number
     """
     snr: builtins.float
     """
-    Returns the Signal-to-noise ratio (SNR) of the last received message,
-    as measured by the receiver. Return SNR of the last received message in dB
+    In-memory SNR of the last received message in dB. Not serialised directly:
+    always zeroed before encode; persisted as snr_q4 = 19 below.
     """
     last_heard: builtins.int
     """
@@ -171,72 +177,69 @@ class NodeInfoLite(google.protobuf.message.Message):
     """
     local channel index we heard that node on. Only populated if its not the default channel.
     """
-    via_mqtt: builtins.bool
-    """
-    True if we witnessed the node over MQTT instead of LoRA transport
-    """
     hops_away: builtins.int
     """
     Number of hops away from us this node is (0 if direct neighbor)
     """
-    is_favorite: builtins.bool
-    """
-    True if node is in our favorites list
-    Persists between NodeDB internal clean ups
-    """
-    is_ignored: builtins.bool
-    """
-    True if node is in our ignored list
-    Persists between NodeDB internal clean ups
-    """
     next_hop: builtins.int
     """
     Last byte of the node number of the node that should be used as the next hop to reach this node.
     """
     bitfield: builtins.int
     """
-    Bitfield for storing booleans.
-    LSB 0 is_key_manually_verified
-    LSB 1 is_muted
+    Bitfield for storing booleans. See NODEINFO_BITFIELD_* in src/mesh/NodeDB.h.
     """
-    @property
-    def user(self) -> global___UserLite:
-        """
-        The user info for this node
-        """
+    long_name: builtins.str
+    """Flattened user fields (formerly UserLite). macaddr dropped (deprecated 1.2.11).
 
-    @property
-    def position(self) -> global___PositionLite:
-        """
-        This position data. Note: before 1.2.14 we would also store the last time we've heard from this node in position.time, that is no longer true.
-        Position.time now indicates the last time we received a POSITION from that node.
-        """
-
-    @property
-    def device_metrics(self) -> meshtastic.protobuf.telemetry_pb2.DeviceMetrics:
-        """
-        The latest device metrics for the node.
-        """
 
+    A full name for this user, i.e. "Kevin Hester".
+    """
+    short_name: builtins.str
+    """
+    A VERY short name, ideally two characters or an emoji.
+    Suitable for a tiny OLED screen.
+    """
+    hw_model: meshtastic.protobuf.mesh_pb2.HardwareModel.ValueType
+    """
+    Hardware model the user's device is running.
+    """
+    role: meshtastic.protobuf.config_pb2.Config.DeviceConfig.Role.ValueType
+    """
+    The user's role in the mesh.
+    """
+    public_key: builtins.bytes
+    """
+    The public key of the user's device, for PKI-based encrypted DMs.
+    """
+    snr_q4: builtins.int
+    """
+    Q4-encoded SNR: dB × 4, sint32 zigzag. Matches RouteDiscovery convention.
+    Encode: snr_q4 = (int32_t)lroundf(snr * 4.0f). Decode: snr = snr_q4 / 4.0f.
+    float snr is always zeroed on disk; this field carries all persisted SNR.
+    A stored 0 does not by itself mean "unknown" here - see NODEINFO_BITFIELD_HAS_SNR in
+    src/mesh/NodeDB.h for the presence bit that disambiguates a genuine 0 dB reading from
+    "never measured".
+    """
     def __init__(
         self,
         *,
         num: builtins.int = ...,
-        user: global___UserLite | None = ...,
-        position: global___PositionLite | None = ...,
         snr: builtins.float = ...,
         last_heard: builtins.int = ...,
-        device_metrics: meshtastic.protobuf.telemetry_pb2.DeviceMetrics | None = ...,
         channel: builtins.int = ...,
-        via_mqtt: builtins.bool = ...,
         hops_away: builtins.int | None = ...,
-        is_favorite: builtins.bool = ...,
-        is_ignored: builtins.bool = ...,
         next_hop: builtins.int = ...,
         bitfield: builtins.int = ...,
+        long_name: builtins.str = ...,
+        short_name: builtins.str = ...,
+        hw_model: meshtastic.protobuf.mesh_pb2.HardwareModel.ValueType = ...,
+        role: meshtastic.protobuf.config_pb2.Config.DeviceConfig.Role.ValueType = ...,
+        public_key: builtins.bytes = ...,
+        snr_q4: builtins.int = ...,
     ) -> None: ...
-    def HasField(self, field_name: typing.Literal["_hops_away", b"_hops_away", "device_metrics", b"device_metrics", "hops_away", b"hops_away", "position", b"position", "user", b"user"]) -> builtins.bool: ...
-    def ClearField(self, field_name: typing.Literal["_hops_away", b"_hops_away", "bitfield", b"bitfield", "channel", b"channel", "device_metrics", b"device_metrics", "hops_away", b"hops_away", "is_favorite", b"is_favorite", "is_ignored", b"is_ignored", "last_heard", b"last_heard", "next_hop", b"next_hop", "num", b"num", "position", b"position", "snr", b"snr", "user", b"user", "via_mqtt", b"via_mqtt"]) -> None: ...
+    def HasField(self, field_name: typing.Literal["_hops_away", b"_hops_away", "hops_away", b"hops_away"]) -> builtins.bool: ...
+    def ClearField(self, field_name: typing.Literal["_hops_away", b"_hops_away", "bitfield", b"bitfield", "channel", b"channel", "hops_away", b"hops_away", "hw_model", b"hw_model", "last_heard", b"last_heard", "long_name", b"long_name", "next_hop", b"next_hop", "num", b"num", "public_key", b"public_key", "role", b"role", "short_name", b"short_name", "snr", b"snr", "snr_q4", b"snr_q4"]) -> None: ...
     def WhichOneof(self, oneof_group: typing.Literal["_hops_away", b"_hops_away"]) -> typing.Literal["hops_away"] | None: ...
 
 global___NodeInfoLite = NodeInfoLite
@@ -337,12 +340,100 @@ class DeviceState(google.protobuf.message.Message):
 
 global___DeviceState = DeviceState
 
+@typing.final
+class NodePositionEntry(google.protobuf.message.Message):
+    """Satellite per-node entries; stored alongside the slim NodeInfoLite so nodes
+    that never report don't pay the embedded cost.
+    """
+
+    DESCRIPTOR: google.protobuf.descriptor.Descriptor
+
+    NUM_FIELD_NUMBER: builtins.int
+    POSITION_FIELD_NUMBER: builtins.int
+    num: builtins.int
+    @property
+    def position(self) -> global___PositionLite: ...
+    def __init__(
+        self,
+        *,
+        num: builtins.int = ...,
+        position: global___PositionLite | None = ...,
+    ) -> None: ...
+    def HasField(self, field_name: typing.Literal["position", b"position"]) -> builtins.bool: ...
+    def ClearField(self, field_name: typing.Literal["num", b"num", "position", b"position"]) -> None: ...
+
+global___NodePositionEntry = NodePositionEntry
+
+@typing.final
+class NodeTelemetryEntry(google.protobuf.message.Message):
+    DESCRIPTOR: google.protobuf.descriptor.Descriptor
+
+    NUM_FIELD_NUMBER: builtins.int
+    DEVICE_METRICS_FIELD_NUMBER: builtins.int
+    num: builtins.int
+    @property
+    def device_metrics(self) -> meshtastic.protobuf.telemetry_pb2.DeviceMetrics: ...
+    def __init__(
+        self,
+        *,
+        num: builtins.int = ...,
+        device_metrics: meshtastic.protobuf.telemetry_pb2.DeviceMetrics | None = ...,
+    ) -> None: ...
+    def HasField(self, field_name: typing.Literal["device_metrics", b"device_metrics"]) -> builtins.bool: ...
+    def ClearField(self, field_name: typing.Literal["device_metrics", b"device_metrics", "num", b"num"]) -> None: ...
+
+global___NodeTelemetryEntry = NodeTelemetryEntry
+
+@typing.final
+class NodeEnvironmentEntry(google.protobuf.message.Message):
+    DESCRIPTOR: google.protobuf.descriptor.Descriptor
+
+    NUM_FIELD_NUMBER: builtins.int
+    ENVIRONMENT_METRICS_FIELD_NUMBER: builtins.int
+    num: builtins.int
+    @property
+    def environment_metrics(self) -> meshtastic.protobuf.telemetry_pb2.EnvironmentMetrics: ...
+    def __init__(
+        self,
+        *,
+        num: builtins.int = ...,
+        environment_metrics: meshtastic.protobuf.telemetry_pb2.EnvironmentMetrics | None = ...,
+    ) -> None: ...
+    def HasField(self, field_name: typing.Literal["environment_metrics", b"environment_metrics"]) -> builtins.bool: ...
+    def ClearField(self, field_name: typing.Literal["environment_metrics", b"environment_metrics", "num", b"num"]) -> None: ...
+
+global___NodeEnvironmentEntry = NodeEnvironmentEntry
+
+@typing.final
+class NodeStatusEntry(google.protobuf.message.Message):
+    DESCRIPTOR: google.protobuf.descriptor.Descriptor
+
+    NUM_FIELD_NUMBER: builtins.int
+    STATUS_FIELD_NUMBER: builtins.int
+    num: builtins.int
+    @property
+    def status(self) -> meshtastic.protobuf.mesh_pb2.StatusMessage: ...
+    def __init__(
+        self,
+        *,
+        num: builtins.int = ...,
+        status: meshtastic.protobuf.mesh_pb2.StatusMessage | None = ...,
+    ) -> None: ...
+    def HasField(self, field_name: typing.Literal["status", b"status"]) -> builtins.bool: ...
+    def ClearField(self, field_name: typing.Literal["num", b"num", "status", b"status"]) -> None: ...
+
+global___NodeStatusEntry = NodeStatusEntry
+
 @typing.final
 class NodeDatabase(google.protobuf.message.Message):
     DESCRIPTOR: google.protobuf.descriptor.Descriptor
 
     VERSION_FIELD_NUMBER: builtins.int
     NODES_FIELD_NUMBER: builtins.int
+    POSITIONS_FIELD_NUMBER: builtins.int
+    TELEMETRY_FIELD_NUMBER: builtins.int
+    STATUS_FIELD_NUMBER: builtins.int
+    ENVIRONMENT_FIELD_NUMBER: builtins.int
     version: builtins.int
     """
     A version integer used to invalidate old save files when we make
@@ -355,13 +446,29 @@ class NodeDatabase(google.protobuf.message.Message):
         New lite version of NodeDB to decrease memory footprint
         """
 
+    @property
+    def positions(self) -> google.protobuf.internal.containers.RepeatedCompositeFieldContainer[global___NodePositionEntry]:
+        """Per-NodeNum satellite arrays. Constrained platforms (e.g. STM32WL) omit
+        these via MESHTASTIC_EXCLUDE_*DB build flags.
+        """
+
+    @property
+    def telemetry(self) -> google.protobuf.internal.containers.RepeatedCompositeFieldContainer[global___NodeTelemetryEntry]: ...
+    @property
+    def status(self) -> google.protobuf.internal.containers.RepeatedCompositeFieldContainer[global___NodeStatusEntry]: ...
+    @property
+    def environment(self) -> google.protobuf.internal.containers.RepeatedCompositeFieldContainer[global___NodeEnvironmentEntry]: ...
     def __init__(
         self,
         *,
         version: builtins.int = ...,
         nodes: collections.abc.Iterable[global___NodeInfoLite] | None = ...,
+        positions: collections.abc.Iterable[global___NodePositionEntry] | None = ...,
+        telemetry: collections.abc.Iterable[global___NodeTelemetryEntry] | None = ...,
+        status: collections.abc.Iterable[global___NodeStatusEntry] | None = ...,
+        environment: collections.abc.Iterable[global___NodeEnvironmentEntry] | None = ...,
     ) -> None: ...
-    def ClearField(self, field_name: typing.Literal["nodes", b"nodes", "version", b"version"]) -> None: ...
+    def ClearField(self, field_name: typing.Literal["environment", b"environment", "nodes", b"nodes", "positions", b"positions", "status", b"status", "telemetry", b"telemetry", "version", b"version"]) -> None: ...
 
 global___NodeDatabase = NodeDatabase
 

meshtastic/protobuf/interdevice_pb2.py

@@ -14,7 +14,7 @@ _sym_db = _symbol_database.Default()
 from meshtastic.protobuf import nanopb_pb2 as meshtastic_dot_protobuf_dot_nanopb__pb2
 
 
-DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n%meshtastic/protobuf/interdevice.proto\x12\x13meshtastic.protobuf\x1a meshtastic/protobuf/nanopb.proto\"s\n\nSensorData\x12.\n\x04type\x18\x01 \x01(\x0e\x32 .meshtastic.protobuf.MessageType\x12\x15\n\x0b\x66loat_value\x18\x02 \x01(\x02H\x00\x12\x16\n\x0cuint32_value\x18\x03 \x01(\rH\x00\x42\x06\n\x04\x64\x61ta\"g\n\x12InterdeviceMessage\x12\x16\n\x04nmea\x18\x01 \x01(\tB\x06\x92?\x03\x08\x80\x08H\x00\x12\x31\n\x06sensor\x18\x02 \x01(\x0b\x32\x1f.meshtastic.protobuf.SensorDataH\x00\x42\x06\n\x04\x64\x61ta*\xd5\x01\n\x0bMessageType\x12\x07\n\x03\x41\x43K\x10\x00\x12\x15\n\x10\x43OLLECT_INTERVAL\x10\xa0\x01\x12\x0c\n\x07\x42\x45\x45P_ON\x10\xa1\x01\x12\r\n\x08\x42\x45\x45P_OFF\x10\xa2\x01\x12\r\n\x08SHUTDOWN\x10\xa3\x01\x12\r\n\x08POWER_ON\x10\xa4\x01\x12\x0f\n\nSCD41_TEMP\x10\xb0\x01\x12\x13\n\x0eSCD41_HUMIDITY\x10\xb1\x01\x12\x0e\n\tSCD41_CO2\x10\xb2\x01\x12\x0f\n\nAHT20_TEMP\x10\xb3\x01\x12\x13\n\x0e\x41HT20_HUMIDITY\x10\xb4\x01\x12\x0f\n\nTVOC_INDEX\x10\xb5\x01\x42g\n\x14org.meshtastic.protoB\x11InterdeviceProtosZ\"github.com/meshtastic/go/generated\xaa\x02\x14Meshtastic.Protobufs\xba\x02\x00\x62\x06proto3')
+DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n%meshtastic/protobuf/interdevice.proto\x12\x13meshtastic.protobuf\x1a meshtastic/protobuf/nanopb.proto\"\xf6\x01\n\x0c\x46ileTransfer\x12\x35\n\toperation\x18\x01 \x01(\x0e\x32\".meshtastic.protobuf.FileOperation\x12\x18\n\x08\x66ilepath\x18\x02 \x01(\tB\x06\x92?\x03\x08\x80\x02\x12\x18\n\x08\x66iledata\x18\x03 \x01(\x0c\x42\x06\x92?\x03\x08\x80 \x12/\n\x06status\x18\x04 \x01(\x0e\x32\x1f.meshtastic.protobuf.FileStatus\x12\x17\n\x07message\x18\x05 \x01(\tB\x06\x92?\x03\x08\xff\x01\x12\x0e\n\x06offset\x18\x06 \x01(\x04\x12\x0e\n\x06length\x18\x07 \x01(\r\x12\x11\n\tfile_size\x18\x08 \x01(\x04\"\xb9\x01\n\x10\x44irectoryListing\x12\x19\n\tdirectory\x18\x01 \x01(\tB\x06\x92?\x03\x08\x80\x02\x12\x1b\n\tfilenames\x18\x02 \x03(\tB\x08\x92?\x05\x10\x10p\xff\x01\x12/\n\x06status\x18\x03 \x01(\x0e\x32\x1f.meshtastic.protobuf.FileStatus\x12\x17\n\x07message\x18\x04 \x01(\tB\x06\x92?\x03\x08\xff\x01\x12\x0e\n\x06offset\x18\x05 \x01(\r\x12\x13\n\x0btotal_count\x18\x06 \x01(\r\"O\n\x0eI2CTransaction\x12\x0f\n\x07\x61\x64\x64ress\x18\x01 \x01(\r\x12\x1a\n\nwrite_data\x18\x02 \x01(\x0c\x42\x06\x92?\x03\x08\x80\x02\x12\x10\n\x08read_len\x18\x03 \x01(\r\"\x92\x03\n\nSdCardInfo\x12\x0f\n\x07present\x18\x01 \x01(\x08\x12;\n\tcard_type\x18\x02 \x01(\x0e\x32(.meshtastic.protobuf.SdCardInfo.CardType\x12\x39\n\x08\x66\x61t_type\x18\x03 \x01(\x0e\x32\'.meshtastic.protobuf.SdCardInfo.FatType\x12\x11\n\tcard_size\x18\x04 \x01(\x04\x12\x12\n\nused_bytes\x18\x05 \x01(\x04\x12\x12\n\nfree_bytes\x18\x06 \x01(\x04\x12\x13\n\x0bstats_valid\x18\x07 \x01(\x08\x12\x0c\n\x04\x62usy\x18\x08 \x01(\x08\x12\x13\n\x0bunformatted\x18\t \x01(\x08\"K\n\x08\x43\x61rdType\x12\x08\n\x04NONE\x10\x00\x12\x07\n\x03MMC\x10\x01\x12\x06\n\x02SD\x10\x02\x12\x08\n\x04SDHC\x10\x03\x12\x08\n\x04SDXC\x10\x04\x12\x10\n\x0cUNKNOWN_CARD\x10\x05\";\n\x07\x46\x61tType\x12\x0f\n\x0bUNKNOWN_FAT\x10\x00\x12\t\n\x05\x46\x41T16\x10\x01\x12\t\n\x05\x46\x41T32\x10\x02\x12\t\n\x05\x45XFAT\x10\x03\"\xac\x01\n\tI2CResult\x12\x35\n\x06status\x18\x01 \x01(\x0e\x32%.meshtastic.protobuf.I2CResult.Status\x12\x19\n\tread_data\x18\x02 \x01(\x0c\x42\x06\x92?\x03\x08\x80\x02\"M\n\x06Status\x12\x0f\n\x0bUNSPECIFIED\x10\x00\x12\x06\n\x02OK\x10\x01\x12\x10\n\x0cNACK_ADDRESS\x10\x02\x12\r\n\tNACK_DATA\x10\x03\x12\t\n\x05\x45RROR\x10\x04\"\x87\x05\n\x12InterdeviceMessage\x12\n\n\x02id\x18\x0f \x01(\r\x12\x16\n\x04nmea\x18\x01 \x01(\tB\x06\x92?\x03\x08\x80\x08H\x00\x12\x15\n\x04\x62\x65\x65p\x18\x02 \x01(\rB\x05\x92?\x02\x38\x10H\x00\x12>\n\x0fi2c_transaction\x18\x03 \x01(\x0b\x32#.meshtastic.protobuf.I2CTransactionH\x00\x12\x34\n\ni2c_result\x18\x04 \x01(\x0b\x32\x1e.meshtastic.protobuf.I2CResultH\x00\x12\x12\n\x08i2c_scan\x18\x05 \x01(\x08H\x00\x12!\n\x0fi2c_scan_result\x18\x06 \x01(\x0c\x42\x06\x92?\x03\x08\x80\x01H\x00\x12:\n\rfile_transfer\x18\x07 \x01(\x0b\x32!.meshtastic.protobuf.FileTransferH\x00\x12\x42\n\x11\x64irectory_listing\x18\x08 \x01(\x0b\x32%.meshtastic.protobuf.DirectoryListingH\x00\x12\x15\n\x0bget_sd_info\x18\t \x01(\x08H\x00\x12\x32\n\x07sd_info\x18\n \x01(\x0b\x32\x1f.meshtastic.protobuf.SdCardInfoH\x00\x12\x37\n\x04ping\x18\x0b \x01(\x0e\x32\'.meshtastic.protobuf.InterdeviceVersionH\x00\x12\x37\n\x04pong\x18\x0c \x01(\x0e\x32\'.meshtastic.protobuf.InterdeviceVersionH\x00\x12\x0e\n\x04nack\x18\r \x01(\x08H\x00\x12\x34\n\nsd_command\x18\x0e \x01(\x0e\x32\x1e.meshtastic.protobuf.SdCommandH\x00\x42\x06\n\x04\x64\x61ta*Z\n\x12InterdeviceVersion\x12#\n\x1fINTERDEVICE_VERSION_UNSPECIFIED\x10\x00\x12\x1f\n\x1bINTERDEVICE_VERSION_CURRENT\x10\x02*7\n\rFileOperation\x12\x07\n\x03GET\x10\x00\x12\x08\n\x04POST\x10\x01\x12\x07\n\x03PUT\x10\x02\x12\n\n\x06\x44\x45LETE\x10\x03*\xa6\x01\n\nFileStatus\x12\x14\n\x10\x46ILE_UNSPECIFIED\x10\x00\x12\x0b\n\x07\x46ILE_OK\x10\x01\x12\r\n\tFILE_BUSY\x10\x02\x12\x10\n\x0c\x46ILE_NO_CARD\x10\x03\x12\x12\n\x0e\x46ILE_NOT_FOUND\x10\x04\x12\x18\n\x14\x46ILE_OFFSET_CONFLICT\x10\x05\x12\x11\n\rFILE_IO_ERROR\x10\x06\x12\x13\n\x0f\x46ILE_NOT_A_FILE\x10\x07*R\n\tSdCommand\x12\x1a\n\x16SD_COMMAND_UNSPECIFIED\x10\x00\x12\x0c\n\x08SD_MOUNT\x10\x01\x12\x0c\n\x08SD_EJECT\x10\x02\x12\r\n\tSD_FORMAT\x10\x03\x42g\n\x14org.meshtastic.protoB\x11InterdeviceProtosZ\"github.com/meshtastic/go/generated\xaa\x02\x14Meshtastic.Protobufs\xba\x02\x00\x62\x06proto3')
 
 _globals = globals()
 _builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals)
@@ -22,12 +22,52 @@ _builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'meshtastic.protobuf.interde
 if _descriptor._USE_C_DESCRIPTORS == False:
   DESCRIPTOR._options = None
   DESCRIPTOR._serialized_options = b'\n\024org.meshtastic.protoB\021InterdeviceProtosZ\"github.com/meshtastic/go/generated\252\002\024Meshtastic.Protobufs\272\002\000'
+  _FILETRANSFER.fields_by_name['filepath']._options = None
+  _FILETRANSFER.fields_by_name['filepath']._serialized_options = b'\222?\003\010\200\002'
+  _FILETRANSFER.fields_by_name['filedata']._options = None
+  _FILETRANSFER.fields_by_name['filedata']._serialized_options = b'\222?\003\010\200 '
+  _FILETRANSFER.fields_by_name['message']._options = None
+  _FILETRANSFER.fields_by_name['message']._serialized_options = b'\222?\003\010\377\001'
+  _DIRECTORYLISTING.fields_by_name['directory']._options = None
+  _DIRECTORYLISTING.fields_by_name['directory']._serialized_options = b'\222?\003\010\200\002'
+  _DIRECTORYLISTING.fields_by_name['filenames']._options = None
+  _DIRECTORYLISTING.fields_by_name['filenames']._serialized_options = b'\222?\005\020\020p\377\001'
+  _DIRECTORYLISTING.fields_by_name['message']._options = None
+  _DIRECTORYLISTING.fields_by_name['message']._serialized_options = b'\222?\003\010\377\001'
+  _I2CTRANSACTION.fields_by_name['write_data']._options = None
+  _I2CTRANSACTION.fields_by_name['write_data']._serialized_options = b'\222?\003\010\200\002'
+  _I2CRESULT.fields_by_name['read_data']._options = None
+  _I2CRESULT.fields_by_name['read_data']._serialized_options = b'\222?\003\010\200\002'
   _INTERDEVICEMESSAGE.fields_by_name['nmea']._options = None
   _INTERDEVICEMESSAGE.fields_by_name['nmea']._serialized_options = b'\222?\003\010\200\010'
-  _globals['_MESSAGETYPE']._serialized_start=319
-  _globals['_MESSAGETYPE']._serialized_end=532
-  _globals['_SENSORDATA']._serialized_start=96
-  _globals['_SENSORDATA']._serialized_end=211
-  _globals['_INTERDEVICEMESSAGE']._serialized_start=213
-  _globals['_INTERDEVICEMESSAGE']._serialized_end=316
+  _INTERDEVICEMESSAGE.fields_by_name['beep']._options = None
+  _INTERDEVICEMESSAGE.fields_by_name['beep']._serialized_options = b'\222?\0028\020'
+  _INTERDEVICEMESSAGE.fields_by_name['i2c_scan_result']._options = None
+  _INTERDEVICEMESSAGE.fields_by_name['i2c_scan_result']._serialized_options = b'\222?\003\010\200\001'
+  _globals['_INTERDEVICEVERSION']._serialized_start=1844
+  _globals['_INTERDEVICEVERSION']._serialized_end=1934
+  _globals['_FILEOPERATION']._serialized_start=1936
+  _globals['_FILEOPERATION']._serialized_end=1991
+  _globals['_FILESTATUS']._serialized_start=1994
+  _globals['_FILESTATUS']._serialized_end=2160
+  _globals['_SDCOMMAND']._serialized_start=2162
+  _globals['_SDCOMMAND']._serialized_end=2244
+  _globals['_FILETRANSFER']._serialized_start=97
+  _globals['_FILETRANSFER']._serialized_end=343
+  _globals['_DIRECTORYLISTING']._serialized_start=346
+  _globals['_DIRECTORYLISTING']._serialized_end=531
+  _globals['_I2CTRANSACTION']._serialized_start=533
+  _globals['_I2CTRANSACTION']._serialized_end=612
+  _globals['_SDCARDINFO']._serialized_start=615
+  _globals['_SDCARDINFO']._serialized_end=1017
+  _globals['_SDCARDINFO_CARDTYPE']._serialized_start=881
+  _globals['_SDCARDINFO_CARDTYPE']._serialized_end=956
+  _globals['_SDCARDINFO_FATTYPE']._serialized_start=958
+  _globals['_SDCARDINFO_FATTYPE']._serialized_end=1017
+  _globals['_I2CRESULT']._serialized_start=1020
+  _globals['_I2CRESULT']._serialized_end=1192
+  _globals['_I2CRESULT_STATUS']._serialized_start=1115
+  _globals['_I2CRESULT_STATUS']._serialized_end=1192
+  _globals['_INTERDEVICEMESSAGE']._serialized_start=1195
+  _globals['_INTERDEVICEMESSAGE']._serialized_end=1842
 # @@protoc_insertion_point(module_scope)

meshtastic/protobuf/interdevice_pb2.pyi

@@ -4,7 +4,9 @@ isort:skip_file
 """
 
 import builtins
+import collections.abc
 import google.protobuf.descriptor
+import google.protobuf.internal.containers
 import google.protobuf.internal.enum_type_wrapper
 import google.protobuf.message
 import sys
@@ -17,89 +19,476 @@ else:
 
 DESCRIPTOR: google.protobuf.descriptor.FileDescriptor
 
-class _MessageType:
+class _InterdeviceVersion:
     ValueType = typing.NewType("ValueType", builtins.int)
     V: typing_extensions.TypeAlias = ValueType
 
-class _MessageTypeEnumTypeWrapper(google.protobuf.internal.enum_type_wrapper._EnumTypeWrapper[_MessageType.ValueType], builtins.type):
+class _InterdeviceVersionEnumTypeWrapper(google.protobuf.internal.enum_type_wrapper._EnumTypeWrapper[_InterdeviceVersion.ValueType], builtins.type):
     DESCRIPTOR: google.protobuf.descriptor.EnumDescriptor
-    ACK: _MessageType.ValueType  # 0
-    COLLECT_INTERVAL: _MessageType.ValueType  # 160
-    """in ms"""
-    BEEP_ON: _MessageType.ValueType  # 161
-    """duration ms"""
-    BEEP_OFF: _MessageType.ValueType  # 162
-    """cancel prematurely"""
-    SHUTDOWN: _MessageType.ValueType  # 163
-    POWER_ON: _MessageType.ValueType  # 164
-    SCD41_TEMP: _MessageType.ValueType  # 176
-    SCD41_HUMIDITY: _MessageType.ValueType  # 177
-    SCD41_CO2: _MessageType.ValueType  # 178
-    AHT20_TEMP: _MessageType.ValueType  # 179
-    AHT20_HUMIDITY: _MessageType.ValueType  # 180
-    TVOC_INDEX: _MessageType.ValueType  # 181
+    INTERDEVICE_VERSION_UNSPECIFIED: _InterdeviceVersion.ValueType  # 0
+    INTERDEVICE_VERSION_CURRENT: _InterdeviceVersion.ValueType  # 2
+    """Never use 1: ping/pong were bools before the handshake existed, and a
+    bool true is the same varint on the wire as the number 1, so firmware
+    predating the handshake would pass it.
+    """
 
-class MessageType(_MessageType, metaclass=_MessageTypeEnumTypeWrapper):
-    """encapsulate up to 1k of NMEA string data"""
+class InterdeviceVersion(_InterdeviceVersion, metaclass=_InterdeviceVersionEnumTypeWrapper):
+    """Version of the interdevice protocol spoken on the link. Both sides send
+    theirs in the ping/pong handshake; a peer reporting a different one runs
+    firmware that does not match and is not talked to.
 
-ACK: MessageType.ValueType  # 0
-COLLECT_INTERVAL: MessageType.ValueType  # 160
-"""in ms"""
-BEEP_ON: MessageType.ValueType  # 161
-"""duration ms"""
-BEEP_OFF: MessageType.ValueType  # 162
-"""cancel prematurely"""
-SHUTDOWN: MessageType.ValueType  # 163
-POWER_ON: MessageType.ValueType  # 164
-SCD41_TEMP: MessageType.ValueType  # 176
-SCD41_HUMIDITY: MessageType.ValueType  # 177
-SCD41_CO2: MessageType.ValueType  # 178
-AHT20_TEMP: MessageType.ValueType  # 179
-AHT20_HUMIDITY: MessageType.ValueType  # 180
-TVOC_INDEX: MessageType.ValueType  # 181
-global___MessageType = MessageType
+    On a change that breaks the other side (renumbered fields, changed
+    semantics, removed messages), raise the value of CURRENT. Do not add
+    another entry: this enum carries a single constant, not a history.
+    """
+
+INTERDEVICE_VERSION_UNSPECIFIED: InterdeviceVersion.ValueType  # 0
+INTERDEVICE_VERSION_CURRENT: InterdeviceVersion.ValueType  # 2
+"""Never use 1: ping/pong were bools before the handshake existed, and a
+bool true is the same varint on the wire as the number 1, so firmware
+predating the handshake would pass it.
+"""
+global___InterdeviceVersion = InterdeviceVersion
+
+class _FileOperation:
+    ValueType = typing.NewType("ValueType", builtins.int)
+    V: typing_extensions.TypeAlias = ValueType
+
+class _FileOperationEnumTypeWrapper(google.protobuf.internal.enum_type_wrapper._EnumTypeWrapper[_FileOperation.ValueType], builtins.type):
+    DESCRIPTOR: google.protobuf.descriptor.EnumDescriptor
+    GET: _FileOperation.ValueType  # 0
+    POST: _FileOperation.ValueType  # 1
+    PUT: _FileOperation.ValueType  # 2
+    DELETE: _FileOperation.ValueType  # 3
+
+class FileOperation(_FileOperation, metaclass=_FileOperationEnumTypeWrapper):
+    """Defines the supported file operations"""
+
+GET: FileOperation.ValueType  # 0
+POST: FileOperation.ValueType  # 1
+PUT: FileOperation.ValueType  # 2
+DELETE: FileOperation.ValueType  # 3
+global___FileOperation = FileOperation
+
+class _FileStatus:
+    ValueType = typing.NewType("ValueType", builtins.int)
+    V: typing_extensions.TypeAlias = ValueType
+
+class _FileStatusEnumTypeWrapper(google.protobuf.internal.enum_type_wrapper._EnumTypeWrapper[_FileStatus.ValueType], builtins.type):
+    DESCRIPTOR: google.protobuf.descriptor.EnumDescriptor
+    FILE_UNSPECIFIED: _FileStatus.ValueType  # 0
+    FILE_OK: _FileStatus.ValueType  # 1
+    FILE_BUSY: _FileStatus.ValueType  # 2
+    """Retry later: the co-processor is doing card maintenance (mount,
+    free space scan) and cannot serve the request right now
+    """
+    FILE_NO_CARD: _FileStatus.ValueType  # 3
+    FILE_NOT_FOUND: _FileStatus.ValueType  # 4
+    FILE_OFFSET_CONFLICT: _FileStatus.ValueType  # 5
+    """PUT only: offset did not match the current end of the file. file_size
+    carries the size the file actually has, so the writer can resync (or
+    recognize its own chunk as already written after a lost response).
+    """
+    FILE_IO_ERROR: _FileStatus.ValueType  # 6
+    FILE_NOT_A_FILE: _FileStatus.ValueType  # 7
+    """path is a directory (GET) or not one (listing)"""
+
+class FileStatus(_FileStatus, metaclass=_FileStatusEnumTypeWrapper):
+    """Outcome of a file or directory operation. The requester must be able to
+    tell a transient condition from a definitive one: BUSY is worth another
+    try, NOT_FOUND is not.
+    """
+
+FILE_UNSPECIFIED: FileStatus.ValueType  # 0
+FILE_OK: FileStatus.ValueType  # 1
+FILE_BUSY: FileStatus.ValueType  # 2
+"""Retry later: the co-processor is doing card maintenance (mount,
+free space scan) and cannot serve the request right now
+"""
+FILE_NO_CARD: FileStatus.ValueType  # 3
+FILE_NOT_FOUND: FileStatus.ValueType  # 4
+FILE_OFFSET_CONFLICT: FileStatus.ValueType  # 5
+"""PUT only: offset did not match the current end of the file. file_size
+carries the size the file actually has, so the writer can resync (or
+recognize its own chunk as already written after a lost response).
+"""
+FILE_IO_ERROR: FileStatus.ValueType  # 6
+FILE_NOT_A_FILE: FileStatus.ValueType  # 7
+"""path is a directory (GET) or not one (listing)"""
+global___FileStatus = FileStatus
+
+class _SdCommand:
+    ValueType = typing.NewType("ValueType", builtins.int)
+    V: typing_extensions.TypeAlias = ValueType
+
+class _SdCommandEnumTypeWrapper(google.protobuf.internal.enum_type_wrapper._EnumTypeWrapper[_SdCommand.ValueType], builtins.type):
+    DESCRIPTOR: google.protobuf.descriptor.EnumDescriptor
+    SD_COMMAND_UNSPECIFIED: _SdCommand.ValueType  # 0
+    SD_MOUNT: _SdCommand.ValueType  # 1
+    """mount a card that is in the slot, also after an eject"""
+    SD_EJECT: _SdCommand.ValueType  # 2
+    """flush and release the card so it can be pulled safely"""
+    SD_FORMAT: _SdCommand.ValueType  # 3
+    """wipe the card and put a fresh FAT on it, then mount it"""
+
+class SdCommand(_SdCommand, metaclass=_SdCommandEnumTypeWrapper):
+    """What to do with the SD card of the co-processor"""
+
+SD_COMMAND_UNSPECIFIED: SdCommand.ValueType  # 0
+SD_MOUNT: SdCommand.ValueType  # 1
+"""mount a card that is in the slot, also after an eject"""
+SD_EJECT: SdCommand.ValueType  # 2
+"""flush and release the card so it can be pulled safely"""
+SD_FORMAT: SdCommand.ValueType  # 3
+"""wipe the card and put a fresh FAT on it, then mount it"""
+global___SdCommand = SdCommand
 
 @typing.final
-class SensorData(google.protobuf.message.Message):
+class FileTransfer(google.protobuf.message.Message):
+    """Message for file operations"""
+
     DESCRIPTOR: google.protobuf.descriptor.Descriptor
 
-    TYPE_FIELD_NUMBER: builtins.int
-    FLOAT_VALUE_FIELD_NUMBER: builtins.int
-    UINT32_VALUE_FIELD_NUMBER: builtins.int
-    type: global___MessageType.ValueType
-    """The message type"""
-    float_value: builtins.float
-    uint32_value: builtins.int
+    OPERATION_FIELD_NUMBER: builtins.int
+    FILEPATH_FIELD_NUMBER: builtins.int
+    FILEDATA_FIELD_NUMBER: builtins.int
+    STATUS_FIELD_NUMBER: builtins.int
+    MESSAGE_FIELD_NUMBER: builtins.int
+    OFFSET_FIELD_NUMBER: builtins.int
+    LENGTH_FIELD_NUMBER: builtins.int
+    FILE_SIZE_FIELD_NUMBER: builtins.int
+    operation: global___FileOperation.ValueType
+    """File operation (GET, POST, PUT, DELETE)"""
+    filepath: builtins.str
+    filedata: builtins.bytes
+    status: global___FileStatus.ValueType
+    """Response: outcome of the operation"""
+    message: builtins.str
+    offset: builtins.int
+    """Byte offset of this chunk within the file (ranged GET/PUT)"""
+    length: builtins.int
+    """GET request: number of bytes to read, 0 = max chunk size. A response
+    carries at most the filedata max_size (see interdevice.options) per
+    chunk; larger requests are truncated, visible in the filedata length.
+    """
+    file_size: builtins.int
+    """GET response: total size of the file"""
     def __init__(
         self,
         *,
-        type: global___MessageType.ValueType = ...,
-        float_value: builtins.float = ...,
-        uint32_value: builtins.int = ...,
+        operation: global___FileOperation.ValueType = ...,
+        filepath: builtins.str = ...,
+        filedata: builtins.bytes = ...,
+        status: global___FileStatus.ValueType = ...,
+        message: builtins.str = ...,
+        offset: builtins.int = ...,
+        length: builtins.int = ...,
+        file_size: builtins.int = ...,
     ) -> None: ...
-    def HasField(self, field_name: typing.Literal["data", b"data", "float_value", b"float_value", "uint32_value", b"uint32_value"]) -> builtins.bool: ...
-    def ClearField(self, field_name: typing.Literal["data", b"data", "float_value", b"float_value", "type", b"type", "uint32_value", b"uint32_value"]) -> None: ...
-    def WhichOneof(self, oneof_group: typing.Literal["data", b"data"]) -> typing.Literal["float_value", "uint32_value"] | None: ...
+    def ClearField(self, field_name: typing.Literal["file_size", b"file_size", "filedata", b"filedata", "filepath", b"filepath", "length", b"length", "message", b"message", "offset", b"offset", "operation", b"operation", "status", b"status"]) -> None: ...
 
-global___SensorData = SensorData
+global___FileTransfer = FileTransfer
+
+@typing.final
+class DirectoryListing(google.protobuf.message.Message):
+    """Message for structured directory listing"""
+
+    DESCRIPTOR: google.protobuf.descriptor.Descriptor
+
+    DIRECTORY_FIELD_NUMBER: builtins.int
+    FILENAMES_FIELD_NUMBER: builtins.int
+    STATUS_FIELD_NUMBER: builtins.int
+    MESSAGE_FIELD_NUMBER: builtins.int
+    OFFSET_FIELD_NUMBER: builtins.int
+    TOTAL_COUNT_FIELD_NUMBER: builtins.int
+    directory: builtins.str
+    status: global___FileStatus.ValueType
+    """Response: outcome of the operation"""
+    message: builtins.str
+    offset: builtins.int
+    """Request: skip this many entries (paging)"""
+    total_count: builtins.int
+    """Response: total number of entries in the directory"""
+    @property
+    def filenames(self) -> google.protobuf.internal.containers.RepeatedScalarFieldContainer[builtins.str]:
+        """One page of entry names, full FAT LFN length. Subdirectories carry a
+        trailing slash. Note that a name whose directory prefix pushes the
+        combined path past the FileTransfer.filepath limit cannot round-trip.
+        Page size is the max_count in interdevice.options; page through with
+        offset and total_count.
+        """
+
+    def __init__(
+        self,
+        *,
+        directory: builtins.str = ...,
+        filenames: collections.abc.Iterable[builtins.str] | None = ...,
+        status: global___FileStatus.ValueType = ...,
+        message: builtins.str = ...,
+        offset: builtins.int = ...,
+        total_count: builtins.int = ...,
+    ) -> None: ...
+    def ClearField(self, field_name: typing.Literal["directory", b"directory", "filenames", b"filenames", "message", b"message", "offset", b"offset", "status", b"status", "total_count", b"total_count"]) -> None: ...
+
+global___DirectoryListing = DirectoryListing
+
+@typing.final
+class I2CTransaction(google.protobuf.message.Message):
+    """A single I2C transaction: an optional write followed by an optional
+    read with repeated start, matching the TwoWire usage of sensor drivers
+    (beginTransmission/write.../endTransmission(false)/requestFrom)
+    """
+
+    DESCRIPTOR: google.protobuf.descriptor.Descriptor
+
+    ADDRESS_FIELD_NUMBER: builtins.int
+    WRITE_DATA_FIELD_NUMBER: builtins.int
+    READ_LEN_FIELD_NUMBER: builtins.int
+    address: builtins.int
+    """7-bit device address"""
+    write_data: builtins.bytes
+    read_len: builtins.int
+    """Number of bytes to read after the write, 0 = write-only. Bounded by
+    the read_data max_size of I2CResult (see interdevice.options); larger
+    requests are truncated, visible in the returned byte count.
+    """
+    def __init__(
+        self,
+        *,
+        address: builtins.int = ...,
+        write_data: builtins.bytes = ...,
+        read_len: builtins.int = ...,
+    ) -> None: ...
+    def ClearField(self, field_name: typing.Literal["address", b"address", "read_len", b"read_len", "write_data", b"write_data"]) -> None: ...
+
+global___I2CTransaction = I2CTransaction
+
+@typing.final
+class SdCardInfo(google.protobuf.message.Message):
+    """SD card statistics"""
+
+    DESCRIPTOR: google.protobuf.descriptor.Descriptor
+
+    class _CardType:
+        ValueType = typing.NewType("ValueType", builtins.int)
+        V: typing_extensions.TypeAlias = ValueType
+
+    class _CardTypeEnumTypeWrapper(google.protobuf.internal.enum_type_wrapper._EnumTypeWrapper[SdCardInfo._CardType.ValueType], builtins.type):
+        DESCRIPTOR: google.protobuf.descriptor.EnumDescriptor
+        NONE: SdCardInfo._CardType.ValueType  # 0
+        MMC: SdCardInfo._CardType.ValueType  # 1
+        SD: SdCardInfo._CardType.ValueType  # 2
+        SDHC: SdCardInfo._CardType.ValueType  # 3
+        SDXC: SdCardInfo._CardType.ValueType  # 4
+        UNKNOWN_CARD: SdCardInfo._CardType.ValueType  # 5
+
+    class CardType(_CardType, metaclass=_CardTypeEnumTypeWrapper): ...
+    NONE: SdCardInfo.CardType.ValueType  # 0
+    MMC: SdCardInfo.CardType.ValueType  # 1
+    SD: SdCardInfo.CardType.ValueType  # 2
+    SDHC: SdCardInfo.CardType.ValueType  # 3
+    SDXC: SdCardInfo.CardType.ValueType  # 4
+    UNKNOWN_CARD: SdCardInfo.CardType.ValueType  # 5
+
+    class _FatType:
+        ValueType = typing.NewType("ValueType", builtins.int)
+        V: typing_extensions.TypeAlias = ValueType
+
+    class _FatTypeEnumTypeWrapper(google.protobuf.internal.enum_type_wrapper._EnumTypeWrapper[SdCardInfo._FatType.ValueType], builtins.type):
+        DESCRIPTOR: google.protobuf.descriptor.EnumDescriptor
+        UNKNOWN_FAT: SdCardInfo._FatType.ValueType  # 0
+        FAT16: SdCardInfo._FatType.ValueType  # 1
+        FAT32: SdCardInfo._FatType.ValueType  # 2
+        EXFAT: SdCardInfo._FatType.ValueType  # 3
+
+    class FatType(_FatType, metaclass=_FatTypeEnumTypeWrapper): ...
+    UNKNOWN_FAT: SdCardInfo.FatType.ValueType  # 0
+    FAT16: SdCardInfo.FatType.ValueType  # 1
+    FAT32: SdCardInfo.FatType.ValueType  # 2
+    EXFAT: SdCardInfo.FatType.ValueType  # 3
+
+    PRESENT_FIELD_NUMBER: builtins.int
+    CARD_TYPE_FIELD_NUMBER: builtins.int
+    FAT_TYPE_FIELD_NUMBER: builtins.int
+    CARD_SIZE_FIELD_NUMBER: builtins.int
+    USED_BYTES_FIELD_NUMBER: builtins.int
+    FREE_BYTES_FIELD_NUMBER: builtins.int
+    STATS_VALID_FIELD_NUMBER: builtins.int
+    BUSY_FIELD_NUMBER: builtins.int
+    UNFORMATTED_FIELD_NUMBER: builtins.int
+    present: builtins.bool
+    """Card initialized and usable. False while `busy` is set does not mean
+    there is no card: the co-processor does not know yet.
+    """
+    card_type: global___SdCardInfo.CardType.ValueType
+    fat_type: global___SdCardInfo.FatType.ValueType
+    card_size: builtins.int
+    """Filesystem size in bytes"""
+    used_bytes: builtins.int
+    """Used bytes (may be expensive to compute on FAT32)"""
+    free_bytes: builtins.int
+    """Free bytes"""
+    stats_valid: builtins.bool
+    """used_bytes/free_bytes are only meaningful when true: the scan behind
+    them runs in the background after mount and can take a while, and a
+    full card is otherwise indistinguishable from a scan in progress
+    """
+    busy: builtins.bool
+    """The co-processor is mounting a card right now, so whether one is
+    present is not decided yet. Ask again rather than concluding the slot
+    is empty.
+    """
+    unformatted: builtins.bool
+    """A card answers in the slot but carries no filesystem that could be
+    mounted (present is false then). Formatting it makes it usable.
+    """
+    def __init__(
+        self,
+        *,
+        present: builtins.bool = ...,
+        card_type: global___SdCardInfo.CardType.ValueType = ...,
+        fat_type: global___SdCardInfo.FatType.ValueType = ...,
+        card_size: builtins.int = ...,
+        used_bytes: builtins.int = ...,
+        free_bytes: builtins.int = ...,
+        stats_valid: builtins.bool = ...,
+        busy: builtins.bool = ...,
+        unformatted: builtins.bool = ...,
+    ) -> None: ...
+    def ClearField(self, field_name: typing.Literal["busy", b"busy", "card_size", b"card_size", "card_type", b"card_type", "fat_type", b"fat_type", "free_bytes", b"free_bytes", "present", b"present", "stats_valid", b"stats_valid", "unformatted", b"unformatted", "used_bytes", b"used_bytes"]) -> None: ...
+
+global___SdCardInfo = SdCardInfo
+
+@typing.final
+class I2CResult(google.protobuf.message.Message):
+    """Result of an I2CTransaction"""
+
+    DESCRIPTOR: google.protobuf.descriptor.Descriptor
+
+    class _Status:
+        ValueType = typing.NewType("ValueType", builtins.int)
+        V: typing_extensions.TypeAlias = ValueType
+
+    class _StatusEnumTypeWrapper(google.protobuf.internal.enum_type_wrapper._EnumTypeWrapper[I2CResult._Status.ValueType], builtins.type):
+        DESCRIPTOR: google.protobuf.descriptor.EnumDescriptor
+        UNSPECIFIED: I2CResult._Status.ValueType  # 0
+        """Never sent: an all-defaults (e.g. accidentally empty) message must
+        not decode as a successful transaction
+        """
+        OK: I2CResult._Status.ValueType  # 1
+        NACK_ADDRESS: I2CResult._Status.ValueType  # 2
+        NACK_DATA: I2CResult._Status.ValueType  # 3
+        ERROR: I2CResult._Status.ValueType  # 4
+
+    class Status(_Status, metaclass=_StatusEnumTypeWrapper): ...
+    UNSPECIFIED: I2CResult.Status.ValueType  # 0
+    """Never sent: an all-defaults (e.g. accidentally empty) message must
+    not decode as a successful transaction
+    """
+    OK: I2CResult.Status.ValueType  # 1
+    NACK_ADDRESS: I2CResult.Status.ValueType  # 2
+    NACK_DATA: I2CResult.Status.ValueType  # 3
+    ERROR: I2CResult.Status.ValueType  # 4
+
+    STATUS_FIELD_NUMBER: builtins.int
+    READ_DATA_FIELD_NUMBER: builtins.int
+    status: global___I2CResult.Status.ValueType
+    read_data: builtins.bytes
+    def __init__(
+        self,
+        *,
+        status: global___I2CResult.Status.ValueType = ...,
+        read_data: builtins.bytes = ...,
+    ) -> None: ...
+    def ClearField(self, field_name: typing.Literal["read_data", b"read_data", "status", b"status"]) -> None: ...
+
+global___I2CResult = I2CResult
 
 @typing.final
 class InterdeviceMessage(google.protobuf.message.Message):
+    """Main message for interdevice communication"""
+
     DESCRIPTOR: google.protobuf.descriptor.Descriptor
 
+    ID_FIELD_NUMBER: builtins.int
     NMEA_FIELD_NUMBER: builtins.int
-    SENSOR_FIELD_NUMBER: builtins.int
+    BEEP_FIELD_NUMBER: builtins.int
+    I2C_TRANSACTION_FIELD_NUMBER: builtins.int
+    I2C_RESULT_FIELD_NUMBER: builtins.int
+    I2C_SCAN_FIELD_NUMBER: builtins.int
+    I2C_SCAN_RESULT_FIELD_NUMBER: builtins.int
+    FILE_TRANSFER_FIELD_NUMBER: builtins.int
+    DIRECTORY_LISTING_FIELD_NUMBER: builtins.int
+    GET_SD_INFO_FIELD_NUMBER: builtins.int
+    SD_INFO_FIELD_NUMBER: builtins.int
+    PING_FIELD_NUMBER: builtins.int
+    PONG_FIELD_NUMBER: builtins.int
+    NACK_FIELD_NUMBER: builtins.int
+    SD_COMMAND_FIELD_NUMBER: builtins.int
+    id: builtins.int
+    """Correlates a response with its request: responses echo the id of the
+    request they answer. 0 for unsolicited messages (e.g. the nmea stream).
+    """
     nmea: builtins.str
+    beep: builtins.int
+    i2c_scan: builtins.bool
+    """Request: scan the secondary I2C bus"""
+    i2c_scan_result: builtins.bytes
+    get_sd_info: builtins.bool
+    """Request: SD card statistics"""
+    ping: global___InterdeviceVersion.ValueType
+    """Link liveness probe and version handshake. The receiver answers ping
+    with pong, echoing the id. Touches no peripherals, so it works with
+    nothing attached. Both carry the version the sender speaks; a peer
+    that answers with a different one speaks another protocol and must
+    not be used.
+    """
+    pong: global___InterdeviceVersion.ValueType
+    nack: builtins.bool
+    """Response: the request could not be decoded or is of an unhandled
+    type, so the requester fails fast instead of burning its timeout.
+    Echoes the id when known, 0 when the frame was undecodable. Never
+    sent in reaction to a nack.
+    """
+    sd_command: global___SdCommand.ValueType
+    """Request: mount the card, or release it so it can be pulled safely. The
+    co-processor answers with sd_info. Without an eject the card is mounted
+    on its own and kept mounted; after one it stays released until a mount
+    is asked for.
+    """
     @property
-    def sensor(self) -> global___SensorData: ...
+    def i2c_transaction(self) -> global___I2CTransaction: ...
+    @property
+    def i2c_result(self) -> global___I2CResult: ...
+    @property
+    def file_transfer(self) -> global___FileTransfer: ...
+    @property
+    def directory_listing(self) -> global___DirectoryListing: ...
+    @property
+    def sd_info(self) -> global___SdCardInfo:
+        """Response"""
+
     def __init__(
         self,
         *,
+        id: builtins.int = ...,
         nmea: builtins.str = ...,
-        sensor: global___SensorData | None = ...,
+        beep: builtins.int = ...,
+        i2c_transaction: global___I2CTransaction | None = ...,
+        i2c_result: global___I2CResult | None = ...,
+        i2c_scan: builtins.bool = ...,
+        i2c_scan_result: builtins.bytes = ...,
+        file_transfer: global___FileTransfer | None = ...,
+        directory_listing: global___DirectoryListing | None = ...,
+        get_sd_info: builtins.bool = ...,
+        sd_info: global___SdCardInfo | None = ...,
+        ping: global___InterdeviceVersion.ValueType = ...,
+        pong: global___InterdeviceVersion.ValueType = ...,
+        nack: builtins.bool = ...,
+        sd_command: global___SdCommand.ValueType = ...,
     ) -> None: ...
-    def HasField(self, field_name: typing.Literal["data", b"data", "nmea", b"nmea", "sensor", b"sensor"]) -> builtins.bool: ...
-    def ClearField(self, field_name: typing.Literal["data", b"data", "nmea", b"nmea", "sensor", b"sensor"]) -> None: ...
-    def WhichOneof(self, oneof_group: typing.Literal["data", b"data"]) -> typing.Literal["nmea", "sensor"] | None: ...
+    def HasField(self, field_name: typing.Literal["beep", b"beep", "data", b"data", "directory_listing", b"directory_listing", "file_transfer", b"file_transfer", "get_sd_info", b"get_sd_info", "i2c_result", b"i2c_result", "i2c_scan", b"i2c_scan", "i2c_scan_result", b"i2c_scan_result", "i2c_transaction", b"i2c_transaction", "nack", b"nack", "nmea", b"nmea", "ping", b"ping", "pong", b"pong", "sd_command", b"sd_command", "sd_info", b"sd_info"]) -> builtins.bool: ...
+    def ClearField(self, field_name: typing.Literal["beep", b"beep", "data", b"data", "directory_listing", b"directory_listing", "file_transfer", b"file_transfer", "get_sd_info", b"get_sd_info", "i2c_result", b"i2c_result", "i2c_scan", b"i2c_scan", "i2c_scan_result", b"i2c_scan_result", "i2c_transaction", b"i2c_transaction", "id", b"id", "nack", b"nack", "nmea", b"nmea", "ping", b"ping", "pong", b"pong", "sd_command", b"sd_command", "sd_info", b"sd_info"]) -> None: ...
+    def WhichOneof(self, oneof_group: typing.Literal["data", b"data"]) -> typing.Literal["nmea", "beep", "i2c_transaction", "i2c_result", "i2c_scan", "i2c_scan_result", "file_transfer", "directory_listing", "get_sd_info", "sd_info", "ping", "pong", "nack", "sd_command"] | None: ...
 
 global___InterdeviceMessage = InterdeviceMessage

meshtastic/protobuf/localonly_pb2.py

@@ -15,7 +15,7 @@ from meshtastic.protobuf import config_pb2 as meshtastic_dot_protobuf_dot_config
 from meshtastic.protobuf import module_config_pb2 as meshtastic_dot_protobuf_dot_module__config__pb2
 
 
-DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n#meshtastic/protobuf/localonly.proto\x12\x13meshtastic.protobuf\x1a meshtastic/protobuf/config.proto\x1a\'meshtastic/protobuf/module_config.proto\"\xfa\x03\n\x0bLocalConfig\x12\x38\n\x06\x64\x65vice\x18\x01 \x01(\x0b\x32(.meshtastic.protobuf.Config.DeviceConfig\x12<\n\x08position\x18\x02 \x01(\x0b\x32*.meshtastic.protobuf.Config.PositionConfig\x12\x36\n\x05power\x18\x03 \x01(\x0b\x32\'.meshtastic.protobuf.Config.PowerConfig\x12:\n\x07network\x18\x04 \x01(\x0b\x32).meshtastic.protobuf.Config.NetworkConfig\x12:\n\x07\x64isplay\x18\x05 \x01(\x0b\x32).meshtastic.protobuf.Config.DisplayConfig\x12\x34\n\x04lora\x18\x06 \x01(\x0b\x32&.meshtastic.protobuf.Config.LoRaConfig\x12>\n\tbluetooth\x18\x07 \x01(\x0b\x32+.meshtastic.protobuf.Config.BluetoothConfig\x12\x0f\n\x07version\x18\x08 \x01(\r\x12<\n\x08security\x18\t \x01(\x0b\x32*.meshtastic.protobuf.Config.SecurityConfig\"\xcf\t\n\x11LocalModuleConfig\x12:\n\x04mqtt\x18\x01 \x01(\x0b\x32,.meshtastic.protobuf.ModuleConfig.MQTTConfig\x12>\n\x06serial\x18\x02 \x01(\x0b\x32..meshtastic.protobuf.ModuleConfig.SerialConfig\x12[\n\x15\x65xternal_notification\x18\x03 \x01(\x0b\x32<.meshtastic.protobuf.ModuleConfig.ExternalNotificationConfig\x12K\n\rstore_forward\x18\x04 \x01(\x0b\x32\x34.meshtastic.protobuf.ModuleConfig.StoreForwardConfig\x12\x45\n\nrange_test\x18\x05 \x01(\x0b\x32\x31.meshtastic.protobuf.ModuleConfig.RangeTestConfig\x12\x44\n\ttelemetry\x18\x06 \x01(\x0b\x32\x31.meshtastic.protobuf.ModuleConfig.TelemetryConfig\x12M\n\x0e\x63\x61nned_message\x18\x07 \x01(\x0b\x32\x35.meshtastic.protobuf.ModuleConfig.CannedMessageConfig\x12<\n\x05\x61udio\x18\t \x01(\x0b\x32-.meshtastic.protobuf.ModuleConfig.AudioConfig\x12O\n\x0fremote_hardware\x18\n \x01(\x0b\x32\x36.meshtastic.protobuf.ModuleConfig.RemoteHardwareConfig\x12K\n\rneighbor_info\x18\x0b \x01(\x0b\x32\x34.meshtastic.protobuf.ModuleConfig.NeighborInfoConfig\x12Q\n\x10\x61mbient_lighting\x18\x0c \x01(\x0b\x32\x37.meshtastic.protobuf.ModuleConfig.AmbientLightingConfig\x12Q\n\x10\x64\x65tection_sensor\x18\r \x01(\x0b\x32\x37.meshtastic.protobuf.ModuleConfig.DetectionSensorConfig\x12\x46\n\npaxcounter\x18\x0e \x01(\x0b\x32\x32.meshtastic.protobuf.ModuleConfig.PaxcounterConfig\x12L\n\rstatusmessage\x18\x0f \x01(\x0b\x32\x35.meshtastic.protobuf.ModuleConfig.StatusMessageConfig\x12U\n\x12traffic_management\x18\x10 \x01(\x0b\x32\x39.meshtastic.protobuf.ModuleConfig.TrafficManagementConfig\x12\x38\n\x03tak\x18\x11 \x01(\x0b\x32+.meshtastic.protobuf.ModuleConfig.TAKConfig\x12\x0f\n\x07version\x18\x08 \x01(\rBe\n\x14org.meshtastic.protoB\x0fLocalOnlyProtosZ\"github.com/meshtastic/go/generated\xaa\x02\x14Meshtastic.Protobufs\xba\x02\x00\x62\x06proto3')
+DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n#meshtastic/protobuf/localonly.proto\x12\x13meshtastic.protobuf\x1a meshtastic/protobuf/config.proto\x1a\'meshtastic/protobuf/module_config.proto\"\xfa\x03\n\x0bLocalConfig\x12\x38\n\x06\x64\x65vice\x18\x01 \x01(\x0b\x32(.meshtastic.protobuf.Config.DeviceConfig\x12<\n\x08position\x18\x02 \x01(\x0b\x32*.meshtastic.protobuf.Config.PositionConfig\x12\x36\n\x05power\x18\x03 \x01(\x0b\x32\'.meshtastic.protobuf.Config.PowerConfig\x12:\n\x07network\x18\x04 \x01(\x0b\x32).meshtastic.protobuf.Config.NetworkConfig\x12:\n\x07\x64isplay\x18\x05 \x01(\x0b\x32).meshtastic.protobuf.Config.DisplayConfig\x12\x34\n\x04lora\x18\x06 \x01(\x0b\x32&.meshtastic.protobuf.Config.LoRaConfig\x12>\n\tbluetooth\x18\x07 \x01(\x0b\x32+.meshtastic.protobuf.Config.BluetoothConfig\x12\x0f\n\x07version\x18\x08 \x01(\r\x12<\n\x08security\x18\t \x01(\x0b\x32*.meshtastic.protobuf.Config.SecurityConfig\"\x98\n\n\x11LocalModuleConfig\x12:\n\x04mqtt\x18\x01 \x01(\x0b\x32,.meshtastic.protobuf.ModuleConfig.MQTTConfig\x12>\n\x06serial\x18\x02 \x01(\x0b\x32..meshtastic.protobuf.ModuleConfig.SerialConfig\x12[\n\x15\x65xternal_notification\x18\x03 \x01(\x0b\x32<.meshtastic.protobuf.ModuleConfig.ExternalNotificationConfig\x12K\n\rstore_forward\x18\x04 \x01(\x0b\x32\x34.meshtastic.protobuf.ModuleConfig.StoreForwardConfig\x12\x45\n\nrange_test\x18\x05 \x01(\x0b\x32\x31.meshtastic.protobuf.ModuleConfig.RangeTestConfig\x12\x44\n\ttelemetry\x18\x06 \x01(\x0b\x32\x31.meshtastic.protobuf.ModuleConfig.TelemetryConfig\x12M\n\x0e\x63\x61nned_message\x18\x07 \x01(\x0b\x32\x35.meshtastic.protobuf.ModuleConfig.CannedMessageConfig\x12<\n\x05\x61udio\x18\t \x01(\x0b\x32-.meshtastic.protobuf.ModuleConfig.AudioConfig\x12O\n\x0fremote_hardware\x18\n \x01(\x0b\x32\x36.meshtastic.protobuf.ModuleConfig.RemoteHardwareConfig\x12K\n\rneighbor_info\x18\x0b \x01(\x0b\x32\x34.meshtastic.protobuf.ModuleConfig.NeighborInfoConfig\x12Q\n\x10\x61mbient_lighting\x18\x0c \x01(\x0b\x32\x37.meshtastic.protobuf.ModuleConfig.AmbientLightingConfig\x12Q\n\x10\x64\x65tection_sensor\x18\r \x01(\x0b\x32\x37.meshtastic.protobuf.ModuleConfig.DetectionSensorConfig\x12\x46\n\npaxcounter\x18\x0e \x01(\x0b\x32\x32.meshtastic.protobuf.ModuleConfig.PaxcounterConfig\x12L\n\rstatusmessage\x18\x0f \x01(\x0b\x32\x35.meshtastic.protobuf.ModuleConfig.StatusMessageConfig\x12U\n\x12traffic_management\x18\x10 \x01(\x0b\x32\x39.meshtastic.protobuf.ModuleConfig.TrafficManagementConfig\x12\x38\n\x03tak\x18\x11 \x01(\x0b\x32+.meshtastic.protobuf.ModuleConfig.TAKConfig\x12G\n\x0bmesh_beacon\x18\x12 \x01(\x0b\x32\x32.meshtastic.protobuf.ModuleConfig.MeshBeaconConfig\x12\x0f\n\x07version\x18\x08 \x01(\rBe\n\x14org.meshtastic.protoB\x0fLocalOnlyProtosZ\"github.com/meshtastic/go/generated\xaa\x02\x14Meshtastic.Protobufs\xba\x02\x00\x62\x06proto3')
 
 _globals = globals()
 _builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals)
@@ -26,5 +26,5 @@ if _descriptor._USE_C_DESCRIPTORS == False:
   _globals['_LOCALCONFIG']._serialized_start=136
   _globals['_LOCALCONFIG']._serialized_end=642
   _globals['_LOCALMODULECONFIG']._serialized_start=645
-  _globals['_LOCALMODULECONFIG']._serialized_end=1876
+  _globals['_LOCALMODULECONFIG']._serialized_end=1949
 # @@protoc_insertion_point(module_scope)

meshtastic/protobuf/localonly_pb2.pyi

@@ -122,6 +122,7 @@ class LocalModuleConfig(google.protobuf.message.Message):
     STATUSMESSAGE_FIELD_NUMBER: builtins.int
     TRAFFIC_MANAGEMENT_FIELD_NUMBER: builtins.int
     TAK_FIELD_NUMBER: builtins.int
+    MESH_BEACON_FIELD_NUMBER: builtins.int
     VERSION_FIELD_NUMBER: builtins.int
     version: builtins.int
     """
@@ -225,6 +226,12 @@ class LocalModuleConfig(google.protobuf.message.Message):
         TAK Config
         """
 
+    @property
+    def mesh_beacon(self) -> meshtastic.protobuf.module_config_pb2.ModuleConfig.MeshBeaconConfig:
+        """
+        MeshBeacon Config
+        """
+
     def __init__(
         self,
         *,
@@ -244,9 +251,10 @@ class LocalModuleConfig(google.protobuf.message.Message):
         statusmessage: meshtastic.protobuf.module_config_pb2.ModuleConfig.StatusMessageConfig | None = ...,
         traffic_management: meshtastic.protobuf.module_config_pb2.ModuleConfig.TrafficManagementConfig | None = ...,
         tak: meshtastic.protobuf.module_config_pb2.ModuleConfig.TAKConfig | None = ...,
+        mesh_beacon: meshtastic.protobuf.module_config_pb2.ModuleConfig.MeshBeaconConfig | None = ...,
         version: builtins.int = ...,
     ) -> None: ...
-    def HasField(self, field_name: typing.Literal["ambient_lighting", b"ambient_lighting", "audio", b"audio", "canned_message", b"canned_message", "detection_sensor", b"detection_sensor", "external_notification", b"external_notification", "mqtt", b"mqtt", "neighbor_info", b"neighbor_info", "paxcounter", b"paxcounter", "range_test", b"range_test", "remote_hardware", b"remote_hardware", "serial", b"serial", "statusmessage", b"statusmessage", "store_forward", b"store_forward", "tak", b"tak", "telemetry", b"telemetry", "traffic_management", b"traffic_management"]) -> builtins.bool: ...
-    def ClearField(self, field_name: typing.Literal["ambient_lighting", b"ambient_lighting", "audio", b"audio", "canned_message", b"canned_message", "detection_sensor", b"detection_sensor", "external_notification", b"external_notification", "mqtt", b"mqtt", "neighbor_info", b"neighbor_info", "paxcounter", b"paxcounter", "range_test", b"range_test", "remote_hardware", b"remote_hardware", "serial", b"serial", "statusmessage", b"statusmessage", "store_forward", b"store_forward", "tak", b"tak", "telemetry", b"telemetry", "traffic_management", b"traffic_management", "version", b"version"]) -> None: ...
+    def HasField(self, field_name: typing.Literal["ambient_lighting", b"ambient_lighting", "audio", b"audio", "canned_message", b"canned_message", "detection_sensor", b"detection_sensor", "external_notification", b"external_notification", "mesh_beacon", b"mesh_beacon", "mqtt", b"mqtt", "neighbor_info", b"neighbor_info", "paxcounter", b"paxcounter", "range_test", b"range_test", "remote_hardware", b"remote_hardware", "serial", b"serial", "statusmessage", b"statusmessage", "store_forward", b"store_forward", "tak", b"tak", "telemetry", b"telemetry", "traffic_management", b"traffic_management"]) -> builtins.bool: ...
+    def ClearField(self, field_name: typing.Literal["ambient_lighting", b"ambient_lighting", "audio", b"audio", "canned_message", b"canned_message", "detection_sensor", b"detection_sensor", "external_notification", b"external_notification", "mesh_beacon", b"mesh_beacon", "mqtt", b"mqtt", "neighbor_info", b"neighbor_info", "paxcounter", b"paxcounter", "range_test", b"range_test", "remote_hardware", b"remote_hardware", "serial", b"serial", "statusmessage", b"statusmessage", "store_forward", b"store_forward", "tak", b"tak", "telemetry", b"telemetry", "traffic_management", b"traffic_management", "version", b"version"]) -> None: ...
 
 global___LocalModuleConfig = LocalModuleConfig

meshtastic/protobuf/mesh_beacon_pb2.py

@@ -0,0 +1,31 @@
+# -*- coding: utf-8 -*-
+# Generated by the protocol buffer compiler.  DO NOT EDIT!
+# source: meshtastic/protobuf/mesh_beacon.proto
+"""Generated protocol buffer code."""
+from google.protobuf import descriptor as _descriptor
+from google.protobuf import descriptor_pool as _descriptor_pool
+from google.protobuf import symbol_database as _symbol_database
+from google.protobuf.internal import builder as _builder
+# @@protoc_insertion_point(imports)
+
+_sym_db = _symbol_database.Default()
+
+
+from meshtastic.protobuf import channel_pb2 as meshtastic_dot_protobuf_dot_channel__pb2
+from meshtastic.protobuf import config_pb2 as meshtastic_dot_protobuf_dot_config__pb2
+from meshtastic.protobuf import nanopb_pb2 as meshtastic_dot_protobuf_dot_nanopb__pb2
+
+
+DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n%meshtastic/protobuf/mesh_beacon.proto\x12\x13meshtastic.protobuf\x1a!meshtastic/protobuf/channel.proto\x1a meshtastic/protobuf/config.proto\x1a meshtastic/protobuf/nanopb.proto\"\x8a\x02\n\nMeshBeacon\x12\x16\n\x07message\x18\x01 \x01(\tB\x05\x92?\x02\x08\x65\x12;\n\roffer_channel\x18\x02 \x01(\x0b\x32$.meshtastic.protobuf.ChannelSettings\x12G\n\x0coffer_region\x18\x03 \x01(\x0e\x32\x31.meshtastic.protobuf.Config.LoRaConfig.RegionCode\x12M\n\x0coffer_preset\x18\x04 \x01(\x0e\x32\x32.meshtastic.protobuf.Config.LoRaConfig.ModemPresetH\x00\x88\x01\x01\x42\x0f\n\r_offer_presetBf\n\x14org.meshtastic.protoB\x10MeshBeaconProtosZ\"github.com/meshtastic/go/generated\xaa\x02\x14Meshtastic.Protobufs\xba\x02\x00\x62\x06proto3')
+
+_globals = globals()
+_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals)
+_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'meshtastic.protobuf.mesh_beacon_pb2', _globals)
+if _descriptor._USE_C_DESCRIPTORS == False:
+  DESCRIPTOR._options = None
+  DESCRIPTOR._serialized_options = b'\n\024org.meshtastic.protoB\020MeshBeaconProtosZ\"github.com/meshtastic/go/generated\252\002\024Meshtastic.Protobufs\272\002\000'
+  _MESHBEACON.fields_by_name['message']._options = None
+  _MESHBEACON.fields_by_name['message']._serialized_options = b'\222?\002\010e'
+  _globals['_MESHBEACON']._serialized_start=166
+  _globals['_MESHBEACON']._serialized_end=432
+# @@protoc_insertion_point(module_scope)

meshtastic/protobuf/mesh_beacon_pb2.pyi

@@ -0,0 +1,62 @@
+"""
+@generated by mypy-protobuf.  Do not edit manually!
+isort:skip_file
+"""
+
+import builtins
+import google.protobuf.descriptor
+import google.protobuf.message
+import meshtastic.protobuf.channel_pb2
+import meshtastic.protobuf.config_pb2
+import typing
+
+DESCRIPTOR: google.protobuf.descriptor.FileDescriptor
+
+@typing.final
+class MeshBeacon(google.protobuf.message.Message):
+    """
+    Payload for MESH_BEACON_APP packets.
+    Periodically broadcast by nodes in beacon mode.
+    Listeners deliver the text message to the local inbox and cache any offered
+    channel/preset for the client app to act on — the firmware never auto-applies them.
+    """
+
+    DESCRIPTOR: google.protobuf.descriptor.Descriptor
+
+    MESSAGE_FIELD_NUMBER: builtins.int
+    OFFER_CHANNEL_FIELD_NUMBER: builtins.int
+    OFFER_REGION_FIELD_NUMBER: builtins.int
+    OFFER_PRESET_FIELD_NUMBER: builtins.int
+    message: builtins.str
+    """
+    Human-readable beacon message. Max 100 bytes enforced by firmware on send.
+    """
+    offer_region: meshtastic.protobuf.config_pb2.Config.LoRaConfig.RegionCode.ValueType
+    """
+    Optional region being advertised alongside offer_preset.
+    """
+    offer_preset: meshtastic.protobuf.config_pb2.Config.LoRaConfig.ModemPreset.ValueType
+    """
+    Optional modem preset being advertised.
+    Combined with offer_region, tells a client "there is a mesh on this preset/region".
+    """
+    @property
+    def offer_channel(self) -> meshtastic.protobuf.channel_pb2.ChannelSettings:
+        """
+        Optional channel (name + PSK) being advertised to listening clients.
+        A client app may offer to switch the user to this channel; firmware never applies it automatically.
+        """
+
+    def __init__(
+        self,
+        *,
+        message: builtins.str = ...,
+        offer_channel: meshtastic.protobuf.channel_pb2.ChannelSettings | None = ...,
+        offer_region: meshtastic.protobuf.config_pb2.Config.LoRaConfig.RegionCode.ValueType = ...,
+        offer_preset: meshtastic.protobuf.config_pb2.Config.LoRaConfig.ModemPreset.ValueType | None = ...,
+    ) -> None: ...
+    def HasField(self, field_name: typing.Literal["_offer_preset", b"_offer_preset", "offer_channel", b"offer_channel", "offer_preset", b"offer_preset"]) -> builtins.bool: ...
+    def ClearField(self, field_name: typing.Literal["_offer_preset", b"_offer_preset", "message", b"message", "offer_channel", b"offer_channel", "offer_preset", b"offer_preset", "offer_region", b"offer_region"]) -> None: ...
+    def WhichOneof(self, oneof_group: typing.Literal["_offer_preset", b"_offer_preset"]) -> typing.Literal["offer_preset"] | None: ...
+
+global___MeshBeacon = MeshBeacon

meshtastic/protobuf/mesh_pb2.pyi

@@ -142,13 +142,13 @@ class _HardwareModelEnumTypeWrapper(google.protobuf.internal.enum_type_wrapper._
     """
     RAK11310 (RP2040 + SX1262)
     """
-    SENSELORA_RP2040: _HardwareModel.ValueType  # 27
+    MAKERFABS_TRACKER: _HardwareModel.ValueType  # 27
     """
-    Makerfabs SenseLoRA Receiver (RP2040 + RFM96)
+    Makerfabs Tracker Reserved
     """
-    SENSELORA_S3: _HardwareModel.ValueType  # 28
+    MAKERFABS_RESERVED: _HardwareModel.ValueType  # 28
     """
-    Makerfabs SenseLoRA Industrial Monitor (ESP32-S3 + RFM96)
+    Makerfabs Reserved
     """
     CANARYONE: _HardwareModel.ValueType  # 29
     """
@@ -563,9 +563,9 @@ class _HardwareModelEnumTypeWrapper(google.protobuf.internal.enum_type_wrapper._
     """
     Heltec Mesh Node T096 board features an nRF52840 CPU and a TFT screen.
     """
-    TRACKER_T1000_E_PRO: _HardwareModel.ValueType  # 128
+    MESH_TRACKER_X1: _HardwareModel.ValueType  # 128
     """
-    Seeed studio T1000-E Pro tracker card. NRF52840 w/ LR2021 radio,
+    Seeed studio Mesh Tracker X1card. NRF52840 w/ LR2021 radio,
     GPS, button, buzzer, and sensors.
     """
     THINKNODE_M7: _HardwareModel.ValueType  # 129
@@ -610,6 +610,30 @@ class _HardwareModelEnumTypeWrapper(google.protobuf.internal.enum_type_wrapper._
     """
     Meshnology W10
     """
+    HELTEC_RC32: _HardwareModel.ValueType  # 141
+    """
+    Heltec ESP32S3 + SX1262
+    """
+    HELTEC_RC52: _HardwareModel.ValueType  # 142
+    """
+    Heltec NRF52840 + SX1262
+    """
+    HELTEC_RCC6: _HardwareModel.ValueType  # 143
+    """
+    Heltec ESP32C6 + SX1262
+    """
+    SEEED_WIO_TRACKER_L1_PRO_1W: _HardwareModel.ValueType  # 144
+    """
+    Seeed Wio Tracker L1 Pro 1W, nRF52840 + SX1262 with 1 W external PA
+    """
+    MESHNOLOGY_W12: _HardwareModel.ValueType  # 145
+    """
+    Meshnology W12
+    """
+    MESHPAGER_X2: _HardwareModel.ValueType  # 146
+    """
+    Seeed Studio MeshPager X2
+    """
     PRIVATE_HW: _HardwareModel.ValueType  # 255
     """
     ------------------------------------------------------------------------------------------------------------------------------------------
@@ -735,13 +759,13 @@ RAK11310: HardwareModel.ValueType  # 26
 """
 RAK11310 (RP2040 + SX1262)
 """
-SENSELORA_RP2040: HardwareModel.ValueType  # 27
+MAKERFABS_TRACKER: HardwareModel.ValueType  # 27
 """
-Makerfabs SenseLoRA Receiver (RP2040 + RFM96)
+Makerfabs Tracker Reserved
 """
-SENSELORA_S3: HardwareModel.ValueType  # 28
+MAKERFABS_RESERVED: HardwareModel.ValueType  # 28
 """
-Makerfabs SenseLoRA Industrial Monitor (ESP32-S3 + RFM96)
+Makerfabs Reserved
 """
 CANARYONE: HardwareModel.ValueType  # 29
 """
@@ -1156,9 +1180,9 @@ HELTEC_MESH_NODE_T096: HardwareModel.ValueType  # 127
 """
 Heltec Mesh Node T096 board features an nRF52840 CPU and a TFT screen.
 """
-TRACKER_T1000_E_PRO: HardwareModel.ValueType  # 128
+MESH_TRACKER_X1: HardwareModel.ValueType  # 128
 """
-Seeed studio T1000-E Pro tracker card. NRF52840 w/ LR2021 radio,
+Seeed studio Mesh Tracker X1card. NRF52840 w/ LR2021 radio,
 GPS, button, buzzer, and sensors.
 """
 THINKNODE_M7: HardwareModel.ValueType  # 129
@@ -1203,6 +1227,30 @@ MESHNOLOGY_W10: HardwareModel.ValueType  # 140
 """
 Meshnology W10
 """
+HELTEC_RC32: HardwareModel.ValueType  # 141
+"""
+Heltec ESP32S3 + SX1262
+"""
+HELTEC_RC52: HardwareModel.ValueType  # 142
+"""
+Heltec NRF52840 + SX1262
+"""
+HELTEC_RCC6: HardwareModel.ValueType  # 143
+"""
+Heltec ESP32C6 + SX1262
+"""
+SEEED_WIO_TRACKER_L1_PRO_1W: HardwareModel.ValueType  # 144
+"""
+Seeed Wio Tracker L1 Pro 1W, nRF52840 + SX1262 with 1 W external PA
+"""
+MESHNOLOGY_W12: HardwareModel.ValueType  # 145
+"""
+Meshnology W12
+"""
+MESHPAGER_X2: HardwareModel.ValueType  # 146
+"""
+Seeed Studio MeshPager X2
+"""
 PRIVATE_HW: HardwareModel.ValueType  # 255
 """
 ------------------------------------------------------------------------------------------------------------------------------------------
@@ -1414,6 +1462,18 @@ class _FirmwareEditionEnumTypeWrapper(google.protobuf.internal.enum_type_wrapper
     """
     Hamvention, the Dayton amateur radio convention
     """
+    FAB: _FirmwareEdition.ValueType  # 20
+    """
+    FAB, the international Fab Lab digital fabrication conference
+    """
+    DRAGON_CON: _FirmwareEdition.ValueType  # 21
+    """
+    Dragon Con, the yearly pop culture convention in Atlanta, GA
+    """
+    CCC: _FirmwareEdition.ValueType  # 22
+    """
+    Chaos Communication Congress, the hacker conference held yearly in Germany
+    """
     DIY_EDITION: _FirmwareEdition.ValueType  # 127
     """
     Placeholder for DIY and unofficial events
@@ -1449,6 +1509,18 @@ HAMVENTION: FirmwareEdition.ValueType  # 19
 """
 Hamvention, the Dayton amateur radio convention
 """
+FAB: FirmwareEdition.ValueType  # 20
+"""
+FAB, the international Fab Lab digital fabrication conference
+"""
+DRAGON_CON: FirmwareEdition.ValueType  # 21
+"""
+Dragon Con, the yearly pop culture convention in Atlanta, GA
+"""
+CCC: FirmwareEdition.ValueType  # 22
+"""
+Chaos Communication Congress, the hacker conference held yearly in Germany
+"""
 DIY_EDITION: FirmwareEdition.ValueType  # 127
 """
 Placeholder for DIY and unofficial events
@@ -1797,7 +1869,7 @@ class Position(google.protobuf.message.Message):
     """
     ground_speed: builtins.int
     """
-    Ground speed in m/s and True North TRACK in 1/100 degrees
+    Ground speed in km/h and True North TRACK in 1/100 degrees
     Clarification of terms:
     - "track" is the direction of motion (measured in horizontal plane)
     - "heading" is where the fuselage points (measured in horizontal plane)
@@ -1932,6 +2004,9 @@ class User(google.protobuf.message.Message):
     long_name: builtins.str
     """
     A full name for this user, i.e. "Kevin Hester"
+    Limited to 24 bytes of UTF-8: longer names are accepted from senders
+    built against the older 39-byte limit, but devices truncate them before
+    storing or rebroadcasting. Clients should enforce 24 bytes in their UI.
     """
     short_name: builtins.str
     """
@@ -2263,6 +2338,7 @@ class Data(google.protobuf.message.Message):
     REPLY_ID_FIELD_NUMBER: builtins.int
     EMOJI_FIELD_NUMBER: builtins.int
     BITFIELD_FIELD_NUMBER: builtins.int
+    XEDDSA_SIGNATURE_FIELD_NUMBER: builtins.int
     portnum: meshtastic.protobuf.portnums_pb2.PortNum.ValueType
     """
     Formerly named typ and of type Type
@@ -2309,6 +2385,10 @@ class Data(google.protobuf.message.Message):
     """
     Bitfield for extra flags. First use is to indicate that user approves the packet being uploaded to MQTT.
     """
+    xeddsa_signature: builtins.bytes
+    """
+    XEdDSA signature for the payload
+    """
     def __init__(
         self,
         *,
@@ -2321,9 +2401,10 @@ class Data(google.protobuf.message.Message):
         reply_id: builtins.int = ...,
         emoji: builtins.int = ...,
         bitfield: builtins.int | None = ...,
+        xeddsa_signature: builtins.bytes = ...,
     ) -> None: ...
     def HasField(self, field_name: typing.Literal["_bitfield", b"_bitfield", "bitfield", b"bitfield"]) -> builtins.bool: ...
-    def ClearField(self, field_name: typing.Literal["_bitfield", b"_bitfield", "bitfield", b"bitfield", "dest", b"dest", "emoji", b"emoji", "payload", b"payload", "portnum", b"portnum", "reply_id", b"reply_id", "request_id", b"request_id", "source", b"source", "want_response", b"want_response"]) -> None: ...
+    def ClearField(self, field_name: typing.Literal["_bitfield", b"_bitfield", "bitfield", b"bitfield", "dest", b"dest", "emoji", b"emoji", "payload", b"payload", "portnum", b"portnum", "reply_id", b"reply_id", "request_id", b"request_id", "source", b"source", "want_response", b"want_response", "xeddsa_signature", b"xeddsa_signature"]) -> None: ...
     def WhichOneof(self, oneof_group: typing.Literal["_bitfield", b"_bitfield"]) -> typing.Literal["bitfield"] | None: ...
 
 global___Data = Data
@@ -2620,6 +2701,51 @@ class RemoteShell(google.protobuf.message.Message):
 
 global___RemoteShell = RemoteShell
 
+@typing.final
+class BoundingBox(google.protobuf.message.Message):
+    """
+    A rectangular, axis-aligned geographic bounding box.
+    Used to define a rectangular geofence region for a Waypoint.
+    Fields are ordered west, south, east, north to match the standard bounding box
+    convention used by GeoJSON and PMTiles (min longitude, min latitude, max longitude, max latitude),
+    so the box can drive an offline map extract directly.
+    All coordinates are in degrees scaled by 1e-7 (same convention as Position and Waypoint).
+    """
+
+    DESCRIPTOR: google.protobuf.descriptor.Descriptor
+
+    LONGITUDE_WEST_I_FIELD_NUMBER: builtins.int
+    LATITUDE_SOUTH_I_FIELD_NUMBER: builtins.int
+    LONGITUDE_EAST_I_FIELD_NUMBER: builtins.int
+    LATITUDE_NORTH_I_FIELD_NUMBER: builtins.int
+    longitude_west_i: builtins.int
+    """
+    Western edge of the box - minimum longitude (south-west corner)
+    """
+    latitude_south_i: builtins.int
+    """
+    Southern edge of the box - minimum latitude (south-west corner)
+    """
+    longitude_east_i: builtins.int
+    """
+    Eastern edge of the box - maximum longitude (north-east corner)
+    """
+    latitude_north_i: builtins.int
+    """
+    Northern edge of the box - maximum latitude (north-east corner)
+    """
+    def __init__(
+        self,
+        *,
+        longitude_west_i: builtins.int = ...,
+        latitude_south_i: builtins.int = ...,
+        longitude_east_i: builtins.int = ...,
+        latitude_north_i: builtins.int = ...,
+    ) -> None: ...
+    def ClearField(self, field_name: typing.Literal["latitude_north_i", b"latitude_north_i", "latitude_south_i", b"latitude_south_i", "longitude_east_i", b"longitude_east_i", "longitude_west_i", b"longitude_west_i"]) -> None: ...
+
+global___BoundingBox = BoundingBox
+
 @typing.final
 class Waypoint(google.protobuf.message.Message):
     """
@@ -2636,6 +2762,11 @@ class Waypoint(google.protobuf.message.Message):
     NAME_FIELD_NUMBER: builtins.int
     DESCRIPTION_FIELD_NUMBER: builtins.int
     ICON_FIELD_NUMBER: builtins.int
+    GEOFENCE_RADIUS_FIELD_NUMBER: builtins.int
+    BOUNDING_BOX_FIELD_NUMBER: builtins.int
+    NOTIFY_ON_ENTER_FIELD_NUMBER: builtins.int
+    NOTIFY_ON_EXIT_FIELD_NUMBER: builtins.int
+    NOTIFY_FAVORITES_ONLY_FIELD_NUMBER: builtins.int
     id: builtins.int
     """
     Id of the waypoint
@@ -2669,6 +2800,36 @@ class Waypoint(google.protobuf.message.Message):
     """
     Designator icon for the waypoint in the form of a unicode emoji
     """
+    geofence_radius: builtins.int
+    """
+    If greater than zero, defines a circular geofence centred on this waypoint's
+    location (latitude_i / longitude_i) with this radius in meters.
+    Zero means the waypoint has no circular geofence.
+    """
+    notify_on_enter: builtins.bool
+    """
+    If true, a notification should be raised when a tracked node enters this
+    waypoint's geofence (the circular radius and/or the bounding box).
+    """
+    notify_on_exit: builtins.bool
+    """
+    If true, a notification should be raised when a tracked node exits this
+    waypoint's geofence (the circular radius and/or the bounding box).
+    """
+    notify_favorites_only: builtins.bool
+    """
+    If true, only raise geofence enter/exit notifications for nodes that are
+    marked as favorites on the receiving device. Applies to both notify_on_enter
+    and notify_on_exit. Favorite status is resolved locally per receiver, so the
+    same waypoint alerts each node only for its own favorites.
+    """
+    @property
+    def bounding_box(self) -> global___BoundingBox:
+        """
+        Optional rectangular geofence region for this waypoint.
+        May be used instead of, or in addition to, geofence_radius.
+        """
+
     def __init__(
         self,
         *,
@@ -2680,9 +2841,16 @@ class Waypoint(google.protobuf.message.Message):
         name: builtins.str = ...,
         description: builtins.str = ...,
         icon: builtins.int = ...,
+        geofence_radius: builtins.int = ...,
+        bounding_box: global___BoundingBox | None = ...,
+        notify_on_enter: builtins.bool = ...,
+        notify_on_exit: builtins.bool = ...,
+        notify_favorites_only: builtins.bool = ...,
     ) -> None: ...
-    def HasField(self, field_name: typing.Literal["_latitude_i", b"_latitude_i", "_longitude_i", b"_longitude_i", "latitude_i", b"latitude_i", "longitude_i", b"longitude_i"]) -> builtins.bool: ...
-    def ClearField(self, field_name: typing.Literal["_latitude_i", b"_latitude_i", "_longitude_i", b"_longitude_i", "description", b"description", "expire", b"expire", "icon", b"icon", "id", b"id", "latitude_i", b"latitude_i", "locked_to", b"locked_to", "longitude_i", b"longitude_i", "name", b"name"]) -> None: ...
+    def HasField(self, field_name: typing.Literal["_bounding_box", b"_bounding_box", "_latitude_i", b"_latitude_i", "_longitude_i", b"_longitude_i", "bounding_box", b"bounding_box", "latitude_i", b"latitude_i", "longitude_i", b"longitude_i"]) -> builtins.bool: ...
+    def ClearField(self, field_name: typing.Literal["_bounding_box", b"_bounding_box", "_latitude_i", b"_latitude_i", "_longitude_i", b"_longitude_i", "bounding_box", b"bounding_box", "description", b"description", "expire", b"expire", "geofence_radius", b"geofence_radius", "icon", b"icon", "id", b"id", "latitude_i", b"latitude_i", "locked_to", b"locked_to", "longitude_i", b"longitude_i", "name", b"name", "notify_favorites_only", b"notify_favorites_only", "notify_on_enter", b"notify_on_enter", "notify_on_exit", b"notify_on_exit"]) -> None: ...
+    @typing.overload
+    def WhichOneof(self, oneof_group: typing.Literal["_bounding_box", b"_bounding_box"]) -> typing.Literal["bounding_box"] | None: ...
     @typing.overload
     def WhichOneof(self, oneof_group: typing.Literal["_latitude_i", b"_latitude_i"]) -> typing.Literal["latitude_i"] | None: ...
     @typing.overload
@@ -2954,6 +3122,10 @@ class MeshPacket(google.protobuf.message.Message):
         """
         Arrived via API connection
         """
+        TRANSPORT_UNICAST_UDP: MeshPacket._TransportMechanism.ValueType  # 8
+        """
+        Arrived via Unicast UDP
+        """
 
     class TransportMechanism(_TransportMechanism, metaclass=_TransportMechanismEnumTypeWrapper):
         """
@@ -2992,6 +3164,10 @@ class MeshPacket(google.protobuf.message.Message):
     """
     Arrived via API connection
     """
+    TRANSPORT_UNICAST_UDP: MeshPacket.TransportMechanism.ValueType  # 8
+    """
+    Arrived via Unicast UDP
+    """
 
     FROM_FIELD_NUMBER: builtins.int
     TO_FIELD_NUMBER: builtins.int
@@ -3014,6 +3190,7 @@ class MeshPacket(google.protobuf.message.Message):
     RELAY_NODE_FIELD_NUMBER: builtins.int
     TX_AFTER_FIELD_NUMBER: builtins.int
     TRANSPORT_MECHANISM_FIELD_NUMBER: builtins.int
+    XEDDSA_SIGNED_FIELD_NUMBER: builtins.int
     to: builtins.int
     """
     The (immediate) destination for this packet
@@ -3053,6 +3230,12 @@ class MeshPacket(google.protobuf.message.Message):
     Note: this field is _never_ sent on the radio link itself (to save space) Times
     are typically not sent over the mesh, but they will be added to any Packet
     (chain of SubPacket) sent to the phone (so the phone can know exact time of reception)
+    Explicit presence: firmware cannot always attach a trustworthy wall-clock timestamp at the
+    moment of reception - a node with no GPS and no phone connected yet has no time source at
+    all. has_rx_time disambiguates that state from a genuine (if coincidental) 1970-01-01
+    reading. A packet delivered with this field absent may still be re-timestamped once a valid
+    clock becomes available, before the phone ever sees it - "absent" is not guaranteed
+    permanent, only "not yet known at last observation".
     """
     rx_snr: builtins.float
     """
@@ -3087,6 +3270,9 @@ class MeshPacket(google.protobuf.message.Message):
     rx_rssi: builtins.int
     """
     rssi of received packet. Only sent to phone for dispay purposes.
+    Explicit presence: rssi 0 is a legitimate reading on some radios (SX126x can report exactly
+    0 dBm; SX127x's formula can even go positive). has_rx_rssi disambiguates; a replayed packet
+    built from history should leave this field absent rather than emitting 0.
     """
     delayed: global___MeshPacket.Delayed.ValueType
     """
@@ -3100,6 +3286,10 @@ class MeshPacket(google.protobuf.message.Message):
     """
     Hop limit with which the original packet started. Sent via LoRa using three bits in the unencrypted header.
     When receiving a packet, the difference between hop_start and hop_limit gives how many hops it traveled.
+    hop_start == 0 does not necessarily mean a direct (0-hop) neighbor: firmware prior to 2.3.0
+    never populated this field, so a receiver can only trust hop_start == 0 as genuine once it has
+    decoded the packet and confirmed the sender's bitfield is present (added in 2.5.0). Until then,
+    or for a sender that never sets that bitfield, treat hop_start == 0 as unknown, not direct.
     """
     public_key: builtins.bytes
     """
@@ -3129,6 +3319,10 @@ class MeshPacket(google.protobuf.message.Message):
     """
     Indicates which transport mechanism this packet arrived over
     """
+    xeddsa_signed: builtins.bool
+    """
+    Indicates whether the packet has a valid signature
+    """
     @property
     def decoded(self) -> global___Data:
         """
@@ -3143,12 +3337,12 @@ class MeshPacket(google.protobuf.message.Message):
         decoded: global___Data | None = ...,
         encrypted: builtins.bytes = ...,
         id: builtins.int = ...,
-        rx_time: builtins.int = ...,
+        rx_time: builtins.int | None = ...,
         rx_snr: builtins.float = ...,
         hop_limit: builtins.int = ...,
         want_ack: builtins.bool = ...,
         priority: global___MeshPacket.Priority.ValueType = ...,
-        rx_rssi: builtins.int = ...,
+        rx_rssi: builtins.int | None = ...,
         delayed: global___MeshPacket.Delayed.ValueType = ...,
         via_mqtt: builtins.bool = ...,
         hop_start: builtins.int = ...,
@@ -3158,9 +3352,15 @@ class MeshPacket(google.protobuf.message.Message):
         relay_node: builtins.int = ...,
         tx_after: builtins.int = ...,
         transport_mechanism: global___MeshPacket.TransportMechanism.ValueType = ...,
+        xeddsa_signed: builtins.bool = ...,
     ) -> None: ...
-    def HasField(self, field_name: typing.Literal["decoded", b"decoded", "encrypted", b"encrypted", "payload_variant", b"payload_variant"]) -> builtins.bool: ...
-    def ClearField(self, field_name: typing.Literal["channel", b"channel", "decoded", b"decoded", "delayed", b"delayed", "encrypted", b"encrypted", "from", b"from", "hop_limit", b"hop_limit", "hop_start", b"hop_start", "id", b"id", "next_hop", b"next_hop", "payload_variant", b"payload_variant", "pki_encrypted", b"pki_encrypted", "priority", b"priority", "public_key", b"public_key", "relay_node", b"relay_node", "rx_rssi", b"rx_rssi", "rx_snr", b"rx_snr", "rx_time", b"rx_time", "to", b"to", "transport_mechanism", b"transport_mechanism", "tx_after", b"tx_after", "via_mqtt", b"via_mqtt", "want_ack", b"want_ack"]) -> None: ...
+    def HasField(self, field_name: typing.Literal["_rx_rssi", b"_rx_rssi", "_rx_time", b"_rx_time", "decoded", b"decoded", "encrypted", b"encrypted", "payload_variant", b"payload_variant", "rx_rssi", b"rx_rssi", "rx_time", b"rx_time"]) -> builtins.bool: ...
+    def ClearField(self, field_name: typing.Literal["_rx_rssi", b"_rx_rssi", "_rx_time", b"_rx_time", "channel", b"channel", "decoded", b"decoded", "delayed", b"delayed", "encrypted", b"encrypted", "from", b"from", "hop_limit", b"hop_limit", "hop_start", b"hop_start", "id", b"id", "next_hop", b"next_hop", "payload_variant", b"payload_variant", "pki_encrypted", b"pki_encrypted", "priority", b"priority", "public_key", b"public_key", "relay_node", b"relay_node", "rx_rssi", b"rx_rssi", "rx_snr", b"rx_snr", "rx_time", b"rx_time", "to", b"to", "transport_mechanism", b"transport_mechanism", "tx_after", b"tx_after", "via_mqtt", b"via_mqtt", "want_ack", b"want_ack", "xeddsa_signed", b"xeddsa_signed"]) -> None: ...
+    @typing.overload
+    def WhichOneof(self, oneof_group: typing.Literal["_rx_rssi", b"_rx_rssi"]) -> typing.Literal["rx_rssi"] | None: ...
+    @typing.overload
+    def WhichOneof(self, oneof_group: typing.Literal["_rx_time", b"_rx_time"]) -> typing.Literal["rx_time"] | None: ...
+    @typing.overload
     def WhichOneof(self, oneof_group: typing.Literal["payload_variant", b"payload_variant"]) -> typing.Literal["decoded", "encrypted"] | None: ...
 
 global___MeshPacket = MeshPacket
@@ -3201,6 +3401,7 @@ class NodeInfo(google.protobuf.message.Message):
     IS_IGNORED_FIELD_NUMBER: builtins.int
     IS_KEY_MANUALLY_VERIFIED_FIELD_NUMBER: builtins.int
     IS_MUTED_FIELD_NUMBER: builtins.int
+    HAS_XEDDSA_SIGNED_FIELD_NUMBER: builtins.int
     num: builtins.int
     """
     The node number
@@ -3253,6 +3454,12 @@ class NodeInfo(google.protobuf.message.Message):
     True if node has been muted
     Persistes between NodeDB internal clean ups
     """
+    has_xeddsa_signed: builtins.bool
+    """
+    True if node is signing its packets via XEdDSA
+    Persists between NodeDB internal clean ups
+    LSB 1 of the bitfield
+    """
     @property
     def user(self) -> global___User:
         """
@@ -3288,9 +3495,10 @@ class NodeInfo(google.protobuf.message.Message):
         is_ignored: builtins.bool = ...,
         is_key_manually_verified: builtins.bool = ...,
         is_muted: builtins.bool = ...,
+        has_xeddsa_signed: builtins.bool = ...,
     ) -> None: ...
     def HasField(self, field_name: typing.Literal["_hops_away", b"_hops_away", "device_metrics", b"device_metrics", "hops_away", b"hops_away", "position", b"position", "user", b"user"]) -> builtins.bool: ...
-    def ClearField(self, field_name: typing.Literal["_hops_away", b"_hops_away", "channel", b"channel", "device_metrics", b"device_metrics", "hops_away", b"hops_away", "is_favorite", b"is_favorite", "is_ignored", b"is_ignored", "is_key_manually_verified", b"is_key_manually_verified", "is_muted", b"is_muted", "last_heard", b"last_heard", "num", b"num", "position", b"position", "snr", b"snr", "user", b"user", "via_mqtt", b"via_mqtt"]) -> None: ...
+    def ClearField(self, field_name: typing.Literal["_hops_away", b"_hops_away", "channel", b"channel", "device_metrics", b"device_metrics", "has_xeddsa_signed", b"has_xeddsa_signed", "hops_away", b"hops_away", "is_favorite", b"is_favorite", "is_ignored", b"is_ignored", "is_key_manually_verified", b"is_key_manually_verified", "is_muted", b"is_muted", "last_heard", b"last_heard", "num", b"num", "position", b"position", "snr", b"snr", "user", b"user", "via_mqtt", b"via_mqtt"]) -> None: ...
     def WhichOneof(self, oneof_group: typing.Literal["_hops_away", b"_hops_away"]) -> typing.Literal["hops_away"] | None: ...
 
 global___NodeInfo = NodeInfo
@@ -3529,6 +3737,7 @@ class FromRadio(google.protobuf.message.Message):
     CLIENTNOTIFICATION_FIELD_NUMBER: builtins.int
     DEVICEUICONFIG_FIELD_NUMBER: builtins.int
     LOCKDOWN_STATUS_FIELD_NUMBER: builtins.int
+    REGION_PRESETS_FIELD_NUMBER: builtins.int
     id: builtins.int
     """
     The packet id, used to allow the phone to request missing read packets from the FIFO,
@@ -3644,6 +3853,16 @@ class FromRadio(google.protobuf.message.Message):
         encoding state as magic-string prefixes inside ClientNotification.
         """
 
+    @property
+    def region_presets(self) -> global___LoRaRegionPresetMap:
+        """
+        Map of which modem presets are legal in each LoRa region. Sent once
+        during the want_config handshake (right after `metadata`, before the
+        first `channel`) so client UIs can prevent the user from selecting an
+        illegal region+preset combination. A region that does not appear in
+        any group carries no constraint info and should not be restricted.
+        """
+
     def __init__(
         self,
         *,
@@ -3665,10 +3884,11 @@ class FromRadio(google.protobuf.message.Message):
         clientNotification: global___ClientNotification | None = ...,
         deviceuiConfig: meshtastic.protobuf.device_ui_pb2.DeviceUIConfig | None = ...,
         lockdown_status: global___LockdownStatus | None = ...,
+        region_presets: global___LoRaRegionPresetMap | None = ...,
     ) -> None: ...
-    def HasField(self, field_name: typing.Literal["channel", b"channel", "clientNotification", b"clientNotification", "config", b"config", "config_complete_id", b"config_complete_id", "deviceuiConfig", b"deviceuiConfig", "fileInfo", b"fileInfo", "lockdown_status", b"lockdown_status", "log_record", b"log_record", "metadata", b"metadata", "moduleConfig", b"moduleConfig", "mqttClientProxyMessage", b"mqttClientProxyMessage", "my_info", b"my_info", "node_info", b"node_info", "packet", b"packet", "payload_variant", b"payload_variant", "queueStatus", b"queueStatus", "rebooted", b"rebooted", "xmodemPacket", b"xmodemPacket"]) -> builtins.bool: ...
-    def ClearField(self, field_name: typing.Literal["channel", b"channel", "clientNotification", b"clientNotification", "config", b"config", "config_complete_id", b"config_complete_id", "deviceuiConfig", b"deviceuiConfig", "fileInfo", b"fileInfo", "id", b"id", "lockdown_status", b"lockdown_status", "log_record", b"log_record", "metadata", b"metadata", "moduleConfig", b"moduleConfig", "mqttClientProxyMessage", b"mqttClientProxyMessage", "my_info", b"my_info", "node_info", b"node_info", "packet", b"packet", "payload_variant", b"payload_variant", "queueStatus", b"queueStatus", "rebooted", b"rebooted", "xmodemPacket", b"xmodemPacket"]) -> None: ...
-    def WhichOneof(self, oneof_group: typing.Literal["payload_variant", b"payload_variant"]) -> typing.Literal["packet", "my_info", "node_info", "config", "log_record", "config_complete_id", "rebooted", "moduleConfig", "channel", "queueStatus", "xmodemPacket", "metadata", "mqttClientProxyMessage", "fileInfo", "clientNotification", "deviceuiConfig", "lockdown_status"] | None: ...
+    def HasField(self, field_name: typing.Literal["channel", b"channel", "clientNotification", b"clientNotification", "config", b"config", "config_complete_id", b"config_complete_id", "deviceuiConfig", b"deviceuiConfig", "fileInfo", b"fileInfo", "lockdown_status", b"lockdown_status", "log_record", b"log_record", "metadata", b"metadata", "moduleConfig", b"moduleConfig", "mqttClientProxyMessage", b"mqttClientProxyMessage", "my_info", b"my_info", "node_info", b"node_info", "packet", b"packet", "payload_variant", b"payload_variant", "queueStatus", b"queueStatus", "rebooted", b"rebooted", "region_presets", b"region_presets", "xmodemPacket", b"xmodemPacket"]) -> builtins.bool: ...
+    def ClearField(self, field_name: typing.Literal["channel", b"channel", "clientNotification", b"clientNotification", "config", b"config", "config_complete_id", b"config_complete_id", "deviceuiConfig", b"deviceuiConfig", "fileInfo", b"fileInfo", "id", b"id", "lockdown_status", b"lockdown_status", "log_record", b"log_record", "metadata", b"metadata", "moduleConfig", b"moduleConfig", "mqttClientProxyMessage", b"mqttClientProxyMessage", "my_info", b"my_info", "node_info", b"node_info", "packet", b"packet", "payload_variant", b"payload_variant", "queueStatus", b"queueStatus", "rebooted", b"rebooted", "region_presets", b"region_presets", "xmodemPacket", b"xmodemPacket"]) -> None: ...
+    def WhichOneof(self, oneof_group: typing.Literal["payload_variant", b"payload_variant"]) -> typing.Literal["packet", "my_info", "node_info", "config", "log_record", "config_complete_id", "rebooted", "moduleConfig", "channel", "queueStatus", "xmodemPacket", "metadata", "mqttClientProxyMessage", "fileInfo", "clientNotification", "deviceuiConfig", "lockdown_status", "region_presets"] | None: ...
 
 global___FromRadio = FromRadio
 
@@ -3713,6 +3933,15 @@ class LockdownStatus(google.protobuf.message.Message):
         """
         Passphrase rejected. backoff_seconds is non-zero when rate-limited.
         """
+        DISABLED: LockdownStatus._State.ValueType  # 5
+        """
+        Lockdown is supported by this firmware but not currently active
+        (no passphrase has been provisioned, or it was disabled via
+        AdminMessage.lockdown_auth.disable). The device is operating in
+        normal, non-encrypted mode. Clients render the lockdown-mode
+        toggle as OFF on receiving this. Distinct from NEEDS_PROVISION,
+        which is only used during an in-progress enable flow.
+        """
 
     class State(_State, metaclass=_StateEnumTypeWrapper): ...
     STATE_UNSPECIFIED: LockdownStatus.State.ValueType  # 0
@@ -3739,6 +3968,15 @@ class LockdownStatus(google.protobuf.message.Message):
     """
     Passphrase rejected. backoff_seconds is non-zero when rate-limited.
     """
+    DISABLED: LockdownStatus.State.ValueType  # 5
+    """
+    Lockdown is supported by this firmware but not currently active
+    (no passphrase has been provisioned, or it was disabled via
+    AdminMessage.lockdown_auth.disable). The device is operating in
+    normal, non-encrypted mode. Clients render the lockdown-mode
+    toggle as OFF on receiving this. Distinct from NEEDS_PROVISION,
+    which is only used during an in-progress enable flow.
+    """
 
     STATE_FIELD_NUMBER: builtins.int
     LOCK_REASON_FIELD_NUMBER: builtins.int
@@ -4174,6 +4412,7 @@ class DeviceMetadata(google.protobuf.message.Message):
     HASREMOTEHARDWARE_FIELD_NUMBER: builtins.int
     HASPKC_FIELD_NUMBER: builtins.int
     EXCLUDED_MODULES_FIELD_NUMBER: builtins.int
+    HAS_XEDDSA_FIELD_NUMBER: builtins.int
     firmware_version: builtins.str
     """
     Device firmware version string
@@ -4223,6 +4462,11 @@ class DeviceMetadata(google.protobuf.message.Message):
     Bit field of boolean for excluded modules
     (bitwise OR of ExcludedModules)
     """
+    has_xeddsa: builtins.bool
+    """
+    Indicates whether this firmware build includes XEdDSA packet signature verification.
+    This is a read-only capability and must be false when XEdDSA is not compiled in.
+    """
     def __init__(
         self,
         *,
@@ -4238,11 +4482,126 @@ class DeviceMetadata(google.protobuf.message.Message):
         hasRemoteHardware: builtins.bool = ...,
         hasPKC: builtins.bool = ...,
         excluded_modules: builtins.int = ...,
+        has_xeddsa: builtins.bool = ...,
     ) -> None: ...
-    def ClearField(self, field_name: typing.Literal["canShutdown", b"canShutdown", "device_state_version", b"device_state_version", "excluded_modules", b"excluded_modules", "firmware_version", b"firmware_version", "hasBluetooth", b"hasBluetooth", "hasEthernet", b"hasEthernet", "hasPKC", b"hasPKC", "hasRemoteHardware", b"hasRemoteHardware", "hasWifi", b"hasWifi", "hw_model", b"hw_model", "position_flags", b"position_flags", "role", b"role"]) -> None: ...
+    def ClearField(self, field_name: typing.Literal["canShutdown", b"canShutdown", "device_state_version", b"device_state_version", "excluded_modules", b"excluded_modules", "firmware_version", b"firmware_version", "hasBluetooth", b"hasBluetooth", "hasEthernet", b"hasEthernet", "hasPKC", b"hasPKC", "hasRemoteHardware", b"hasRemoteHardware", "hasWifi", b"hasWifi", "has_xeddsa", b"has_xeddsa", "hw_model", b"hw_model", "position_flags", b"position_flags", "role", b"role"]) -> None: ...
 
 global___DeviceMetadata = DeviceMetadata
 
+@typing.final
+class LoRaPresetGroup(google.protobuf.message.Message):
+    """
+    A distinct set of legal modem presets shared by one or more LoRa regions.
+    Regions that have an identical preset list / default / licensing reference
+    the same group (by index) via LoRaRegionPresetMap.region_groups. This keeps
+    the whole map small enough to fit in a single FromRadio packet, since most
+    regions share the one standard preset list.
+    """
+
+    DESCRIPTOR: google.protobuf.descriptor.Descriptor
+
+    PRESETS_FIELD_NUMBER: builtins.int
+    DEFAULT_PRESET_FIELD_NUMBER: builtins.int
+    LICENSED_ONLY_FIELD_NUMBER: builtins.int
+    default_preset: meshtastic.protobuf.config_pb2.Config.LoRaConfig.ModemPreset.ValueType
+    """
+    The firmware's default modem preset for regions in this group.
+    Always one of `presets`. Clients should select this when switching to one
+    of these regions, or when the current preset is not legal in the new region.
+    """
+    licensed_only: builtins.bool
+    """
+    True if regions referencing this group are for licensed operators only
+    (e.g. amateur / ham radio bands). Clients should warn or gate accordingly.
+    """
+    @property
+    def presets(self) -> google.protobuf.internal.containers.RepeatedScalarFieldContainer[meshtastic.protobuf.config_pb2.Config.LoRaConfig.ModemPreset.ValueType]:
+        """
+        The modem presets that are legal for every region referencing this group.
+        """
+
+    def __init__(
+        self,
+        *,
+        presets: collections.abc.Iterable[meshtastic.protobuf.config_pb2.Config.LoRaConfig.ModemPreset.ValueType] | None = ...,
+        default_preset: meshtastic.protobuf.config_pb2.Config.LoRaConfig.ModemPreset.ValueType = ...,
+        licensed_only: builtins.bool = ...,
+    ) -> None: ...
+    def ClearField(self, field_name: typing.Literal["default_preset", b"default_preset", "licensed_only", b"licensed_only", "presets", b"presets"]) -> None: ...
+
+global___LoRaPresetGroup = LoRaPresetGroup
+
+@typing.final
+class LoRaRegionPresets(google.protobuf.message.Message):
+    """
+    Associates a single LoRa region with its preset group.
+    """
+
+    DESCRIPTOR: google.protobuf.descriptor.Descriptor
+
+    REGION_FIELD_NUMBER: builtins.int
+    GROUP_INDEX_FIELD_NUMBER: builtins.int
+    region: meshtastic.protobuf.config_pb2.Config.LoRaConfig.RegionCode.ValueType
+    """
+    The LoRa region this entry describes.
+    """
+    group_index: builtins.int
+    """
+    Index into LoRaRegionPresetMap.groups for the preset list that is legal
+    in `region`.
+    """
+    def __init__(
+        self,
+        *,
+        region: meshtastic.protobuf.config_pb2.Config.LoRaConfig.RegionCode.ValueType = ...,
+        group_index: builtins.int = ...,
+    ) -> None: ...
+    def ClearField(self, field_name: typing.Literal["group_index", b"group_index", "region", b"region"]) -> None: ...
+
+global___LoRaRegionPresets = LoRaRegionPresets
+
+@typing.final
+class LoRaRegionPresetMap(google.protobuf.message.Message):
+    """
+    Map describing which modem presets are valid for each LoRa region. Sent by
+    the firmware during the want_config handshake (as FromRadio.region_presets)
+    so that client UIs can prevent illegal region+preset selections.
+
+    Delivery is grouped to save space: `groups` holds each distinct preset list,
+    and `region_groups` maps every known region to one of those groups by index.
+    A region that does NOT appear in `region_groups` carries no constraint
+    information and should not be restricted by the client (e.g. firmware that
+    predates this message, or a region with no firmware table entry). Clients
+    must also tolerate this whole message being absent.
+    """
+
+    DESCRIPTOR: google.protobuf.descriptor.Descriptor
+
+    GROUPS_FIELD_NUMBER: builtins.int
+    REGION_GROUPS_FIELD_NUMBER: builtins.int
+    @property
+    def groups(self) -> google.protobuf.internal.containers.RepeatedCompositeFieldContainer[global___LoRaPresetGroup]:
+        """
+        One entry per distinct (preset-list, default, licensing) combination.
+        Referenced by index from `region_groups`.
+        """
+
+    @property
+    def region_groups(self) -> google.protobuf.internal.containers.RepeatedCompositeFieldContainer[global___LoRaRegionPresets]:
+        """
+        One entry per known LoRa region, pointing at its preset group.
+        """
+
+    def __init__(
+        self,
+        *,
+        groups: collections.abc.Iterable[global___LoRaPresetGroup] | None = ...,
+        region_groups: collections.abc.Iterable[global___LoRaRegionPresets] | None = ...,
+    ) -> None: ...
+    def ClearField(self, field_name: typing.Literal["groups", b"groups", "region_groups", b"region_groups"]) -> None: ...
+
+global___LoRaRegionPresetMap = LoRaRegionPresetMap
+
 @typing.final
 class Heartbeat(google.protobuf.message.Message):
     """

meshtastic/protobuf/module_config_pb2.pyi

@@ -10,6 +10,8 @@ import google.protobuf.internal.containers
 import google.protobuf.internal.enum_type_wrapper
 import google.protobuf.message
 import meshtastic.protobuf.atak_pb2
+import meshtastic.protobuf.channel_pb2
+import meshtastic.protobuf.config_pb2
 import sys
 import typing
 
@@ -502,95 +504,48 @@ class ModuleConfig(google.protobuf.message.Message):
 
         DESCRIPTOR: google.protobuf.descriptor.Descriptor
 
-        ENABLED_FIELD_NUMBER: builtins.int
-        POSITION_DEDUP_ENABLED_FIELD_NUMBER: builtins.int
-        POSITION_PRECISION_BITS_FIELD_NUMBER: builtins.int
         POSITION_MIN_INTERVAL_SECS_FIELD_NUMBER: builtins.int
-        NODEINFO_DIRECT_RESPONSE_FIELD_NUMBER: builtins.int
         NODEINFO_DIRECT_RESPONSE_MAX_HOPS_FIELD_NUMBER: builtins.int
-        RATE_LIMIT_ENABLED_FIELD_NUMBER: builtins.int
         RATE_LIMIT_WINDOW_SECS_FIELD_NUMBER: builtins.int
         RATE_LIMIT_MAX_PACKETS_FIELD_NUMBER: builtins.int
-        DROP_UNKNOWN_ENABLED_FIELD_NUMBER: builtins.int
         UNKNOWN_PACKET_THRESHOLD_FIELD_NUMBER: builtins.int
-        EXHAUST_HOP_TELEMETRY_FIELD_NUMBER: builtins.int
-        EXHAUST_HOP_POSITION_FIELD_NUMBER: builtins.int
-        ROUTER_PRESERVE_HOPS_FIELD_NUMBER: builtins.int
-        enabled: builtins.bool
-        """
-        Master enable for traffic management module
-        """
-        position_dedup_enabled: builtins.bool
-        """
-        Enable position deduplication to drop redundant position broadcasts
-        """
-        position_precision_bits: builtins.int
-        """
-        Number of bits of precision for position deduplication (0-32)
-        """
         position_min_interval_secs: builtins.int
         """
-        Minimum interval in seconds between position updates from the same node
-        """
-        nodeinfo_direct_response: builtins.bool
-        """
-        Enable direct response to NodeInfo requests from local cache
+        Minimum interval in seconds between position updates from the same node.
+        A non-zero value implicitly enables the suppression window; 0 disables it.
         """
         nodeinfo_direct_response_max_hops: builtins.int
         """
-        Minimum hop distance from requestor before responding to NodeInfo requests
-        """
-        rate_limit_enabled: builtins.bool
-        """
-        Enable per-node rate limiting to throttle chatty nodes
+        Maximum hop distance from the requestor at which direct NodeInfo responses
+        are served from the local cache. A non-zero value implicitly enables direct
+        response; 0 disables it.
         """
         rate_limit_window_secs: builtins.int
         """
-        Time window in seconds for rate limiting calculations
+        Time window in seconds for per-node rate limiting.
+        A non-zero value implicitly enables rate limiting; 0 disables it.
         """
         rate_limit_max_packets: builtins.int
         """
-        Maximum packets allowed per node within the rate limit window
-        """
-        drop_unknown_enabled: builtins.bool
-        """
-        Enable dropping of unknown/undecryptable packets per rate_limit_window_secs
+        Maximum packets allowed per node within the rate limit window.
+        A non-zero value implicitly enables rate limiting; 0 disables it.
         """
         unknown_packet_threshold: builtins.int
         """
-        Number of unknown packets before dropping from a node
-        """
-        exhaust_hop_telemetry: builtins.bool
-        """
-        Set hop_limit to 0 for relayed telemetry broadcasts (own packets unaffected)
-        """
-        exhaust_hop_position: builtins.bool
-        """
-        Set hop_limit to 0 for relayed position broadcasts (own packets unaffected)
-        """
-        router_preserve_hops: builtins.bool
-        """
-        Preserve hop_limit for router-to-router traffic
+        Maximum unknown/undecryptable packets per rate window before the source
+        is dropped. A non-zero value implicitly enables unknown-packet filtering;
+        0 disables it.
         """
         def __init__(
             self,
             *,
-            enabled: builtins.bool = ...,
-            position_dedup_enabled: builtins.bool = ...,
-            position_precision_bits: builtins.int = ...,
             position_min_interval_secs: builtins.int = ...,
-            nodeinfo_direct_response: builtins.bool = ...,
             nodeinfo_direct_response_max_hops: builtins.int = ...,
-            rate_limit_enabled: builtins.bool = ...,
             rate_limit_window_secs: builtins.int = ...,
             rate_limit_max_packets: builtins.int = ...,
-            drop_unknown_enabled: builtins.bool = ...,
             unknown_packet_threshold: builtins.int = ...,
-            exhaust_hop_telemetry: builtins.bool = ...,
-            exhaust_hop_position: builtins.bool = ...,
-            router_preserve_hops: builtins.bool = ...,
         ) -> None: ...
-        def ClearField(self, field_name: typing.Literal["drop_unknown_enabled", b"drop_unknown_enabled", "enabled", b"enabled", "exhaust_hop_position", b"exhaust_hop_position", "exhaust_hop_telemetry", b"exhaust_hop_telemetry", "nodeinfo_direct_response", b"nodeinfo_direct_response", "nodeinfo_direct_response_max_hops", b"nodeinfo_direct_response_max_hops", "position_dedup_enabled", b"position_dedup_enabled", "position_min_interval_secs", b"position_min_interval_secs", "position_precision_bits", b"position_precision_bits", "rate_limit_enabled", b"rate_limit_enabled", "rate_limit_max_packets", b"rate_limit_max_packets", "rate_limit_window_secs", b"rate_limit_window_secs", "router_preserve_hops", b"router_preserve_hops", "unknown_packet_threshold", b"unknown_packet_threshold"]) -> None: ...
+        def ClearField(self, field_name: typing.Literal["nodeinfo_direct_response_max_hops", b"nodeinfo_direct_response_max_hops", "position_min_interval_secs", b"position_min_interval_secs", "rate_limit_max_packets", b"rate_limit_max_packets", "rate_limit_window_secs", b"rate_limit_window_secs", "unknown_packet_threshold", b"unknown_packet_threshold"]) -> None: ...
 
     @typing.final
     class SerialConfig(google.protobuf.message.Message):
@@ -1302,6 +1257,173 @@ class ModuleConfig(google.protobuf.message.Message):
         ) -> None: ...
         def ClearField(self, field_name: typing.Literal["node_status", b"node_status"]) -> None: ...
 
+    @typing.final
+    class MeshBeaconConfig(google.protobuf.message.Message):
+        """
+        MeshBeacon module config
+        """
+
+        DESCRIPTOR: google.protobuf.descriptor.Descriptor
+
+        class _Flags:
+            ValueType = typing.NewType("ValueType", builtins.int)
+            V: typing_extensions.TypeAlias = ValueType
+
+        class _FlagsEnumTypeWrapper(google.protobuf.internal.enum_type_wrapper._EnumTypeWrapper[ModuleConfig.MeshBeaconConfig._Flags.ValueType], builtins.type):
+            DESCRIPTOR: google.protobuf.descriptor.EnumDescriptor
+            FLAG_NONE: ModuleConfig.MeshBeaconConfig._Flags.ValueType  # 0
+            """
+            No options enabled.
+            """
+            FLAG_LISTEN_ENABLED: ModuleConfig.MeshBeaconConfig._Flags.ValueType  # 1
+            """
+            Enable receiving MESH_BEACON_APP packets from other nodes.
+            The text portion is delivered to the local message inbox.
+            Offered channel/preset are stored for the client app to act on.
+            """
+            FLAG_BROADCAST_ENABLED: ModuleConfig.MeshBeaconConfig._Flags.ValueType  # 2
+            """
+            Enable periodically broadcasting MESH_BEACON_APP packets from this node.
+            """
+            FLAG_LEGACY_SPLIT: ModuleConfig.MeshBeaconConfig._Flags.ValueType  # 4
+            """
+            When both text and offer content are present, split the beacon into a separate
+            MESH_BEACON_APP (offer only) and TEXT_MESSAGE_APP (text only) packet, so firmware
+            that only decodes TEXT_MESSAGE_APP still receives the human-readable text.
+            """
+
+        class Flags(_Flags, metaclass=_FlagsEnumTypeWrapper):
+            """
+            Boolean options for the beacon module, packed into the `flags` bitfield below.
+            OR the FLAG_* values together; a flag is on when its bit is set.
+            """
+
+        FLAG_NONE: ModuleConfig.MeshBeaconConfig.Flags.ValueType  # 0
+        """
+        No options enabled.
+        """
+        FLAG_LISTEN_ENABLED: ModuleConfig.MeshBeaconConfig.Flags.ValueType  # 1
+        """
+        Enable receiving MESH_BEACON_APP packets from other nodes.
+        The text portion is delivered to the local message inbox.
+        Offered channel/preset are stored for the client app to act on.
+        """
+        FLAG_BROADCAST_ENABLED: ModuleConfig.MeshBeaconConfig.Flags.ValueType  # 2
+        """
+        Enable periodically broadcasting MESH_BEACON_APP packets from this node.
+        """
+        FLAG_LEGACY_SPLIT: ModuleConfig.MeshBeaconConfig.Flags.ValueType  # 4
+        """
+        When both text and offer content are present, split the beacon into a separate
+        MESH_BEACON_APP (offer only) and TEXT_MESSAGE_APP (text only) packet, so firmware
+        that only decodes TEXT_MESSAGE_APP still receives the human-readable text.
+        """
+
+        @typing.final
+        class BroadcastTarget(google.protobuf.message.Message):
+            """
+            One entry in the broadcast destination list.
+            Each entry names one set of radio settings to send a beacon copy on.
+            """
+
+            DESCRIPTOR: google.protobuf.descriptor.Descriptor
+
+            PRESET_FIELD_NUMBER: builtins.int
+            REGION_FIELD_NUMBER: builtins.int
+            CHANNEL_INDEX_FIELD_NUMBER: builtins.int
+            preset: meshtastic.protobuf.config_pb2.Config.LoRaConfig.ModemPreset.ValueType
+            """
+            Modem preset to use for this target.
+            Falls back to the running config preset if unset.
+            """
+            region: meshtastic.protobuf.config_pb2.Config.LoRaConfig.RegionCode.ValueType
+            """
+            Region to use for this target. UNSET means use the running config region.
+            """
+            channel_index: builtins.int
+            """Tag 3 was an embedded ChannelSettings; replaced by channel_index (tag 4) to keep
+            ModuleConfig within the BLE FromRadio size budget. Branch unreleased, so tag 3 is a gap.
+
+
+            Index into the device's channel table (0..MAX_NUM_CHANNELS-1) of the channel to
+            transmit this target's beacon on. The referenced channel must already be configured
+            on the node (its key is needed to encrypt). If unset, the default channel for the
+            preset is used.
+            """
+            def __init__(
+                self,
+                *,
+                preset: meshtastic.protobuf.config_pb2.Config.LoRaConfig.ModemPreset.ValueType | None = ...,
+                region: meshtastic.protobuf.config_pb2.Config.LoRaConfig.RegionCode.ValueType = ...,
+                channel_index: builtins.int | None = ...,
+            ) -> None: ...
+            def HasField(self, field_name: typing.Literal["_channel_index", b"_channel_index", "_preset", b"_preset", "channel_index", b"channel_index", "preset", b"preset"]) -> builtins.bool: ...
+            def ClearField(self, field_name: typing.Literal["_channel_index", b"_channel_index", "_preset", b"_preset", "channel_index", b"channel_index", "preset", b"preset", "region", b"region"]) -> None: ...
+            @typing.overload
+            def WhichOneof(self, oneof_group: typing.Literal["_channel_index", b"_channel_index"]) -> typing.Literal["channel_index"] | None: ...
+            @typing.overload
+            def WhichOneof(self, oneof_group: typing.Literal["_preset", b"_preset"]) -> typing.Literal["preset"] | None: ...
+
+        FLAGS_FIELD_NUMBER: builtins.int
+        BROADCAST_MESSAGE_FIELD_NUMBER: builtins.int
+        BROADCAST_OFFER_CHANNEL_FIELD_NUMBER: builtins.int
+        BROADCAST_OFFER_REGION_FIELD_NUMBER: builtins.int
+        BROADCAST_OFFER_PRESET_FIELD_NUMBER: builtins.int
+        BROADCAST_INTERVAL_SECS_FIELD_NUMBER: builtins.int
+        BROADCAST_TARGETS_FIELD_NUMBER: builtins.int
+        flags: builtins.int
+        """
+        Bitwise-OR of Flags values (listen / broadcast / legacy-split toggles).
+        """
+        broadcast_message: builtins.str
+        """
+        Message to include in each beacon broadcast. Max 100 bytes enforced by firmware.
+        """
+        broadcast_offer_region: meshtastic.protobuf.config_pb2.Config.LoRaConfig.RegionCode.ValueType
+        """
+        Optional region to advertise in the MeshBeacon offer_region field.
+        """
+        broadcast_offer_preset: meshtastic.protobuf.config_pb2.Config.LoRaConfig.ModemPreset.ValueType
+        """
+        Optional modem preset to advertise in the MeshBeacon offer_preset field.
+        """
+        broadcast_interval_secs: builtins.int
+        """
+        How often to broadcast, in seconds. Min 3600 (1 h), default 3600.
+        """
+        @property
+        def broadcast_offer_channel(self) -> meshtastic.protobuf.channel_pb2.ChannelSettings:
+            """
+            Optional channel (name + PSK) to advertise in the MeshBeacon offer_channel field.
+            """
+
+        @property
+        def broadcast_targets(self) -> google.protobuf.internal.containers.RepeatedCompositeFieldContainer[global___ModuleConfig.MeshBeaconConfig.BroadcastTarget]:
+            """
+            Broadcast destination list.
+            The broadcaster sends one beacon copy per distinct destination, in sequence, temporarily
+            switching the radio to that entry's preset/region/channel for each.
+            When empty, a single beacon is sent on the node's running preset and region over the
+            primary channel.
+            Entries that resolve to the same effective preset, region and channel are deduplicated, so
+            a duplicate entry does not produce a second transmission.
+            """
+
+        def __init__(
+            self,
+            *,
+            flags: builtins.int = ...,
+            broadcast_message: builtins.str = ...,
+            broadcast_offer_channel: meshtastic.protobuf.channel_pb2.ChannelSettings | None = ...,
+            broadcast_offer_region: meshtastic.protobuf.config_pb2.Config.LoRaConfig.RegionCode.ValueType = ...,
+            broadcast_offer_preset: meshtastic.protobuf.config_pb2.Config.LoRaConfig.ModemPreset.ValueType | None = ...,
+            broadcast_interval_secs: builtins.int = ...,
+            broadcast_targets: collections.abc.Iterable[global___ModuleConfig.MeshBeaconConfig.BroadcastTarget] | None = ...,
+        ) -> None: ...
+        def HasField(self, field_name: typing.Literal["_broadcast_offer_preset", b"_broadcast_offer_preset", "broadcast_offer_channel", b"broadcast_offer_channel", "broadcast_offer_preset", b"broadcast_offer_preset"]) -> builtins.bool: ...
+        def ClearField(self, field_name: typing.Literal["_broadcast_offer_preset", b"_broadcast_offer_preset", "broadcast_interval_secs", b"broadcast_interval_secs", "broadcast_message", b"broadcast_message", "broadcast_offer_channel", b"broadcast_offer_channel", "broadcast_offer_preset", b"broadcast_offer_preset", "broadcast_offer_region", b"broadcast_offer_region", "broadcast_targets", b"broadcast_targets", "flags", b"flags"]) -> None: ...
+        def WhichOneof(self, oneof_group: typing.Literal["_broadcast_offer_preset", b"_broadcast_offer_preset"]) -> typing.Literal["broadcast_offer_preset"] | None: ...
+
     @typing.final
     class TAKConfig(google.protobuf.message.Message):
         """
@@ -1346,6 +1468,7 @@ class ModuleConfig(google.protobuf.message.Message):
     STATUSMESSAGE_FIELD_NUMBER: builtins.int
     TRAFFIC_MANAGEMENT_FIELD_NUMBER: builtins.int
     TAK_FIELD_NUMBER: builtins.int
+    MESH_BEACON_FIELD_NUMBER: builtins.int
     @property
     def mqtt(self) -> global___ModuleConfig.MQTTConfig:
         """
@@ -1442,6 +1565,12 @@ class ModuleConfig(google.protobuf.message.Message):
         TAK team/role configuration for TAK_TRACKER
         """
 
+    @property
+    def mesh_beacon(self) -> global___ModuleConfig.MeshBeaconConfig:
+        """
+        MeshBeacon module config
+        """
+
     def __init__(
         self,
         *,
@@ -1461,10 +1590,11 @@ class ModuleConfig(google.protobuf.message.Message):
         statusmessage: global___ModuleConfig.StatusMessageConfig | None = ...,
         traffic_management: global___ModuleConfig.TrafficManagementConfig | None = ...,
         tak: global___ModuleConfig.TAKConfig | None = ...,
+        mesh_beacon: global___ModuleConfig.MeshBeaconConfig | None = ...,
     ) -> None: ...
-    def HasField(self, field_name: typing.Literal["ambient_lighting", b"ambient_lighting", "audio", b"audio", "canned_message", b"canned_message", "detection_sensor", b"detection_sensor", "external_notification", b"external_notification", "mqtt", b"mqtt", "neighbor_info", b"neighbor_info", "paxcounter", b"paxcounter", "payload_variant", b"payload_variant", "range_test", b"range_test", "remote_hardware", b"remote_hardware", "serial", b"serial", "statusmessage", b"statusmessage", "store_forward", b"store_forward", "tak", b"tak", "telemetry", b"telemetry", "traffic_management", b"traffic_management"]) -> builtins.bool: ...
-    def ClearField(self, field_name: typing.Literal["ambient_lighting", b"ambient_lighting", "audio", b"audio", "canned_message", b"canned_message", "detection_sensor", b"detection_sensor", "external_notification", b"external_notification", "mqtt", b"mqtt", "neighbor_info", b"neighbor_info", "paxcounter", b"paxcounter", "payload_variant", b"payload_variant", "range_test", b"range_test", "remote_hardware", b"remote_hardware", "serial", b"serial", "statusmessage", b"statusmessage", "store_forward", b"store_forward", "tak", b"tak", "telemetry", b"telemetry", "traffic_management", b"traffic_management"]) -> None: ...
-    def WhichOneof(self, oneof_group: typing.Literal["payload_variant", b"payload_variant"]) -> typing.Literal["mqtt", "serial", "external_notification", "store_forward", "range_test", "telemetry", "canned_message", "audio", "remote_hardware", "neighbor_info", "ambient_lighting", "detection_sensor", "paxcounter", "statusmessage", "traffic_management", "tak"] | None: ...
+    def HasField(self, field_name: typing.Literal["ambient_lighting", b"ambient_lighting", "audio", b"audio", "canned_message", b"canned_message", "detection_sensor", b"detection_sensor", "external_notification", b"external_notification", "mesh_beacon", b"mesh_beacon", "mqtt", b"mqtt", "neighbor_info", b"neighbor_info", "paxcounter", b"paxcounter", "payload_variant", b"payload_variant", "range_test", b"range_test", "remote_hardware", b"remote_hardware", "serial", b"serial", "statusmessage", b"statusmessage", "store_forward", b"store_forward", "tak", b"tak", "telemetry", b"telemetry", "traffic_management", b"traffic_management"]) -> builtins.bool: ...
+    def ClearField(self, field_name: typing.Literal["ambient_lighting", b"ambient_lighting", "audio", b"audio", "canned_message", b"canned_message", "detection_sensor", b"detection_sensor", "external_notification", b"external_notification", "mesh_beacon", b"mesh_beacon", "mqtt", b"mqtt", "neighbor_info", b"neighbor_info", "paxcounter", b"paxcounter", "payload_variant", b"payload_variant", "range_test", b"range_test", "remote_hardware", b"remote_hardware", "serial", b"serial", "statusmessage", b"statusmessage", "store_forward", b"store_forward", "tak", b"tak", "telemetry", b"telemetry", "traffic_management", b"traffic_management"]) -> None: ...
+    def WhichOneof(self, oneof_group: typing.Literal["payload_variant", b"payload_variant"]) -> typing.Literal["mqtt", "serial", "external_notification", "store_forward", "range_test", "telemetry", "canned_message", "audio", "remote_hardware", "neighbor_info", "ambient_lighting", "detection_sensor", "paxcounter", "statusmessage", "traffic_management", "tak", "mesh_beacon"] | None: ...
 
 global___ModuleConfig = ModuleConfig
 

meshtastic/protobuf/mqtt_pb2.py

@@ -16,7 +16,7 @@ from meshtastic.protobuf import mesh_pb2 as meshtastic_dot_protobuf_dot_mesh__pb
 from meshtastic.protobuf import nanopb_pb2 as meshtastic_dot_protobuf_dot_nanopb__pb2
 
 
-DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\x1emeshtastic/protobuf/mqtt.proto\x12\x13meshtastic.protobuf\x1a meshtastic/protobuf/config.proto\x1a\x1emeshtastic/protobuf/mesh.proto\x1a meshtastic/protobuf/nanopb.proto\"j\n\x0fServiceEnvelope\x12/\n\x06packet\x18\x01 \x01(\x0b\x32\x1f.meshtastic.protobuf.MeshPacket\x12\x12\n\nchannel_id\x18\x02 \x01(\t\x12\x12\n\ngateway_id\x18\x03 \x01(\t\"\x9f\x04\n\tMapReport\x12\x18\n\tlong_name\x18\x01 \x01(\tB\x05\x92?\x02\x08(\x12\x19\n\nshort_name\x18\x02 \x01(\tB\x05\x92?\x02\x08\x05\x12;\n\x04role\x18\x03 \x01(\x0e\x32-.meshtastic.protobuf.Config.DeviceConfig.Role\x12\x34\n\x08hw_model\x18\x04 \x01(\x0e\x32\".meshtastic.protobuf.HardwareModel\x12\x1f\n\x10\x66irmware_version\x18\x05 \x01(\tB\x05\x92?\x02\x08\x12\x12\x41\n\x06region\x18\x06 \x01(\x0e\x32\x31.meshtastic.protobuf.Config.LoRaConfig.RegionCode\x12H\n\x0cmodem_preset\x18\x07 \x01(\x0e\x32\x32.meshtastic.protobuf.Config.LoRaConfig.ModemPreset\x12\x1b\n\x13has_default_channel\x18\x08 \x01(\x08\x12\x12\n\nlatitude_i\x18\t \x01(\x0f\x12\x13\n\x0blongitude_i\x18\n \x01(\x0f\x12\x10\n\x08\x61ltitude\x18\x0b \x01(\x05\x12\x1a\n\x12position_precision\x18\x0c \x01(\r\x12%\n\x16num_online_local_nodes\x18\r \x01(\rB\x05\x92?\x02\x38\x10\x12!\n\x19has_opted_report_location\x18\x0e \x01(\x08\x42`\n\x14org.meshtastic.protoB\nMQTTProtosZ\"github.com/meshtastic/go/generated\xaa\x02\x14Meshtastic.Protobufs\xba\x02\x00\x62\x06proto3')
+DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\x1emeshtastic/protobuf/mqtt.proto\x12\x13meshtastic.protobuf\x1a meshtastic/protobuf/config.proto\x1a\x1emeshtastic/protobuf/mesh.proto\x1a meshtastic/protobuf/nanopb.proto\"\x7f\n\x0fServiceEnvelope\x12\x36\n\x06packet\x18\x01 \x01(\x0b\x32\x1f.meshtastic.protobuf.MeshPacketB\x05\x92?\x02\x18\x04\x12\x19\n\nchannel_id\x18\x02 \x01(\tB\x05\x92?\x02\x18\x04\x12\x19\n\ngateway_id\x18\x03 \x01(\tB\x05\x92?\x02\x18\x04\"\x9f\x04\n\tMapReport\x12\x18\n\tlong_name\x18\x01 \x01(\tB\x05\x92?\x02\x08\x19\x12\x19\n\nshort_name\x18\x02 \x01(\tB\x05\x92?\x02\x08\x05\x12;\n\x04role\x18\x03 \x01(\x0e\x32-.meshtastic.protobuf.Config.DeviceConfig.Role\x12\x34\n\x08hw_model\x18\x04 \x01(\x0e\x32\".meshtastic.protobuf.HardwareModel\x12\x1f\n\x10\x66irmware_version\x18\x05 \x01(\tB\x05\x92?\x02\x08\x12\x12\x41\n\x06region\x18\x06 \x01(\x0e\x32\x31.meshtastic.protobuf.Config.LoRaConfig.RegionCode\x12H\n\x0cmodem_preset\x18\x07 \x01(\x0e\x32\x32.meshtastic.protobuf.Config.LoRaConfig.ModemPreset\x12\x1b\n\x13has_default_channel\x18\x08 \x01(\x08\x12\x12\n\nlatitude_i\x18\t \x01(\x0f\x12\x13\n\x0blongitude_i\x18\n \x01(\x0f\x12\x10\n\x08\x61ltitude\x18\x0b \x01(\x05\x12\x1a\n\x12position_precision\x18\x0c \x01(\r\x12%\n\x16num_online_local_nodes\x18\r \x01(\rB\x05\x92?\x02\x38\x10\x12!\n\x19has_opted_report_location\x18\x0e \x01(\x08\x42`\n\x14org.meshtastic.protoB\nMQTTProtosZ\"github.com/meshtastic/go/generated\xaa\x02\x14Meshtastic.Protobufs\xba\x02\x00\x62\x06proto3')
 
 _globals = globals()
 _builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals)
@@ -24,8 +24,14 @@ _builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'meshtastic.protobuf.mqtt_pb
 if _descriptor._USE_C_DESCRIPTORS == False:
   DESCRIPTOR._options = None
   DESCRIPTOR._serialized_options = b'\n\024org.meshtastic.protoB\nMQTTProtosZ\"github.com/meshtastic/go/generated\252\002\024Meshtastic.Protobufs\272\002\000'
+  _SERVICEENVELOPE.fields_by_name['packet']._options = None
+  _SERVICEENVELOPE.fields_by_name['packet']._serialized_options = b'\222?\002\030\004'
+  _SERVICEENVELOPE.fields_by_name['channel_id']._options = None
+  _SERVICEENVELOPE.fields_by_name['channel_id']._serialized_options = b'\222?\002\030\004'
+  _SERVICEENVELOPE.fields_by_name['gateway_id']._options = None
+  _SERVICEENVELOPE.fields_by_name['gateway_id']._serialized_options = b'\222?\002\030\004'
   _MAPREPORT.fields_by_name['long_name']._options = None
-  _MAPREPORT.fields_by_name['long_name']._serialized_options = b'\222?\002\010('
+  _MAPREPORT.fields_by_name['long_name']._serialized_options = b'\222?\002\010\031'
   _MAPREPORT.fields_by_name['short_name']._options = None
   _MAPREPORT.fields_by_name['short_name']._serialized_options = b'\222?\002\010\005'
   _MAPREPORT.fields_by_name['firmware_version']._options = None
@@ -33,7 +39,7 @@ if _descriptor._USE_C_DESCRIPTORS == False:
   _MAPREPORT.fields_by_name['num_online_local_nodes']._options = None
   _MAPREPORT.fields_by_name['num_online_local_nodes']._serialized_options = b'\222?\0028\020'
   _globals['_SERVICEENVELOPE']._serialized_start=155
-  _globals['_SERVICEENVELOPE']._serialized_end=261
-  _globals['_MAPREPORT']._serialized_start=264
-  _globals['_MAPREPORT']._serialized_end=807
+  _globals['_SERVICEENVELOPE']._serialized_end=282
+  _globals['_MAPREPORT']._serialized_start=285
+  _globals['_MAPREPORT']._serialized_end=828
 # @@protoc_insertion_point(module_scope)

meshtastic/protobuf/portnums_pb2.py

@@ -13,7 +13,7 @@ _sym_db = _symbol_database.Default()
 
 
 
-DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\"meshtastic/protobuf/portnums.proto\x12\x13meshtastic.protobuf*\xfd\x05\n\x07PortNum\x12\x0f\n\x0bUNKNOWN_APP\x10\x00\x12\x14\n\x10TEXT_MESSAGE_APP\x10\x01\x12\x17\n\x13REMOTE_HARDWARE_APP\x10\x02\x12\x10\n\x0cPOSITION_APP\x10\x03\x12\x10\n\x0cNODEINFO_APP\x10\x04\x12\x0f\n\x0bROUTING_APP\x10\x05\x12\r\n\tADMIN_APP\x10\x06\x12\x1f\n\x1bTEXT_MESSAGE_COMPRESSED_APP\x10\x07\x12\x10\n\x0cWAYPOINT_APP\x10\x08\x12\r\n\tAUDIO_APP\x10\t\x12\x18\n\x14\x44\x45TECTION_SENSOR_APP\x10\n\x12\r\n\tALERT_APP\x10\x0b\x12\x18\n\x14KEY_VERIFICATION_APP\x10\x0c\x12\x14\n\x10REMOTE_SHELL_APP\x10\r\x12\r\n\tREPLY_APP\x10 \x12\x11\n\rIP_TUNNEL_APP\x10!\x12\x12\n\x0ePAXCOUNTER_APP\x10\"\x12\x1e\n\x1aSTORE_FORWARD_PLUSPLUS_APP\x10#\x12\x13\n\x0fNODE_STATUS_APP\x10$\x12\x0e\n\nSERIAL_APP\x10@\x12\x15\n\x11STORE_FORWARD_APP\x10\x41\x12\x12\n\x0eRANGE_TEST_APP\x10\x42\x12\x11\n\rTELEMETRY_APP\x10\x43\x12\x0b\n\x07ZPS_APP\x10\x44\x12\x11\n\rSIMULATOR_APP\x10\x45\x12\x12\n\x0eTRACEROUTE_APP\x10\x46\x12\x14\n\x10NEIGHBORINFO_APP\x10G\x12\x0f\n\x0b\x41TAK_PLUGIN\x10H\x12\x12\n\x0eMAP_REPORT_APP\x10I\x12\x13\n\x0fPOWERSTRESS_APP\x10J\x12\x12\n\x0eLORAWAN_BRIDGE\x10K\x12\x18\n\x14RETICULUM_TUNNEL_APP\x10L\x12\x0f\n\x0b\x43\x41YENNE_APP\x10M\x12\x12\n\x0e\x41TAK_PLUGIN_V2\x10N\x12\x12\n\x0eGROUPALARM_APP\x10p\x12\x10\n\x0bPRIVATE_APP\x10\x80\x02\x12\x13\n\x0e\x41TAK_FORWARDER\x10\x81\x02\x12\x08\n\x03MAX\x10\xff\x03\x42^\n\x14org.meshtastic.protoB\x08PortnumsZ\"github.com/meshtastic/go/generated\xaa\x02\x14Meshtastic.Protobufs\xba\x02\x00\x62\x06proto3')
+DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\"meshtastic/protobuf/portnums.proto\x12\x13meshtastic.protobuf*\xa4\x06\n\x07PortNum\x12\x0f\n\x0bUNKNOWN_APP\x10\x00\x12\x14\n\x10TEXT_MESSAGE_APP\x10\x01\x12\x17\n\x13REMOTE_HARDWARE_APP\x10\x02\x12\x10\n\x0cPOSITION_APP\x10\x03\x12\x10\n\x0cNODEINFO_APP\x10\x04\x12\x0f\n\x0bROUTING_APP\x10\x05\x12\r\n\tADMIN_APP\x10\x06\x12\x1f\n\x1bTEXT_MESSAGE_COMPRESSED_APP\x10\x07\x12\x10\n\x0cWAYPOINT_APP\x10\x08\x12\r\n\tAUDIO_APP\x10\t\x12\x18\n\x14\x44\x45TECTION_SENSOR_APP\x10\n\x12\r\n\tALERT_APP\x10\x0b\x12\x18\n\x14KEY_VERIFICATION_APP\x10\x0c\x12\x14\n\x10REMOTE_SHELL_APP\x10\r\x12\r\n\tREPLY_APP\x10 \x12\x11\n\rIP_TUNNEL_APP\x10!\x12\x12\n\x0ePAXCOUNTER_APP\x10\"\x12\x1e\n\x1aSTORE_FORWARD_PLUSPLUS_APP\x10#\x12\x13\n\x0fNODE_STATUS_APP\x10$\x12\x13\n\x0fMESH_BEACON_APP\x10%\x12\x0e\n\nSERIAL_APP\x10@\x12\x15\n\x11STORE_FORWARD_APP\x10\x41\x12\x12\n\x0eRANGE_TEST_APP\x10\x42\x12\x11\n\rTELEMETRY_APP\x10\x43\x12\x0b\n\x07ZPS_APP\x10\x44\x12\x11\n\rSIMULATOR_APP\x10\x45\x12\x12\n\x0eTRACEROUTE_APP\x10\x46\x12\x14\n\x10NEIGHBORINFO_APP\x10G\x12\x0f\n\x0b\x41TAK_PLUGIN\x10H\x12\x12\n\x0eMAP_REPORT_APP\x10I\x12\x13\n\x0fPOWERSTRESS_APP\x10J\x12\x12\n\x0eLORAWAN_BRIDGE\x10K\x12\x18\n\x14RETICULUM_TUNNEL_APP\x10L\x12\x0f\n\x0b\x43\x41YENNE_APP\x10M\x12\x12\n\x0e\x41TAK_PLUGIN_V2\x10N\x12\x10\n\x0cLORA_OTA_APP\x10O\x12\x12\n\x0eGROUPALARM_APP\x10p\x12\x10\n\x0bPRIVATE_APP\x10\x80\x02\x12\x13\n\x0e\x41TAK_FORWARDER\x10\x81\x02\x12\x08\n\x03MAX\x10\xff\x03\x42^\n\x14org.meshtastic.protoB\x08PortnumsZ\"github.com/meshtastic/go/generated\xaa\x02\x14Meshtastic.Protobufs\xba\x02\x00\x62\x06proto3')
 
 _globals = globals()
 _builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals)
@@ -22,5 +22,5 @@ if _descriptor._USE_C_DESCRIPTORS == False:
   DESCRIPTOR._options = None
   DESCRIPTOR._serialized_options = b'\n\024org.meshtastic.protoB\010PortnumsZ\"github.com/meshtastic/go/generated\252\002\024Meshtastic.Protobufs\272\002\000'
   _globals['_PORTNUM']._serialized_start=60
-  _globals['_PORTNUM']._serialized_end=825
+  _globals['_PORTNUM']._serialized_end=864
 # @@protoc_insertion_point(module_scope)

meshtastic/protobuf/portnums_pb2.pyi

@@ -135,6 +135,13 @@ class _PortNumEnumTypeWrapper(google.protobuf.internal.enum_type_wrapper._EnumTy
     This module allows setting an extra string of status for a node.
     Broadcasts on change and on a timer, possibly once a day.
     """
+    MESH_BEACON_APP: _PortNum.ValueType  # 37
+    """
+    Beacon module broadcast packets.
+    ENCODING: protobuf
+    Periodically broadcast by nodes in beacon mode; received by nodes with MeshBeaconConfig.FLAG_LISTEN_ENABLED.
+    Carries a text message plus optional channel/preset offers for client apps.
+    """
     SERIAL_APP: _PortNum.ValueType  # 64
     """
     Provides a hardware serial interface to send and receive from the Meshtastic network.
@@ -223,6 +230,11 @@ class _PortNumEnumTypeWrapper(google.protobuf.internal.enum_type_wrapper._EnumTy
     Portnum for payloads from the official Meshtastic ATAK plugin using
     TAKPacketV2 with zstd dictionary compression.
     """
+    LORA_OTA_APP: _PortNum.ValueType  # 79
+    """signed firmware updates over lora.
+
+    ENCODING: binary (ota-common transport frames)
+    """
     GROUPALARM_APP: _PortNum.ValueType  # 112
     """
     GroupAlarm integration
@@ -374,6 +386,13 @@ ENCODING: protobuf
 This module allows setting an extra string of status for a node.
 Broadcasts on change and on a timer, possibly once a day.
 """
+MESH_BEACON_APP: PortNum.ValueType  # 37
+"""
+Beacon module broadcast packets.
+ENCODING: protobuf
+Periodically broadcast by nodes in beacon mode; received by nodes with MeshBeaconConfig.FLAG_LISTEN_ENABLED.
+Carries a text message plus optional channel/preset offers for client apps.
+"""
 SERIAL_APP: PortNum.ValueType  # 64
 """
 Provides a hardware serial interface to send and receive from the Meshtastic network.
@@ -462,6 +481,11 @@ ATAK Plugin V2
 Portnum for payloads from the official Meshtastic ATAK plugin using
 TAKPacketV2 with zstd dictionary compression.
 """
+LORA_OTA_APP: PortNum.ValueType  # 79
+"""signed firmware updates over lora.
+
+ENCODING: binary (ota-common transport frames)
+"""
 GROUPALARM_APP: PortNum.ValueType  # 112
 """
 GroupAlarm integration

meshtastic/protobuf/telemetry_pb2.pyi

@@ -241,6 +241,22 @@ class _TelemetrySensorTypeEnumTypeWrapper(google.protobuf.internal.enum_type_wra
     """
     ICM-42607-P 6‑Axis IMU
     """
+    SPA06: _TelemetrySensorType.ValueType  # 54
+    """
+    SPA06 pressure and temperature
+    """
+    HM330X: _TelemetrySensorType.ValueType  # 55
+    """
+    HM330X PM SENSOR
+    """
+    SEN6X: _TelemetrySensorType.ValueType  # 56
+    """
+    Sensirion SEN6X PM/RHT/VOC/NOx/CO2/HCHO sensor family (SEN62, SEN63C, SEN65, SEN66, SEN68, SEN69C)
+    """
+    AS3935: _TelemetrySensorType.ValueType  # 57
+    """
+    AS3935 Franklin lightning sensor
+    """
 
 class TelemetrySensorType(_TelemetrySensorType, metaclass=_TelemetrySensorTypeEnumTypeWrapper):
     """
@@ -463,6 +479,22 @@ ICM42607P: TelemetrySensorType.ValueType  # 53
 """
 ICM-42607-P 6‑Axis IMU
 """
+SPA06: TelemetrySensorType.ValueType  # 54
+"""
+SPA06 pressure and temperature
+"""
+HM330X: TelemetrySensorType.ValueType  # 55
+"""
+HM330X PM SENSOR
+"""
+SEN6X: TelemetrySensorType.ValueType  # 56
+"""
+Sensirion SEN6X PM/RHT/VOC/NOx/CO2/HCHO sensor family (SEN62, SEN63C, SEN65, SEN66, SEN68, SEN69C)
+"""
+AS3935: TelemetrySensorType.ValueType  # 57
+"""
+AS3935 Franklin lightning sensor
+"""
 global___TelemetrySensorType = TelemetrySensorType
 
 @typing.final
@@ -553,6 +585,24 @@ class EnvironmentMetrics(google.protobuf.message.Message):
     SOIL_MOISTURE_FIELD_NUMBER: builtins.int
     SOIL_TEMPERATURE_FIELD_NUMBER: builtins.int
     ONE_WIRE_TEMPERATURE_FIELD_NUMBER: builtins.int
+    ADC_VOLTAGE_CH0_FIELD_NUMBER: builtins.int
+    ADC_VOLTAGE_CH1_FIELD_NUMBER: builtins.int
+    ADC_VOLTAGE_CH2_FIELD_NUMBER: builtins.int
+    ADC_VOLTAGE_CH3_FIELD_NUMBER: builtins.int
+    ADC_VOLTAGE_CH4_FIELD_NUMBER: builtins.int
+    ADC_VOLTAGE_CH5_FIELD_NUMBER: builtins.int
+    ADC_VOLTAGE_CH6_FIELD_NUMBER: builtins.int
+    ADC_VOLTAGE_CH7_FIELD_NUMBER: builtins.int
+    ONE_WIRE_TEMPERATURE_CH0_FIELD_NUMBER: builtins.int
+    ONE_WIRE_TEMPERATURE_CH1_FIELD_NUMBER: builtins.int
+    ONE_WIRE_TEMPERATURE_CH2_FIELD_NUMBER: builtins.int
+    ONE_WIRE_TEMPERATURE_CH3_FIELD_NUMBER: builtins.int
+    ONE_WIRE_TEMPERATURE_CH4_FIELD_NUMBER: builtins.int
+    ONE_WIRE_TEMPERATURE_CH5_FIELD_NUMBER: builtins.int
+    ONE_WIRE_TEMPERATURE_CH6_FIELD_NUMBER: builtins.int
+    ONE_WIRE_TEMPERATURE_CH7_FIELD_NUMBER: builtins.int
+    LIGHTNING_STRIKE_COUNT_1H_FIELD_NUMBER: builtins.int
+    LIGHTNING_DISTANCE_KM_FIELD_NUMBER: builtins.int
     temperature: builtins.float
     """
     Temperature measured
@@ -643,10 +693,82 @@ class EnvironmentMetrics(google.protobuf.message.Message):
     """
     Soil temperature measured (*C)
     """
+    adc_voltage_ch0: builtins.float
+    """
+    Multi-channel ADC Voltage Channel 0 (V)
+    """
+    adc_voltage_ch1: builtins.float
+    """
+    Multi-channel ADC Voltage Channel 1 (V)
+    """
+    adc_voltage_ch2: builtins.float
+    """
+    Multi-channel ADC Voltage Channel 2 (V)
+    """
+    adc_voltage_ch3: builtins.float
+    """
+    Multi-channel ADC Voltage Channel 3 (V)
+    """
+    adc_voltage_ch4: builtins.float
+    """
+    Multi-channel ADC Voltage Channel 4 (V)
+    """
+    adc_voltage_ch5: builtins.float
+    """
+    Multi-channel ADC Voltage Channel 5 (V)
+    """
+    adc_voltage_ch6: builtins.float
+    """
+    Multi-channel ADC Voltage Channel 6 (V)
+    """
+    adc_voltage_ch7: builtins.float
+    """
+    Multi-channel ADC Voltage Channel 7 (V)
+    """
+    one_wire_temperature_ch0: builtins.float
+    """
+    Multi-channel One-Wire Temperature Channel 0 (*C)
+    """
+    one_wire_temperature_ch1: builtins.float
+    """
+    Multi-channel One-Wire Temperature Channel 1 (*C)
+    """
+    one_wire_temperature_ch2: builtins.float
+    """
+    Multi-channel One-Wire Temperature Channel 2 (*C)
+    """
+    one_wire_temperature_ch3: builtins.float
+    """
+    Multi-channel One-Wire Temperature Channel 3 (*C)
+    """
+    one_wire_temperature_ch4: builtins.float
+    """
+    Multi-channel One-Wire Temperature Channel 4 (*C)
+    """
+    one_wire_temperature_ch5: builtins.float
+    """
+    Multi-channel One-Wire Temperature Channel 5 (*C)
+    """
+    one_wire_temperature_ch6: builtins.float
+    """
+    Multi-channel One-Wire Temperature Channel 6 (*C)
+    """
+    one_wire_temperature_ch7: builtins.float
+    """
+    Multi-channel One-Wire Temperature Channel 7 (*C)
+    """
+    lightning_strike_count_1h: builtins.int
+    """
+    Lightning strikes detected in the last hour
+    """
+    lightning_distance_km: builtins.float
+    """
+    Estimated distance to the leading edge of the storm, in km
+    """
     @property
     def one_wire_temperature(self) -> google.protobuf.internal.containers.RepeatedScalarFieldContainer[builtins.float]:
         """
-        One-wire temperature (*C)
+        Never implemented, but Voltage may be mis-interpreted by old clients as temperature
         """
 
     def __init__(
@@ -675,9 +797,43 @@ class EnvironmentMetrics(google.protobuf.message.Message):
         soil_moisture: builtins.int | None = ...,
         soil_temperature: builtins.float | None = ...,
         one_wire_temperature: collections.abc.Iterable[builtins.float] | None = ...,
+        adc_voltage_ch0: builtins.float | None = ...,
+        adc_voltage_ch1: builtins.float | None = ...,
+        adc_voltage_ch2: builtins.float | None = ...,
+        adc_voltage_ch3: builtins.float | None = ...,
+        adc_voltage_ch4: builtins.float | None = ...,
+        adc_voltage_ch5: builtins.float | None = ...,
+        adc_voltage_ch6: builtins.float | None = ...,
+        adc_voltage_ch7: builtins.float | None = ...,
+        one_wire_temperature_ch0: builtins.float | None = ...,
+        one_wire_temperature_ch1: builtins.float | None = ...,
+        one_wire_temperature_ch2: builtins.float | None = ...,
+        one_wire_temperature_ch3: builtins.float | None = ...,
+        one_wire_temperature_ch4: builtins.float | None = ...,
+        one_wire_temperature_ch5: builtins.float | None = ...,
+        one_wire_temperature_ch6: builtins.float | None = ...,
+        one_wire_temperature_ch7: builtins.float | None = ...,
+        lightning_strike_count_1h: builtins.int | None = ...,
+        lightning_distance_km: builtins.float | None = ...,
     ) -> None: ...
-    def HasField(self, field_name: typing.Literal["_barometric_pressure", b"_barometric_pressure", "_current", b"_current", "_distance", b"_distance", "_gas_resistance", b"_gas_resistance", "_iaq", b"_iaq", "_ir_lux", b"_ir_lux", "_lux", b"_lux", "_radiation", b"_radiation", "_rainfall_1h", b"_rainfall_1h", "_rainfall_24h", b"_rainfall_24h", "_relative_humidity", b"_relative_humidity", "_soil_moisture", b"_soil_moisture", "_soil_temperature", b"_soil_temperature", "_temperature", b"_temperature", "_uv_lux", b"_uv_lux", "_voltage", b"_voltage", "_weight", b"_weight", "_white_lux", b"_white_lux", "_wind_direction", b"_wind_direction", "_wind_gust", b"_wind_gust", "_wind_lull", b"_wind_lull", "_wind_speed", b"_wind_speed", "barometric_pressure", b"barometric_pressure", "current", b"current", "distance", b"distance", "gas_resistance", b"gas_resistance", "iaq", b"iaq", "ir_lux", b"ir_lux", "lux", b"lux", "radiation", b"radiation", "rainfall_1h", b"rainfall_1h", "rainfall_24h", b"rainfall_24h", "relative_humidity", b"relative_humidity", "soil_moisture", b"soil_moisture", "soil_temperature", b"soil_temperature", "temperature", b"temperature", "uv_lux", b"uv_lux", "voltage", b"voltage", "weight", b"weight", "white_lux", b"white_lux", "wind_direction", b"wind_direction", "wind_gust", b"wind_gust", "wind_lull", b"wind_lull", "wind_speed", b"wind_speed"]) -> builtins.bool: ...
-    def ClearField(self, field_name: typing.Literal["_barometric_pressure", b"_barometric_pressure", "_current", b"_current", "_distance", b"_distance", "_gas_resistance", b"_gas_resistance", "_iaq", b"_iaq", "_ir_lux", b"_ir_lux", "_lux", b"_lux", "_radiation", b"_radiation", "_rainfall_1h", b"_rainfall_1h", "_rainfall_24h", b"_rainfall_24h", "_relative_humidity", b"_relative_humidity", "_soil_moisture", b"_soil_moisture", "_soil_temperature", b"_soil_temperature", "_temperature", b"_temperature", "_uv_lux", b"_uv_lux", "_voltage", b"_voltage", "_weight", b"_weight", "_white_lux", b"_white_lux", "_wind_direction", b"_wind_direction", "_wind_gust", b"_wind_gust", "_wind_lull", b"_wind_lull", "_wind_speed", b"_wind_speed", "barometric_pressure", b"barometric_pressure", "current", b"current", "distance", b"distance", "gas_resistance", b"gas_resistance", "iaq", b"iaq", "ir_lux", b"ir_lux", "lux", b"lux", "one_wire_temperature", b"one_wire_temperature", "radiation", b"radiation", "rainfall_1h", b"rainfall_1h", "rainfall_24h", b"rainfall_24h", "relative_humidity", b"relative_humidity", "soil_moisture", b"soil_moisture", "soil_temperature", b"soil_temperature", "temperature", b"temperature", "uv_lux", b"uv_lux", "voltage", b"voltage", "weight", b"weight", "white_lux", b"white_lux", "wind_direction", b"wind_direction", "wind_gust", b"wind_gust", "wind_lull", b"wind_lull", "wind_speed", b"wind_speed"]) -> None: ...
+    def HasField(self, field_name: typing.Literal["_adc_voltage_ch0", b"_adc_voltage_ch0", "_adc_voltage_ch1", b"_adc_voltage_ch1", "_adc_voltage_ch2", b"_adc_voltage_ch2", "_adc_voltage_ch3", b"_adc_voltage_ch3", "_adc_voltage_ch4", b"_adc_voltage_ch4", "_adc_voltage_ch5", b"_adc_voltage_ch5", "_adc_voltage_ch6", b"_adc_voltage_ch6", "_adc_voltage_ch7", b"_adc_voltage_ch7", "_barometric_pressure", b"_barometric_pressure", "_current", b"_current", "_distance", b"_distance", "_gas_resistance", b"_gas_resistance", "_iaq", b"_iaq", "_ir_lux", b"_ir_lux", "_lightning_distance_km", b"_lightning_distance_km", "_lightning_strike_count_1h", b"_lightning_strike_count_1h", "_lux", b"_lux", "_one_wire_temperature_ch0", b"_one_wire_temperature_ch0", "_one_wire_temperature_ch1", b"_one_wire_temperature_ch1", "_one_wire_temperature_ch2", b"_one_wire_temperature_ch2", "_one_wire_temperature_ch3", b"_one_wire_temperature_ch3", "_one_wire_temperature_ch4", b"_one_wire_temperature_ch4", "_one_wire_temperature_ch5", b"_one_wire_temperature_ch5", "_one_wire_temperature_ch6", b"_one_wire_temperature_ch6", "_one_wire_temperature_ch7", b"_one_wire_temperature_ch7", "_radiation", b"_radiation", "_rainfall_1h", b"_rainfall_1h", "_rainfall_24h", b"_rainfall_24h", "_relative_humidity", b"_relative_humidity", "_soil_moisture", b"_soil_moisture", "_soil_temperature", b"_soil_temperature", "_temperature", b"_temperature", "_uv_lux", b"_uv_lux", "_voltage", b"_voltage", "_weight", b"_weight", "_white_lux", b"_white_lux", "_wind_direction", b"_wind_direction", "_wind_gust", b"_wind_gust", "_wind_lull", b"_wind_lull", "_wind_speed", b"_wind_speed", "adc_voltage_ch0", b"adc_voltage_ch0", "adc_voltage_ch1", b"adc_voltage_ch1", "adc_voltage_ch2", b"adc_voltage_ch2", "adc_voltage_ch3", b"adc_voltage_ch3", "adc_voltage_ch4", b"adc_voltage_ch4", "adc_voltage_ch5", b"adc_voltage_ch5", "adc_voltage_ch6", b"adc_voltage_ch6", "adc_voltage_ch7", b"adc_voltage_ch7", "barometric_pressure", b"barometric_pressure", "current", b"current", "distance", b"distance", "gas_resistance", b"gas_resistance", "iaq", b"iaq", "ir_lux", b"ir_lux", "lightning_distance_km", b"lightning_distance_km", "lightning_strike_count_1h", b"lightning_strike_count_1h", "lux", b"lux", "one_wire_temperature_ch0", b"one_wire_temperature_ch0", "one_wire_temperature_ch1", b"one_wire_temperature_ch1", "one_wire_temperature_ch2", b"one_wire_temperature_ch2", "one_wire_temperature_ch3", b"one_wire_temperature_ch3", "one_wire_temperature_ch4", b"one_wire_temperature_ch4", "one_wire_temperature_ch5", b"one_wire_temperature_ch5", "one_wire_temperature_ch6", b"one_wire_temperature_ch6", "one_wire_temperature_ch7", b"one_wire_temperature_ch7", "radiation", b"radiation", "rainfall_1h", b"rainfall_1h", "rainfall_24h", b"rainfall_24h", "relative_humidity", b"relative_humidity", "soil_moisture", b"soil_moisture", "soil_temperature", b"soil_temperature", "temperature", b"temperature", "uv_lux", b"uv_lux", "voltage", b"voltage", "weight", b"weight", "white_lux", b"white_lux", "wind_direction", b"wind_direction", "wind_gust", b"wind_gust", "wind_lull", b"wind_lull", "wind_speed", b"wind_speed"]) -> builtins.bool: ...
+    def ClearField(self, field_name: typing.Literal["_adc_voltage_ch0", b"_adc_voltage_ch0", "_adc_voltage_ch1", b"_adc_voltage_ch1", "_adc_voltage_ch2", b"_adc_voltage_ch2", "_adc_voltage_ch3", b"_adc_voltage_ch3", "_adc_voltage_ch4", b"_adc_voltage_ch4", "_adc_voltage_ch5", b"_adc_voltage_ch5", "_adc_voltage_ch6", b"_adc_voltage_ch6", "_adc_voltage_ch7", b"_adc_voltage_ch7", "_barometric_pressure", b"_barometric_pressure", "_current", b"_current", "_distance", b"_distance", "_gas_resistance", b"_gas_resistance", "_iaq", b"_iaq", "_ir_lux", b"_ir_lux", "_lightning_distance_km", b"_lightning_distance_km", "_lightning_strike_count_1h", b"_lightning_strike_count_1h", "_lux", b"_lux", "_one_wire_temperature_ch0", b"_one_wire_temperature_ch0", "_one_wire_temperature_ch1", b"_one_wire_temperature_ch1", "_one_wire_temperature_ch2", b"_one_wire_temperature_ch2", "_one_wire_temperature_ch3", b"_one_wire_temperature_ch3", "_one_wire_temperature_ch4", b"_one_wire_temperature_ch4", "_one_wire_temperature_ch5", b"_one_wire_temperature_ch5", "_one_wire_temperature_ch6", b"_one_wire_temperature_ch6", "_one_wire_temperature_ch7", b"_one_wire_temperature_ch7", "_radiation", b"_radiation", "_rainfall_1h", b"_rainfall_1h", "_rainfall_24h", b"_rainfall_24h", "_relative_humidity", b"_relative_humidity", "_soil_moisture", b"_soil_moisture", "_soil_temperature", b"_soil_temperature", "_temperature", b"_temperature", "_uv_lux", b"_uv_lux", "_voltage", b"_voltage", "_weight", b"_weight", "_white_lux", b"_white_lux", "_wind_direction", b"_wind_direction", "_wind_gust", b"_wind_gust", "_wind_lull", b"_wind_lull", "_wind_speed", b"_wind_speed", "adc_voltage_ch0", b"adc_voltage_ch0", "adc_voltage_ch1", b"adc_voltage_ch1", "adc_voltage_ch2", b"adc_voltage_ch2", "adc_voltage_ch3", b"adc_voltage_ch3", "adc_voltage_ch4", b"adc_voltage_ch4", "adc_voltage_ch5", b"adc_voltage_ch5", "adc_voltage_ch6", b"adc_voltage_ch6", "adc_voltage_ch7", b"adc_voltage_ch7", "barometric_pressure", b"barometric_pressure", "current", b"current", "distance", b"distance", "gas_resistance", b"gas_resistance", "iaq", b"iaq", "ir_lux", b"ir_lux", "lightning_distance_km", b"lightning_distance_km", "lightning_strike_count_1h", b"lightning_strike_count_1h", "lux", b"lux", "one_wire_temperature", b"one_wire_temperature", "one_wire_temperature_ch0", b"one_wire_temperature_ch0", "one_wire_temperature_ch1", b"one_wire_temperature_ch1", "one_wire_temperature_ch2", b"one_wire_temperature_ch2", "one_wire_temperature_ch3", b"one_wire_temperature_ch3", "one_wire_temperature_ch4", b"one_wire_temperature_ch4", "one_wire_temperature_ch5", b"one_wire_temperature_ch5", "one_wire_temperature_ch6", b"one_wire_temperature_ch6", "one_wire_temperature_ch7", b"one_wire_temperature_ch7", "radiation", b"radiation", "rainfall_1h", b"rainfall_1h", "rainfall_24h", b"rainfall_24h", "relative_humidity", b"relative_humidity", "soil_moisture", b"soil_moisture", "soil_temperature", b"soil_temperature", "temperature", b"temperature", "uv_lux", b"uv_lux", "voltage", b"voltage", "weight", b"weight", "white_lux", b"white_lux", "wind_direction", b"wind_direction", "wind_gust", b"wind_gust", "wind_lull", b"wind_lull", "wind_speed", b"wind_speed"]) -> None: ...
+    @typing.overload
+    def WhichOneof(self, oneof_group: typing.Literal["_adc_voltage_ch0", b"_adc_voltage_ch0"]) -> typing.Literal["adc_voltage_ch0"] | None: ...
+    @typing.overload
+    def WhichOneof(self, oneof_group: typing.Literal["_adc_voltage_ch1", b"_adc_voltage_ch1"]) -> typing.Literal["adc_voltage_ch1"] | None: ...
+    @typing.overload
+    def WhichOneof(self, oneof_group: typing.Literal["_adc_voltage_ch2", b"_adc_voltage_ch2"]) -> typing.Literal["adc_voltage_ch2"] | None: ...
+    @typing.overload
+    def WhichOneof(self, oneof_group: typing.Literal["_adc_voltage_ch3", b"_adc_voltage_ch3"]) -> typing.Literal["adc_voltage_ch3"] | None: ...
+    @typing.overload
+    def WhichOneof(self, oneof_group: typing.Literal["_adc_voltage_ch4", b"_adc_voltage_ch4"]) -> typing.Literal["adc_voltage_ch4"] | None: ...
+    @typing.overload
+    def WhichOneof(self, oneof_group: typing.Literal["_adc_voltage_ch5", b"_adc_voltage_ch5"]) -> typing.Literal["adc_voltage_ch5"] | None: ...
+    @typing.overload
+    def WhichOneof(self, oneof_group: typing.Literal["_adc_voltage_ch6", b"_adc_voltage_ch6"]) -> typing.Literal["adc_voltage_ch6"] | None: ...
+    @typing.overload
+    def WhichOneof(self, oneof_group: typing.Literal["_adc_voltage_ch7", b"_adc_voltage_ch7"]) -> typing.Literal["adc_voltage_ch7"] | None: ...
     @typing.overload
     def WhichOneof(self, oneof_group: typing.Literal["_barometric_pressure", b"_barometric_pressure"]) -> typing.Literal["barometric_pressure"] | None: ...
     @typing.overload
@@ -691,8 +847,28 @@ class EnvironmentMetrics(google.protobuf.message.Message):
     @typing.overload
     def WhichOneof(self, oneof_group: typing.Literal["_ir_lux", b"_ir_lux"]) -> typing.Literal["ir_lux"] | None: ...
     @typing.overload
+    def WhichOneof(self, oneof_group: typing.Literal["_lightning_distance_km", b"_lightning_distance_km"]) -> typing.Literal["lightning_distance_km"] | None: ...
+    @typing.overload
+    def WhichOneof(self, oneof_group: typing.Literal["_lightning_strike_count_1h", b"_lightning_strike_count_1h"]) -> typing.Literal["lightning_strike_count_1h"] | None: ...
+    @typing.overload
     def WhichOneof(self, oneof_group: typing.Literal["_lux", b"_lux"]) -> typing.Literal["lux"] | None: ...
     @typing.overload
+    def WhichOneof(self, oneof_group: typing.Literal["_one_wire_temperature_ch0", b"_one_wire_temperature_ch0"]) -> typing.Literal["one_wire_temperature_ch0"] | None: ...
+    @typing.overload
+    def WhichOneof(self, oneof_group: typing.Literal["_one_wire_temperature_ch1", b"_one_wire_temperature_ch1"]) -> typing.Literal["one_wire_temperature_ch1"] | None: ...
+    @typing.overload
+    def WhichOneof(self, oneof_group: typing.Literal["_one_wire_temperature_ch2", b"_one_wire_temperature_ch2"]) -> typing.Literal["one_wire_temperature_ch2"] | None: ...
+    @typing.overload
+    def WhichOneof(self, oneof_group: typing.Literal["_one_wire_temperature_ch3", b"_one_wire_temperature_ch3"]) -> typing.Literal["one_wire_temperature_ch3"] | None: ...
+    @typing.overload
+    def WhichOneof(self, oneof_group: typing.Literal["_one_wire_temperature_ch4", b"_one_wire_temperature_ch4"]) -> typing.Literal["one_wire_temperature_ch4"] | None: ...
+    @typing.overload
+    def WhichOneof(self, oneof_group: typing.Literal["_one_wire_temperature_ch5", b"_one_wire_temperature_ch5"]) -> typing.Literal["one_wire_temperature_ch5"] | None: ...
+    @typing.overload
+    def WhichOneof(self, oneof_group: typing.Literal["_one_wire_temperature_ch6", b"_one_wire_temperature_ch6"]) -> typing.Literal["one_wire_temperature_ch6"] | None: ...
+    @typing.overload
+    def WhichOneof(self, oneof_group: typing.Literal["_one_wire_temperature_ch7", b"_one_wire_temperature_ch7"]) -> typing.Literal["one_wire_temperature_ch7"] | None: ...
+    @typing.overload
     def WhichOneof(self, oneof_group: typing.Literal["_radiation", b"_radiation"]) -> typing.Literal["radiation"] | None: ...
     @typing.overload
     def WhichOneof(self, oneof_group: typing.Literal["_rainfall_1h", b"_rainfall_1h"]) -> typing.Literal["rainfall_1h"] | None: ...
@@ -775,43 +951,43 @@ class PowerMetrics(google.protobuf.message.Message):
     """
     ch4_voltage: builtins.float
     """
-    Voltage (Ch4)
+    Voltage (Ch4) - TODO Remove
     """
     ch4_current: builtins.float
     """
-    Current (Ch4)
+    Current (Ch4) - TODO Remove
     """
     ch5_voltage: builtins.float
     """
-    Voltage (Ch5)
+    Voltage (Ch5) - TODO Remove
     """
     ch5_current: builtins.float
     """
-    Current (Ch5)
+    Current (Ch5) - TODO Remove
     """
     ch6_voltage: builtins.float
     """
-    Voltage (Ch6)
+    Voltage (Ch6) - TODO Remove
     """
     ch6_current: builtins.float
     """
-    Current (Ch6)
+    Current (Ch6) - TODO Remove
     """
     ch7_voltage: builtins.float
     """
-    Voltage (Ch7)
+    Voltage (Ch7) - TODO Remove
     """
     ch7_current: builtins.float
     """
-    Current (Ch7)
+    Current (Ch7) - TODO Remove
     """
     ch8_voltage: builtins.float
     """
-    Voltage (Ch8)
+    Voltage (Ch8) - TODO Remove
     """
     ch8_current: builtins.float
     """
-    Current (Ch8)
+    Current (Ch8) - TODO Remove
     """
     def __init__(
         self,
@@ -903,6 +1079,7 @@ class AirQualityMetrics(google.protobuf.message.Message):
     PM_VOC_IDX_FIELD_NUMBER: builtins.int
     PM_NOX_IDX_FIELD_NUMBER: builtins.int
     PARTICLES_TPS_FIELD_NUMBER: builtins.int
+    PM_STATUS_FLAGS_FIELD_NUMBER: builtins.int
     pm10_standard: builtins.int
     """
     Concentration Units Standard PM1.0 in ug/m3
@@ -1003,6 +1180,13 @@ class AirQualityMetrics(google.protobuf.message.Message):
     """
     Typical Particle Size in um
     """
+    pm_status_flags: builtins.int
+    """
+    Raw PM sensor device status/error register bitmask, as defined by the sensor's own datasheet
+    (currently populated by the SEN6X family: bit 4 fan error, bit 6 RH&T error, bit 7 gas/VOC-NOx
+    error, bit 9 CO2 error (SEN66), bit 10 HCHO error, bit 11 PM error, bit 12 CO2 error (SEN63C/SEN69C),
+    bit 21 fan speed warning)
+    """
     def __init__(
         self,
         *,
@@ -1031,9 +1215,10 @@ class AirQualityMetrics(google.protobuf.message.Message):
         pm_voc_idx: builtins.float | None = ...,
         pm_nox_idx: builtins.float | None = ...,
         particles_tps: builtins.float | None = ...,
+        pm_status_flags: builtins.int | None = ...,
     ) -> None: ...
-    def HasField(self, field_name: typing.Literal["_co2", b"_co2", "_co2_humidity", b"_co2_humidity", "_co2_temperature", b"_co2_temperature", "_form_formaldehyde", b"_form_formaldehyde", "_form_humidity", b"_form_humidity", "_form_temperature", b"_form_temperature", "_particles_03um", b"_particles_03um", "_particles_05um", b"_particles_05um", "_particles_100um", b"_particles_100um", "_particles_10um", b"_particles_10um", "_particles_25um", b"_particles_25um", "_particles_40um", b"_particles_40um", "_particles_50um", b"_particles_50um", "_particles_tps", b"_particles_tps", "_pm100_environmental", b"_pm100_environmental", "_pm100_standard", b"_pm100_standard", "_pm10_environmental", b"_pm10_environmental", "_pm10_standard", b"_pm10_standard", "_pm25_environmental", b"_pm25_environmental", "_pm25_standard", b"_pm25_standard", "_pm40_standard", b"_pm40_standard", "_pm_humidity", b"_pm_humidity", "_pm_nox_idx", b"_pm_nox_idx", "_pm_temperature", b"_pm_temperature", "_pm_voc_idx", b"_pm_voc_idx", "co2", b"co2", "co2_humidity", b"co2_humidity", "co2_temperature", b"co2_temperature", "form_formaldehyde", b"form_formaldehyde", "form_humidity", b"form_humidity", "form_temperature", b"form_temperature", "particles_03um", b"particles_03um", "particles_05um", b"particles_05um", "particles_100um", b"particles_100um", "particles_10um", b"particles_10um", "particles_25um", b"particles_25um", "particles_40um", b"particles_40um", "particles_50um", b"particles_50um", "particles_tps", b"particles_tps", "pm100_environmental", b"pm100_environmental", "pm100_standard", b"pm100_standard", "pm10_environmental", b"pm10_environmental", "pm10_standard", b"pm10_standard", "pm25_environmental", b"pm25_environmental", "pm25_standard", b"pm25_standard", "pm40_standard", b"pm40_standard", "pm_humidity", b"pm_humidity", "pm_nox_idx", b"pm_nox_idx", "pm_temperature", b"pm_temperature", "pm_voc_idx", b"pm_voc_idx"]) -> builtins.bool: ...
-    def ClearField(self, field_name: typing.Literal["_co2", b"_co2", "_co2_humidity", b"_co2_humidity", "_co2_temperature", b"_co2_temperature", "_form_formaldehyde", b"_form_formaldehyde", "_form_humidity", b"_form_humidity", "_form_temperature", b"_form_temperature", "_particles_03um", b"_particles_03um", "_particles_05um", b"_particles_05um", "_particles_100um", b"_particles_100um", "_particles_10um", b"_particles_10um", "_particles_25um", b"_particles_25um", "_particles_40um", b"_particles_40um", "_particles_50um", b"_particles_50um", "_particles_tps", b"_particles_tps", "_pm100_environmental", b"_pm100_environmental", "_pm100_standard", b"_pm100_standard", "_pm10_environmental", b"_pm10_environmental", "_pm10_standard", b"_pm10_standard", "_pm25_environmental", b"_pm25_environmental", "_pm25_standard", b"_pm25_standard", "_pm40_standard", b"_pm40_standard", "_pm_humidity", b"_pm_humidity", "_pm_nox_idx", b"_pm_nox_idx", "_pm_temperature", b"_pm_temperature", "_pm_voc_idx", b"_pm_voc_idx", "co2", b"co2", "co2_humidity", b"co2_humidity", "co2_temperature", b"co2_temperature", "form_formaldehyde", b"form_formaldehyde", "form_humidity", b"form_humidity", "form_temperature", b"form_temperature", "particles_03um", b"particles_03um", "particles_05um", b"particles_05um", "particles_100um", b"particles_100um", "particles_10um", b"particles_10um", "particles_25um", b"particles_25um", "particles_40um", b"particles_40um", "particles_50um", b"particles_50um", "particles_tps", b"particles_tps", "pm100_environmental", b"pm100_environmental", "pm100_standard", b"pm100_standard", "pm10_environmental", b"pm10_environmental", "pm10_standard", b"pm10_standard", "pm25_environmental", b"pm25_environmental", "pm25_standard", b"pm25_standard", "pm40_standard", b"pm40_standard", "pm_humidity", b"pm_humidity", "pm_nox_idx", b"pm_nox_idx", "pm_temperature", b"pm_temperature", "pm_voc_idx", b"pm_voc_idx"]) -> None: ...
+    def HasField(self, field_name: typing.Literal["_co2", b"_co2", "_co2_humidity", b"_co2_humidity", "_co2_temperature", b"_co2_temperature", "_form_formaldehyde", b"_form_formaldehyde", "_form_humidity", b"_form_humidity", "_form_temperature", b"_form_temperature", "_particles_03um", b"_particles_03um", "_particles_05um", b"_particles_05um", "_particles_100um", b"_particles_100um", "_particles_10um", b"_particles_10um", "_particles_25um", b"_particles_25um", "_particles_40um", b"_particles_40um", "_particles_50um", b"_particles_50um", "_particles_tps", b"_particles_tps", "_pm100_environmental", b"_pm100_environmental", "_pm100_standard", b"_pm100_standard", "_pm10_environmental", b"_pm10_environmental", "_pm10_standard", b"_pm10_standard", "_pm25_environmental", b"_pm25_environmental", "_pm25_standard", b"_pm25_standard", "_pm40_standard", b"_pm40_standard", "_pm_humidity", b"_pm_humidity", "_pm_nox_idx", b"_pm_nox_idx", "_pm_status_flags", b"_pm_status_flags", "_pm_temperature", b"_pm_temperature", "_pm_voc_idx", b"_pm_voc_idx", "co2", b"co2", "co2_humidity", b"co2_humidity", "co2_temperature", b"co2_temperature", "form_formaldehyde", b"form_formaldehyde", "form_humidity", b"form_humidity", "form_temperature", b"form_temperature", "particles_03um", b"particles_03um", "particles_05um", b"particles_05um", "particles_100um", b"particles_100um", "particles_10um", b"particles_10um", "particles_25um", b"particles_25um", "particles_40um", b"particles_40um", "particles_50um", b"particles_50um", "particles_tps", b"particles_tps", "pm100_environmental", b"pm100_environmental", "pm100_standard", b"pm100_standard", "pm10_environmental", b"pm10_environmental", "pm10_standard", b"pm10_standard", "pm25_environmental", b"pm25_environmental", "pm25_standard", b"pm25_standard", "pm40_standard", b"pm40_standard", "pm_humidity", b"pm_humidity", "pm_nox_idx", b"pm_nox_idx", "pm_status_flags", b"pm_status_flags", "pm_temperature", b"pm_temperature", "pm_voc_idx", b"pm_voc_idx"]) -> builtins.bool: ...
+    def ClearField(self, field_name: typing.Literal["_co2", b"_co2", "_co2_humidity", b"_co2_humidity", "_co2_temperature", b"_co2_temperature", "_form_formaldehyde", b"_form_formaldehyde", "_form_humidity", b"_form_humidity", "_form_temperature", b"_form_temperature", "_particles_03um", b"_particles_03um", "_particles_05um", b"_particles_05um", "_particles_100um", b"_particles_100um", "_particles_10um", b"_particles_10um", "_particles_25um", b"_particles_25um", "_particles_40um", b"_particles_40um", "_particles_50um", b"_particles_50um", "_particles_tps", b"_particles_tps", "_pm100_environmental", b"_pm100_environmental", "_pm100_standard", b"_pm100_standard", "_pm10_environmental", b"_pm10_environmental", "_pm10_standard", b"_pm10_standard", "_pm25_environmental", b"_pm25_environmental", "_pm25_standard", b"_pm25_standard", "_pm40_standard", b"_pm40_standard", "_pm_humidity", b"_pm_humidity", "_pm_nox_idx", b"_pm_nox_idx", "_pm_status_flags", b"_pm_status_flags", "_pm_temperature", b"_pm_temperature", "_pm_voc_idx", b"_pm_voc_idx", "co2", b"co2", "co2_humidity", b"co2_humidity", "co2_temperature", b"co2_temperature", "form_formaldehyde", b"form_formaldehyde", "form_humidity", b"form_humidity", "form_temperature", b"form_temperature", "particles_03um", b"particles_03um", "particles_05um", b"particles_05um", "particles_100um", b"particles_100um", "particles_10um", b"particles_10um", "particles_25um", b"particles_25um", "particles_40um", b"particles_40um", "particles_50um", b"particles_50um", "particles_tps", b"particles_tps", "pm100_environmental", b"pm100_environmental", "pm100_standard", b"pm100_standard", "pm10_environmental", b"pm10_environmental", "pm10_standard", b"pm10_standard", "pm25_environmental", b"pm25_environmental", "pm25_standard", b"pm25_standard", "pm40_standard", b"pm40_standard", "pm_humidity", b"pm_humidity", "pm_nox_idx", b"pm_nox_idx", "pm_status_flags", b"pm_status_flags", "pm_temperature", b"pm_temperature", "pm_voc_idx", b"pm_voc_idx"]) -> None: ...
     @typing.overload
     def WhichOneof(self, oneof_group: typing.Literal["_co2", b"_co2"]) -> typing.Literal["co2"] | None: ...
     @typing.overload
@@ -1081,6 +1266,8 @@ class AirQualityMetrics(google.protobuf.message.Message):
     @typing.overload
     def WhichOneof(self, oneof_group: typing.Literal["_pm_nox_idx", b"_pm_nox_idx"]) -> typing.Literal["pm_nox_idx"] | None: ...
     @typing.overload
+    def WhichOneof(self, oneof_group: typing.Literal["_pm_status_flags", b"_pm_status_flags"]) -> typing.Literal["pm_status_flags"] | None: ...
+    @typing.overload
     def WhichOneof(self, oneof_group: typing.Literal["_pm_temperature", b"_pm_temperature"]) -> typing.Literal["pm_temperature"] | None: ...
     @typing.overload
     def WhichOneof(self, oneof_group: typing.Literal["_pm_voc_idx", b"_pm_voc_idx"]) -> typing.Literal["pm_voc_idx"] | None: ...
@@ -1488,10 +1675,33 @@ class Nau7802Config(google.protobuf.message.Message):
 
 global___Nau7802Config = Nau7802Config
 
+@typing.final
+class AS3935Config(google.protobuf.message.Message):
+    """
+    AS3935 lightning sensor configuration, for saving to flash
+    """
+
+    DESCRIPTOR: google.protobuf.descriptor.Descriptor
+
+    TUNING_CAP_PF_FIELD_NUMBER: builtins.int
+    tuning_cap_pf: builtins.int
+    """
+    Antenna tuning capacitance in pF, 0 to 120 in steps of 8. The chip does not retain
+    this across power loss, so it is stored here and re-applied on every boot.
+    """
+    def __init__(
+        self,
+        *,
+        tuning_cap_pf: builtins.int = ...,
+    ) -> None: ...
+    def ClearField(self, field_name: typing.Literal["tuning_cap_pf", b"tuning_cap_pf"]) -> None: ...
+
+global___AS3935Config = AS3935Config
+
 @typing.final
 class SEN5XState(google.protobuf.message.Message):
     """
-    SEN5X State, for saving to flash
+    SEN5X State, for saving to flash (to be merged with SEN6XState)
     """
 
     DESCRIPTOR: google.protobuf.descriptor.Descriptor
@@ -1546,3 +1756,62 @@ class SEN5XState(google.protobuf.message.Message):
     def WhichOneof(self, oneof_group: typing.Literal["_voc_state_valid", b"_voc_state_valid"]) -> typing.Literal["voc_state_valid"] | None: ...
 
 global___SEN5XState = SEN5XState
+
+@typing.final
+class SEN6XState(google.protobuf.message.Message):
+    """
+    SEN6X State, for saving to flash
+    """
+
+    DESCRIPTOR: google.protobuf.descriptor.Descriptor
+
+    LAST_CLEANING_TIME_FIELD_NUMBER: builtins.int
+    LAST_CLEANING_VALID_FIELD_NUMBER: builtins.int
+    ONE_SHOT_MODE_FIELD_NUMBER: builtins.int
+    VOC_STATE_TIME_FIELD_NUMBER: builtins.int
+    VOC_STATE_VALID_FIELD_NUMBER: builtins.int
+    VOC_STATE_ARRAY_FIELD_NUMBER: builtins.int
+    last_cleaning_time: builtins.int
+    """
+    Last cleaning time for SEN6X
+    """
+    last_cleaning_valid: builtins.bool
+    """
+    Last cleaning time for SEN6X - valid flag
+    """
+    one_shot_mode: builtins.bool
+    """
+    Config flag for one-shot mode (see admin.proto)
+    """
+    voc_state_time: builtins.int
+    """
+    Last VOC state time, for models with a VOC sensor (SEN65, SEN66, SEN68, SEN69C)
+    """
+    voc_state_valid: builtins.bool
+    """
+    Last VOC state validity flag, for models with a VOC sensor (SEN65, SEN66, SEN68, SEN69C)
+    """
+    voc_state_array: builtins.int
+    """
+    VOC state array (8x uint8t), for models with a VOC sensor (SEN65, SEN66, SEN68, SEN69C)
+    """
+    def __init__(
+        self,
+        *,
+        last_cleaning_time: builtins.int = ...,
+        last_cleaning_valid: builtins.bool = ...,
+        one_shot_mode: builtins.bool = ...,
+        voc_state_time: builtins.int | None = ...,
+        voc_state_valid: builtins.bool | None = ...,
+        voc_state_array: builtins.int | None = ...,
+    ) -> None: ...
+    def HasField(self, field_name: typing.Literal["_voc_state_array", b"_voc_state_array", "_voc_state_time", b"_voc_state_time", "_voc_state_valid", b"_voc_state_valid", "voc_state_array", b"voc_state_array", "voc_state_time", b"voc_state_time", "voc_state_valid", b"voc_state_valid"]) -> builtins.bool: ...
+    def ClearField(self, field_name: typing.Literal["_voc_state_array", b"_voc_state_array", "_voc_state_time", b"_voc_state_time", "_voc_state_valid", b"_voc_state_valid", "last_cleaning_time", b"last_cleaning_time", "last_cleaning_valid", b"last_cleaning_valid", "one_shot_mode", b"one_shot_mode", "voc_state_array", b"voc_state_array", "voc_state_time", b"voc_state_time", "voc_state_valid", b"voc_state_valid"]) -> None: ...
+    @typing.overload
+    def WhichOneof(self, oneof_group: typing.Literal["_voc_state_array", b"_voc_state_array"]) -> typing.Literal["voc_state_array"] | None: ...
+    @typing.overload
+    def WhichOneof(self, oneof_group: typing.Literal["_voc_state_time", b"_voc_state_time"]) -> typing.Literal["voc_state_time"] | None: ...
+    @typing.overload
+    def WhichOneof(self, oneof_group: typing.Literal["_voc_state_valid", b"_voc_state_valid"]) -> typing.Literal["voc_state_valid"] | None: ...
+
+global___SEN6XState = SEN6XState

meshtastic/tests/test_inject_nanopb_options.py

@@ -21,6 +21,7 @@ from meshtastic.protobuf import (
     atak_pb2,
     config_pb2,
     mesh_pb2,
+    mqtt_pb2,
     nanopb_pb2,
     telemetry_pb2,
 )
@@ -640,7 +641,15 @@ def test_descriptor_multilevel_nested_route_link_uid():
 
 @pytest.mark.unit
 def test_descriptor_telemetry_environment_one_wire_temperature():
-    """EnvironmentMetrics.one_wire_temperature has max_count = 8 from telemetry.options."""
+    """EnvironmentMetrics.one_wire_temperature has type = FT_IGNORE from telemetry.options."""
     env = telemetry_pb2.DESCRIPTOR.message_types_by_name["EnvironmentMetrics"]
     opts = _field_opts(env, "one_wire_temperature")
-    assert opts.max_count == 8
+    assert opts.type == nanopb_pb2.FT_IGNORE
+
+
+@pytest.mark.unit
+def test_descriptor_mqtt_service_envelope_pointer_fields():
+    """ServiceEnvelope fields carry type = FT_POINTER from mqtt.options."""
+    envelope = mqtt_pb2.DESCRIPTOR.message_types_by_name["ServiceEnvelope"]
+    for name in ("packet", "channel_id", "gateway_id"):
+        assert _field_opts(envelope, name).type == nanopb_pb2.FT_POINTER

meshtastic/tests/test_mesh_interface_traffic_management.py

@@ -12,11 +12,11 @@ def test_handleFromRadio_with_traffic_management_module_config():
     """Test _handleFromRadio with moduleConfig.traffic_management."""
     iface = MeshInterface(noProto=True)
     from_radio = mesh_pb2.FromRadio()
-    from_radio.moduleConfig.traffic_management.enabled = True
-    from_radio.moduleConfig.traffic_management.rate_limit_enabled = True
+    from_radio.moduleConfig.traffic_management.position_min_interval_secs = 30
+    from_radio.moduleConfig.traffic_management.rate_limit_window_secs = 60
 
     iface._handleFromRadio(from_radio.SerializeToString())
 
-    assert iface.localNode.moduleConfig.traffic_management.enabled is True
-    assert iface.localNode.moduleConfig.traffic_management.rate_limit_enabled is True
+    assert iface.localNode.moduleConfig.traffic_management.position_min_interval_secs == 30
+    assert iface.localNode.moduleConfig.traffic_management.rate_limit_window_secs == 60
     iface.close()

meshtastic/tests/test_node.py

@@ -1153,8 +1153,8 @@ def test_writeConfig_traffic_management():
     """Test writeConfig with traffic_management module config."""
     iface = MagicMock(autospec=SerialInterface)
     anode = Node(iface, 123, noProto=True)
-    anode.moduleConfig.traffic_management.enabled = True
-    anode.moduleConfig.traffic_management.rate_limit_enabled = True
+    anode.moduleConfig.traffic_management.position_min_interval_secs = 30
+    anode.moduleConfig.traffic_management.rate_limit_window_secs = 60
 
     sent_admin = []
 
@@ -1167,8 +1167,8 @@ def test_writeConfig_traffic_management():
     assert len(sent_admin) == 1
     assert sent_admin[0].HasField("set_module_config")
     assert sent_admin[0].set_module_config.HasField("traffic_management")
-    assert sent_admin[0].set_module_config.traffic_management.enabled is True
-    assert sent_admin[0].set_module_config.traffic_management.rate_limit_enabled is True
+    assert sent_admin[0].set_module_config.traffic_management.position_min_interval_secs == 30
+    assert sent_admin[0].set_module_config.traffic_management.rate_limit_window_secs == 60
 
 
 # TODO