esp_hosted/

proto.rs

#![allow(warnings)]
#![allow(clippy::all)]

#[derive(Debug, Default, PartialEq, Clone)]
pub struct r#wifi_init_config {
    pub r#static_rx_buf_num: i32,
    pub r#dynamic_rx_buf_num: i32,
    pub r#tx_buf_type: i32,
    pub r#static_tx_buf_num: i32,
    pub r#dynamic_tx_buf_num: i32,
    pub r#cache_tx_buf_num: i32,
    pub r#csi_enable: i32,
    pub r#ampdu_rx_enable: i32,
    pub r#ampdu_tx_enable: i32,
    pub r#amsdu_tx_enable: i32,
    pub r#nvs_enable: i32,
    pub r#nano_enable: i32,
    pub r#rx_ba_win: i32,
    pub r#wifi_task_core_id: i32,
    pub r#beacon_max_len: i32,
    pub r#mgmt_sbuf_num: i32,
    pub r#feature_caps: u64,
    pub r#sta_disconnected_pm: bool,
    pub r#espnow_max_encrypt_num: i32,
    pub r#magic: i32,
}
impl r#wifi_init_config {
    ///Return a reference to `static_rx_buf_num`
    #[inline]
    pub fn r#static_rx_buf_num(&self) -> &i32 {
        &self.r#static_rx_buf_num
    }
    ///Return a mutable reference to `static_rx_buf_num`
    #[inline]
    pub fn mut_static_rx_buf_num(&mut self) -> &mut i32 {
        &mut self.r#static_rx_buf_num
    }
    ///Set the value of `static_rx_buf_num`
    #[inline]
    pub fn set_static_rx_buf_num(&mut self, value: i32) -> &mut Self {
        self.r#static_rx_buf_num = value.into();
        self
    }
    ///Builder method that sets the value of `static_rx_buf_num`. Useful for initializing the message.
    #[inline]
    pub fn init_static_rx_buf_num(mut self, value: i32) -> Self {
        self.r#static_rx_buf_num = value.into();
        self
    }
    ///Return a reference to `dynamic_rx_buf_num`
    #[inline]
    pub fn r#dynamic_rx_buf_num(&self) -> &i32 {
        &self.r#dynamic_rx_buf_num
    }
    ///Return a mutable reference to `dynamic_rx_buf_num`
    #[inline]
    pub fn mut_dynamic_rx_buf_num(&mut self) -> &mut i32 {
        &mut self.r#dynamic_rx_buf_num
    }
    ///Set the value of `dynamic_rx_buf_num`
    #[inline]
    pub fn set_dynamic_rx_buf_num(&mut self, value: i32) -> &mut Self {
        self.r#dynamic_rx_buf_num = value.into();
        self
    }
    ///Builder method that sets the value of `dynamic_rx_buf_num`. Useful for initializing the message.
    #[inline]
    pub fn init_dynamic_rx_buf_num(mut self, value: i32) -> Self {
        self.r#dynamic_rx_buf_num = value.into();
        self
    }
    ///Return a reference to `tx_buf_type`
    #[inline]
    pub fn r#tx_buf_type(&self) -> &i32 {
        &self.r#tx_buf_type
    }
    ///Return a mutable reference to `tx_buf_type`
    #[inline]
    pub fn mut_tx_buf_type(&mut self) -> &mut i32 {
        &mut self.r#tx_buf_type
    }
    ///Set the value of `tx_buf_type`
    #[inline]
    pub fn set_tx_buf_type(&mut self, value: i32) -> &mut Self {
        self.r#tx_buf_type = value.into();
        self
    }
    ///Builder method that sets the value of `tx_buf_type`. Useful for initializing the message.
    #[inline]
    pub fn init_tx_buf_type(mut self, value: i32) -> Self {
        self.r#tx_buf_type = value.into();
        self
    }
    ///Return a reference to `static_tx_buf_num`
    #[inline]
    pub fn r#static_tx_buf_num(&self) -> &i32 {
        &self.r#static_tx_buf_num
    }
    ///Return a mutable reference to `static_tx_buf_num`
    #[inline]
    pub fn mut_static_tx_buf_num(&mut self) -> &mut i32 {
        &mut self.r#static_tx_buf_num
    }
    ///Set the value of `static_tx_buf_num`
    #[inline]
    pub fn set_static_tx_buf_num(&mut self, value: i32) -> &mut Self {
        self.r#static_tx_buf_num = value.into();
        self
    }
    ///Builder method that sets the value of `static_tx_buf_num`. Useful for initializing the message.
    #[inline]
    pub fn init_static_tx_buf_num(mut self, value: i32) -> Self {
        self.r#static_tx_buf_num = value.into();
        self
    }
    ///Return a reference to `dynamic_tx_buf_num`
    #[inline]
    pub fn r#dynamic_tx_buf_num(&self) -> &i32 {
        &self.r#dynamic_tx_buf_num
    }
    ///Return a mutable reference to `dynamic_tx_buf_num`
    #[inline]
    pub fn mut_dynamic_tx_buf_num(&mut self) -> &mut i32 {
        &mut self.r#dynamic_tx_buf_num
    }
    ///Set the value of `dynamic_tx_buf_num`
    #[inline]
    pub fn set_dynamic_tx_buf_num(&mut self, value: i32) -> &mut Self {
        self.r#dynamic_tx_buf_num = value.into();
        self
    }
    ///Builder method that sets the value of `dynamic_tx_buf_num`. Useful for initializing the message.
    #[inline]
    pub fn init_dynamic_tx_buf_num(mut self, value: i32) -> Self {
        self.r#dynamic_tx_buf_num = value.into();
        self
    }
    ///Return a reference to `cache_tx_buf_num`
    #[inline]
    pub fn r#cache_tx_buf_num(&self) -> &i32 {
        &self.r#cache_tx_buf_num
    }
    ///Return a mutable reference to `cache_tx_buf_num`
    #[inline]
    pub fn mut_cache_tx_buf_num(&mut self) -> &mut i32 {
        &mut self.r#cache_tx_buf_num
    }
    ///Set the value of `cache_tx_buf_num`
    #[inline]
    pub fn set_cache_tx_buf_num(&mut self, value: i32) -> &mut Self {
        self.r#cache_tx_buf_num = value.into();
        self
    }
    ///Builder method that sets the value of `cache_tx_buf_num`. Useful for initializing the message.
    #[inline]
    pub fn init_cache_tx_buf_num(mut self, value: i32) -> Self {
        self.r#cache_tx_buf_num = value.into();
        self
    }
    ///Return a reference to `csi_enable`
    #[inline]
    pub fn r#csi_enable(&self) -> &i32 {
        &self.r#csi_enable
    }
    ///Return a mutable reference to `csi_enable`
    #[inline]
    pub fn mut_csi_enable(&mut self) -> &mut i32 {
        &mut self.r#csi_enable
    }
    ///Set the value of `csi_enable`
    #[inline]
    pub fn set_csi_enable(&mut self, value: i32) -> &mut Self {
        self.r#csi_enable = value.into();
        self
    }
    ///Builder method that sets the value of `csi_enable`. Useful for initializing the message.
    #[inline]
    pub fn init_csi_enable(mut self, value: i32) -> Self {
        self.r#csi_enable = value.into();
        self
    }
    ///Return a reference to `ampdu_rx_enable`
    #[inline]
    pub fn r#ampdu_rx_enable(&self) -> &i32 {
        &self.r#ampdu_rx_enable
    }
    ///Return a mutable reference to `ampdu_rx_enable`
    #[inline]
    pub fn mut_ampdu_rx_enable(&mut self) -> &mut i32 {
        &mut self.r#ampdu_rx_enable
    }
    ///Set the value of `ampdu_rx_enable`
    #[inline]
    pub fn set_ampdu_rx_enable(&mut self, value: i32) -> &mut Self {
        self.r#ampdu_rx_enable = value.into();
        self
    }
    ///Builder method that sets the value of `ampdu_rx_enable`. Useful for initializing the message.
    #[inline]
    pub fn init_ampdu_rx_enable(mut self, value: i32) -> Self {
        self.r#ampdu_rx_enable = value.into();
        self
    }
    ///Return a reference to `ampdu_tx_enable`
    #[inline]
    pub fn r#ampdu_tx_enable(&self) -> &i32 {
        &self.r#ampdu_tx_enable
    }
    ///Return a mutable reference to `ampdu_tx_enable`
    #[inline]
    pub fn mut_ampdu_tx_enable(&mut self) -> &mut i32 {
        &mut self.r#ampdu_tx_enable
    }
    ///Set the value of `ampdu_tx_enable`
    #[inline]
    pub fn set_ampdu_tx_enable(&mut self, value: i32) -> &mut Self {
        self.r#ampdu_tx_enable = value.into();
        self
    }
    ///Builder method that sets the value of `ampdu_tx_enable`. Useful for initializing the message.
    #[inline]
    pub fn init_ampdu_tx_enable(mut self, value: i32) -> Self {
        self.r#ampdu_tx_enable = value.into();
        self
    }
    ///Return a reference to `amsdu_tx_enable`
    #[inline]
    pub fn r#amsdu_tx_enable(&self) -> &i32 {
        &self.r#amsdu_tx_enable
    }
    ///Return a mutable reference to `amsdu_tx_enable`
    #[inline]
    pub fn mut_amsdu_tx_enable(&mut self) -> &mut i32 {
        &mut self.r#amsdu_tx_enable
    }
    ///Set the value of `amsdu_tx_enable`
    #[inline]
    pub fn set_amsdu_tx_enable(&mut self, value: i32) -> &mut Self {
        self.r#amsdu_tx_enable = value.into();
        self
    }
    ///Builder method that sets the value of `amsdu_tx_enable`. Useful for initializing the message.
    #[inline]
    pub fn init_amsdu_tx_enable(mut self, value: i32) -> Self {
        self.r#amsdu_tx_enable = value.into();
        self
    }
    ///Return a reference to `nvs_enable`
    #[inline]
    pub fn r#nvs_enable(&self) -> &i32 {
        &self.r#nvs_enable
    }
    ///Return a mutable reference to `nvs_enable`
    #[inline]
    pub fn mut_nvs_enable(&mut self) -> &mut i32 {
        &mut self.r#nvs_enable
    }
    ///Set the value of `nvs_enable`
    #[inline]
    pub fn set_nvs_enable(&mut self, value: i32) -> &mut Self {
        self.r#nvs_enable = value.into();
        self
    }
    ///Builder method that sets the value of `nvs_enable`. Useful for initializing the message.
    #[inline]
    pub fn init_nvs_enable(mut self, value: i32) -> Self {
        self.r#nvs_enable = value.into();
        self
    }
    ///Return a reference to `nano_enable`
    #[inline]
    pub fn r#nano_enable(&self) -> &i32 {
        &self.r#nano_enable
    }
    ///Return a mutable reference to `nano_enable`
    #[inline]
    pub fn mut_nano_enable(&mut self) -> &mut i32 {
        &mut self.r#nano_enable
    }
    ///Set the value of `nano_enable`
    #[inline]
    pub fn set_nano_enable(&mut self, value: i32) -> &mut Self {
        self.r#nano_enable = value.into();
        self
    }
    ///Builder method that sets the value of `nano_enable`. Useful for initializing the message.
    #[inline]
    pub fn init_nano_enable(mut self, value: i32) -> Self {
        self.r#nano_enable = value.into();
        self
    }
    ///Return a reference to `rx_ba_win`
    #[inline]
    pub fn r#rx_ba_win(&self) -> &i32 {
        &self.r#rx_ba_win
    }
    ///Return a mutable reference to `rx_ba_win`
    #[inline]
    pub fn mut_rx_ba_win(&mut self) -> &mut i32 {
        &mut self.r#rx_ba_win
    }
    ///Set the value of `rx_ba_win`
    #[inline]
    pub fn set_rx_ba_win(&mut self, value: i32) -> &mut Self {
        self.r#rx_ba_win = value.into();
        self
    }
    ///Builder method that sets the value of `rx_ba_win`. Useful for initializing the message.
    #[inline]
    pub fn init_rx_ba_win(mut self, value: i32) -> Self {
        self.r#rx_ba_win = value.into();
        self
    }
    ///Return a reference to `wifi_task_core_id`
    #[inline]
    pub fn r#wifi_task_core_id(&self) -> &i32 {
        &self.r#wifi_task_core_id
    }
    ///Return a mutable reference to `wifi_task_core_id`
    #[inline]
    pub fn mut_wifi_task_core_id(&mut self) -> &mut i32 {
        &mut self.r#wifi_task_core_id
    }
    ///Set the value of `wifi_task_core_id`
    #[inline]
    pub fn set_wifi_task_core_id(&mut self, value: i32) -> &mut Self {
        self.r#wifi_task_core_id = value.into();
        self
    }
    ///Builder method that sets the value of `wifi_task_core_id`. Useful for initializing the message.
    #[inline]
    pub fn init_wifi_task_core_id(mut self, value: i32) -> Self {
        self.r#wifi_task_core_id = value.into();
        self
    }
    ///Return a reference to `beacon_max_len`
    #[inline]
    pub fn r#beacon_max_len(&self) -> &i32 {
        &self.r#beacon_max_len
    }
    ///Return a mutable reference to `beacon_max_len`
    #[inline]
    pub fn mut_beacon_max_len(&mut self) -> &mut i32 {
        &mut self.r#beacon_max_len
    }
    ///Set the value of `beacon_max_len`
    #[inline]
    pub fn set_beacon_max_len(&mut self, value: i32) -> &mut Self {
        self.r#beacon_max_len = value.into();
        self
    }
    ///Builder method that sets the value of `beacon_max_len`. Useful for initializing the message.
    #[inline]
    pub fn init_beacon_max_len(mut self, value: i32) -> Self {
        self.r#beacon_max_len = value.into();
        self
    }
    ///Return a reference to `mgmt_sbuf_num`
    #[inline]
    pub fn r#mgmt_sbuf_num(&self) -> &i32 {
        &self.r#mgmt_sbuf_num
    }
    ///Return a mutable reference to `mgmt_sbuf_num`
    #[inline]
    pub fn mut_mgmt_sbuf_num(&mut self) -> &mut i32 {
        &mut self.r#mgmt_sbuf_num
    }
    ///Set the value of `mgmt_sbuf_num`
    #[inline]
    pub fn set_mgmt_sbuf_num(&mut self, value: i32) -> &mut Self {
        self.r#mgmt_sbuf_num = value.into();
        self
    }
    ///Builder method that sets the value of `mgmt_sbuf_num`. Useful for initializing the message.
    #[inline]
    pub fn init_mgmt_sbuf_num(mut self, value: i32) -> Self {
        self.r#mgmt_sbuf_num = value.into();
        self
    }
    ///Return a reference to `feature_caps`
    #[inline]
    pub fn r#feature_caps(&self) -> &u64 {
        &self.r#feature_caps
    }
    ///Return a mutable reference to `feature_caps`
    #[inline]
    pub fn mut_feature_caps(&mut self) -> &mut u64 {
        &mut self.r#feature_caps
    }
    ///Set the value of `feature_caps`
    #[inline]
    pub fn set_feature_caps(&mut self, value: u64) -> &mut Self {
        self.r#feature_caps = value.into();
        self
    }
    ///Builder method that sets the value of `feature_caps`. Useful for initializing the message.
    #[inline]
    pub fn init_feature_caps(mut self, value: u64) -> Self {
        self.r#feature_caps = value.into();
        self
    }
    ///Return a reference to `sta_disconnected_pm`
    #[inline]
    pub fn r#sta_disconnected_pm(&self) -> &bool {
        &self.r#sta_disconnected_pm
    }
    ///Return a mutable reference to `sta_disconnected_pm`
    #[inline]
    pub fn mut_sta_disconnected_pm(&mut self) -> &mut bool {
        &mut self.r#sta_disconnected_pm
    }
    ///Set the value of `sta_disconnected_pm`
    #[inline]
    pub fn set_sta_disconnected_pm(&mut self, value: bool) -> &mut Self {
        self.r#sta_disconnected_pm = value.into();
        self
    }
    ///Builder method that sets the value of `sta_disconnected_pm`. Useful for initializing the message.
    #[inline]
    pub fn init_sta_disconnected_pm(mut self, value: bool) -> Self {
        self.r#sta_disconnected_pm = value.into();
        self
    }
    ///Return a reference to `espnow_max_encrypt_num`
    #[inline]
    pub fn r#espnow_max_encrypt_num(&self) -> &i32 {
        &self.r#espnow_max_encrypt_num
    }
    ///Return a mutable reference to `espnow_max_encrypt_num`
    #[inline]
    pub fn mut_espnow_max_encrypt_num(&mut self) -> &mut i32 {
        &mut self.r#espnow_max_encrypt_num
    }
    ///Set the value of `espnow_max_encrypt_num`
    #[inline]
    pub fn set_espnow_max_encrypt_num(&mut self, value: i32) -> &mut Self {
        self.r#espnow_max_encrypt_num = value.into();
        self
    }
    ///Builder method that sets the value of `espnow_max_encrypt_num`. Useful for initializing the message.
    #[inline]
    pub fn init_espnow_max_encrypt_num(mut self, value: i32) -> Self {
        self.r#espnow_max_encrypt_num = value.into();
        self
    }
    ///Return a reference to `magic`
    #[inline]
    pub fn r#magic(&self) -> &i32 {
        &self.r#magic
    }
    ///Return a mutable reference to `magic`
    #[inline]
    pub fn mut_magic(&mut self) -> &mut i32 {
        &mut self.r#magic
    }
    ///Set the value of `magic`
    #[inline]
    pub fn set_magic(&mut self, value: i32) -> &mut Self {
        self.r#magic = value.into();
        self
    }
    ///Builder method that sets the value of `magic`. Useful for initializing the message.
    #[inline]
    pub fn init_magic(mut self, value: i32) -> Self {
        self.r#magic = value.into();
        self
    }
}
impl ::micropb::MessageDecode for r#wifi_init_config {
    fn decode<IMPL_MICROPB_READ: ::micropb::PbRead>(
        &mut self,
        decoder: &mut ::micropb::PbDecoder<IMPL_MICROPB_READ>,
        len: usize,
    ) -> Result<(), ::micropb::DecodeError<IMPL_MICROPB_READ::Error>> {
        use ::micropb::{FieldDecode, PbBytes, PbMap, PbString, PbVec};
        let before = decoder.bytes_read();
        while decoder.bytes_read() - before < len {
            let tag = decoder.decode_tag()?;
            match tag.field_num() {
                0 => return Err(::micropb::DecodeError::ZeroField),
                1u32 => {
                    let mut_ref = &mut self.r#static_rx_buf_num;
                    {
                        let val = decoder.decode_int32()?;
                        let val_ref = &val;
                        if *val_ref != 0 {
                            *mut_ref = val as _;
                        }
                    };
                }
                2u32 => {
                    let mut_ref = &mut self.r#dynamic_rx_buf_num;
                    {
                        let val = decoder.decode_int32()?;
                        let val_ref = &val;
                        if *val_ref != 0 {
                            *mut_ref = val as _;
                        }
                    };
                }
                3u32 => {
                    let mut_ref = &mut self.r#tx_buf_type;
                    {
                        let val = decoder.decode_int32()?;
                        let val_ref = &val;
                        if *val_ref != 0 {
                            *mut_ref = val as _;
                        }
                    };
                }
                4u32 => {
                    let mut_ref = &mut self.r#static_tx_buf_num;
                    {
                        let val = decoder.decode_int32()?;
                        let val_ref = &val;
                        if *val_ref != 0 {
                            *mut_ref = val as _;
                        }
                    };
                }
                5u32 => {
                    let mut_ref = &mut self.r#dynamic_tx_buf_num;
                    {
                        let val = decoder.decode_int32()?;
                        let val_ref = &val;
                        if *val_ref != 0 {
                            *mut_ref = val as _;
                        }
                    };
                }
                6u32 => {
                    let mut_ref = &mut self.r#cache_tx_buf_num;
                    {
                        let val = decoder.decode_int32()?;
                        let val_ref = &val;
                        if *val_ref != 0 {
                            *mut_ref = val as _;
                        }
                    };
                }
                7u32 => {
                    let mut_ref = &mut self.r#csi_enable;
                    {
                        let val = decoder.decode_int32()?;
                        let val_ref = &val;
                        if *val_ref != 0 {
                            *mut_ref = val as _;
                        }
                    };
                }
                8u32 => {
                    let mut_ref = &mut self.r#ampdu_rx_enable;
                    {
                        let val = decoder.decode_int32()?;
                        let val_ref = &val;
                        if *val_ref != 0 {
                            *mut_ref = val as _;
                        }
                    };
                }
                9u32 => {
                    let mut_ref = &mut self.r#ampdu_tx_enable;
                    {
                        let val = decoder.decode_int32()?;
                        let val_ref = &val;
                        if *val_ref != 0 {
                            *mut_ref = val as _;
                        }
                    };
                }
                10u32 => {
                    let mut_ref = &mut self.r#amsdu_tx_enable;
                    {
                        let val = decoder.decode_int32()?;
                        let val_ref = &val;
                        if *val_ref != 0 {
                            *mut_ref = val as _;
                        }
                    };
                }
                11u32 => {
                    let mut_ref = &mut self.r#nvs_enable;
                    {
                        let val = decoder.decode_int32()?;
                        let val_ref = &val;
                        if *val_ref != 0 {
                            *mut_ref = val as _;
                        }
                    };
                }
                12u32 => {
                    let mut_ref = &mut self.r#nano_enable;
                    {
                        let val = decoder.decode_int32()?;
                        let val_ref = &val;
                        if *val_ref != 0 {
                            *mut_ref = val as _;
                        }
                    };
                }
                13u32 => {
                    let mut_ref = &mut self.r#rx_ba_win;
                    {
                        let val = decoder.decode_int32()?;
                        let val_ref = &val;
                        if *val_ref != 0 {
                            *mut_ref = val as _;
                        }
                    };
                }
                14u32 => {
                    let mut_ref = &mut self.r#wifi_task_core_id;
                    {
                        let val = decoder.decode_int32()?;
                        let val_ref = &val;
                        if *val_ref != 0 {
                            *mut_ref = val as _;
                        }
                    };
                }
                15u32 => {
                    let mut_ref = &mut self.r#beacon_max_len;
                    {
                        let val = decoder.decode_int32()?;
                        let val_ref = &val;
                        if *val_ref != 0 {
                            *mut_ref = val as _;
                        }
                    };
                }
                16u32 => {
                    let mut_ref = &mut self.r#mgmt_sbuf_num;
                    {
                        let val = decoder.decode_int32()?;
                        let val_ref = &val;
                        if *val_ref != 0 {
                            *mut_ref = val as _;
                        }
                    };
                }
                17u32 => {
                    let mut_ref = &mut self.r#feature_caps;
                    {
                        let val = decoder.decode_varint64()?;
                        let val_ref = &val;
                        if *val_ref != 0 {
                            *mut_ref = val as _;
                        }
                    };
                }
                18u32 => {
                    let mut_ref = &mut self.r#sta_disconnected_pm;
                    {
                        let val = decoder.decode_bool()?;
                        let val_ref = &val;
                        if *val_ref {
                            *mut_ref = val as _;
                        }
                    };
                }
                19u32 => {
                    let mut_ref = &mut self.r#espnow_max_encrypt_num;
                    {
                        let val = decoder.decode_int32()?;
                        let val_ref = &val;
                        if *val_ref != 0 {
                            *mut_ref = val as _;
                        }
                    };
                }
                20u32 => {
                    let mut_ref = &mut self.r#magic;
                    {
                        let val = decoder.decode_int32()?;
                        let val_ref = &val;
                        if *val_ref != 0 {
                            *mut_ref = val as _;
                        }
                    };
                }
                _ => {
                    decoder.skip_wire_value(tag.wire_type())?;
                }
            }
        }
        Ok(())
    }
}
impl ::micropb::MessageEncode for r#wifi_init_config {
    const MAX_SIZE: ::core::option::Option<usize> = 'msg: {
        let mut max_size = 0;
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(10usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(10usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(10usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(10usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(10usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(10usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(10usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(10usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(10usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(10usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(10usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(10usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(10usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(10usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(10usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(10usize), |size| size + 2usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(10usize), |size| size + 2usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(1usize), |size| size + 2usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(10usize), |size| size + 2usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(10usize), |size| size + 2usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        ::core::option::Option::Some(max_size)
    };
    fn encode<IMPL_MICROPB_WRITE: ::micropb::PbWrite>(
        &self,
        encoder: &mut ::micropb::PbEncoder<IMPL_MICROPB_WRITE>,
    ) -> Result<(), IMPL_MICROPB_WRITE::Error> {
        use ::micropb::{FieldEncode, PbMap};
        {
            let val_ref = &self.r#static_rx_buf_num;
            if *val_ref != 0 {
                encoder.encode_varint32(8u32)?;
                encoder.encode_int32(*val_ref as _)?;
            }
        }
        {
            let val_ref = &self.r#dynamic_rx_buf_num;
            if *val_ref != 0 {
                encoder.encode_varint32(16u32)?;
                encoder.encode_int32(*val_ref as _)?;
            }
        }
        {
            let val_ref = &self.r#tx_buf_type;
            if *val_ref != 0 {
                encoder.encode_varint32(24u32)?;
                encoder.encode_int32(*val_ref as _)?;
            }
        }
        {
            let val_ref = &self.r#static_tx_buf_num;
            if *val_ref != 0 {
                encoder.encode_varint32(32u32)?;
                encoder.encode_int32(*val_ref as _)?;
            }
        }
        {
            let val_ref = &self.r#dynamic_tx_buf_num;
            if *val_ref != 0 {
                encoder.encode_varint32(40u32)?;
                encoder.encode_int32(*val_ref as _)?;
            }
        }
        {
            let val_ref = &self.r#cache_tx_buf_num;
            if *val_ref != 0 {
                encoder.encode_varint32(48u32)?;
                encoder.encode_int32(*val_ref as _)?;
            }
        }
        {
            let val_ref = &self.r#csi_enable;
            if *val_ref != 0 {
                encoder.encode_varint32(56u32)?;
                encoder.encode_int32(*val_ref as _)?;
            }
        }
        {
            let val_ref = &self.r#ampdu_rx_enable;
            if *val_ref != 0 {
                encoder.encode_varint32(64u32)?;
                encoder.encode_int32(*val_ref as _)?;
            }
        }
        {
            let val_ref = &self.r#ampdu_tx_enable;
            if *val_ref != 0 {
                encoder.encode_varint32(72u32)?;
                encoder.encode_int32(*val_ref as _)?;
            }
        }
        {
            let val_ref = &self.r#amsdu_tx_enable;
            if *val_ref != 0 {
                encoder.encode_varint32(80u32)?;
                encoder.encode_int32(*val_ref as _)?;
            }
        }
        {
            let val_ref = &self.r#nvs_enable;
            if *val_ref != 0 {
                encoder.encode_varint32(88u32)?;
                encoder.encode_int32(*val_ref as _)?;
            }
        }
        {
            let val_ref = &self.r#nano_enable;
            if *val_ref != 0 {
                encoder.encode_varint32(96u32)?;
                encoder.encode_int32(*val_ref as _)?;
            }
        }
        {
            let val_ref = &self.r#rx_ba_win;
            if *val_ref != 0 {
                encoder.encode_varint32(104u32)?;
                encoder.encode_int32(*val_ref as _)?;
            }
        }
        {
            let val_ref = &self.r#wifi_task_core_id;
            if *val_ref != 0 {
                encoder.encode_varint32(112u32)?;
                encoder.encode_int32(*val_ref as _)?;
            }
        }
        {
            let val_ref = &self.r#beacon_max_len;
            if *val_ref != 0 {
                encoder.encode_varint32(120u32)?;
                encoder.encode_int32(*val_ref as _)?;
            }
        }
        {
            let val_ref = &self.r#mgmt_sbuf_num;
            if *val_ref != 0 {
                encoder.encode_varint32(128u32)?;
                encoder.encode_int32(*val_ref as _)?;
            }
        }
        {
            let val_ref = &self.r#feature_caps;
            if *val_ref != 0 {
                encoder.encode_varint32(136u32)?;
                encoder.encode_varint64(*val_ref as _)?;
            }
        }
        {
            let val_ref = &self.r#sta_disconnected_pm;
            if *val_ref {
                encoder.encode_varint32(144u32)?;
                encoder.encode_bool(*val_ref)?;
            }
        }
        {
            let val_ref = &self.r#espnow_max_encrypt_num;
            if *val_ref != 0 {
                encoder.encode_varint32(152u32)?;
                encoder.encode_int32(*val_ref as _)?;
            }
        }
        {
            let val_ref = &self.r#magic;
            if *val_ref != 0 {
                encoder.encode_varint32(160u32)?;
                encoder.encode_int32(*val_ref as _)?;
            }
        }
        Ok(())
    }
    fn compute_size(&self) -> usize {
        use ::micropb::{FieldEncode, PbMap};
        let mut size = 0;
        {
            let val_ref = &self.r#static_rx_buf_num;
            if *val_ref != 0 {
                size += 1usize + ::micropb::size::sizeof_int32(*val_ref as _);
            }
        }
        {
            let val_ref = &self.r#dynamic_rx_buf_num;
            if *val_ref != 0 {
                size += 1usize + ::micropb::size::sizeof_int32(*val_ref as _);
            }
        }
        {
            let val_ref = &self.r#tx_buf_type;
            if *val_ref != 0 {
                size += 1usize + ::micropb::size::sizeof_int32(*val_ref as _);
            }
        }
        {
            let val_ref = &self.r#static_tx_buf_num;
            if *val_ref != 0 {
                size += 1usize + ::micropb::size::sizeof_int32(*val_ref as _);
            }
        }
        {
            let val_ref = &self.r#dynamic_tx_buf_num;
            if *val_ref != 0 {
                size += 1usize + ::micropb::size::sizeof_int32(*val_ref as _);
            }
        }
        {
            let val_ref = &self.r#cache_tx_buf_num;
            if *val_ref != 0 {
                size += 1usize + ::micropb::size::sizeof_int32(*val_ref as _);
            }
        }
        {
            let val_ref = &self.r#csi_enable;
            if *val_ref != 0 {
                size += 1usize + ::micropb::size::sizeof_int32(*val_ref as _);
            }
        }
        {
            let val_ref = &self.r#ampdu_rx_enable;
            if *val_ref != 0 {
                size += 1usize + ::micropb::size::sizeof_int32(*val_ref as _);
            }
        }
        {
            let val_ref = &self.r#ampdu_tx_enable;
            if *val_ref != 0 {
                size += 1usize + ::micropb::size::sizeof_int32(*val_ref as _);
            }
        }
        {
            let val_ref = &self.r#amsdu_tx_enable;
            if *val_ref != 0 {
                size += 1usize + ::micropb::size::sizeof_int32(*val_ref as _);
            }
        }
        {
            let val_ref = &self.r#nvs_enable;
            if *val_ref != 0 {
                size += 1usize + ::micropb::size::sizeof_int32(*val_ref as _);
            }
        }
        {
            let val_ref = &self.r#nano_enable;
            if *val_ref != 0 {
                size += 1usize + ::micropb::size::sizeof_int32(*val_ref as _);
            }
        }
        {
            let val_ref = &self.r#rx_ba_win;
            if *val_ref != 0 {
                size += 1usize + ::micropb::size::sizeof_int32(*val_ref as _);
            }
        }
        {
            let val_ref = &self.r#wifi_task_core_id;
            if *val_ref != 0 {
                size += 1usize + ::micropb::size::sizeof_int32(*val_ref as _);
            }
        }
        {
            let val_ref = &self.r#beacon_max_len;
            if *val_ref != 0 {
                size += 1usize + ::micropb::size::sizeof_int32(*val_ref as _);
            }
        }
        {
            let val_ref = &self.r#mgmt_sbuf_num;
            if *val_ref != 0 {
                size += 2usize + ::micropb::size::sizeof_int32(*val_ref as _);
            }
        }
        {
            let val_ref = &self.r#feature_caps;
            if *val_ref != 0 {
                size += 2usize + ::micropb::size::sizeof_varint64(*val_ref as _);
            }
        }
        {
            let val_ref = &self.r#sta_disconnected_pm;
            if *val_ref {
                size += 2usize + 1;
            }
        }
        {
            let val_ref = &self.r#espnow_max_encrypt_num;
            if *val_ref != 0 {
                size += 2usize + ::micropb::size::sizeof_int32(*val_ref as _);
            }
        }
        {
            let val_ref = &self.r#magic;
            if *val_ref != 0 {
                size += 2usize + ::micropb::size::sizeof_int32(*val_ref as _);
            }
        }
        size
    }
}
#[derive(Debug, Default, PartialEq, Clone)]
pub struct r#wifi_country {
    pub r#cc: ::micropb::heapless::Vec<u8, 3>,
    pub r#schan: u32,
    pub r#nchan: u32,
    pub r#max_tx_power: i32,
    pub r#policy: i32,
}
impl r#wifi_country {
    ///Return a reference to `cc`
    #[inline]
    pub fn r#cc(&self) -> &::micropb::heapless::Vec<u8, 3> {
        &self.r#cc
    }
    ///Return a mutable reference to `cc`
    #[inline]
    pub fn mut_cc(&mut self) -> &mut ::micropb::heapless::Vec<u8, 3> {
        &mut self.r#cc
    }
    ///Set the value of `cc`
    #[inline]
    pub fn set_cc(&mut self, value: ::micropb::heapless::Vec<u8, 3>) -> &mut Self {
        self.r#cc = value.into();
        self
    }
    ///Builder method that sets the value of `cc`. Useful for initializing the message.
    #[inline]
    pub fn init_cc(mut self, value: ::micropb::heapless::Vec<u8, 3>) -> Self {
        self.r#cc = value.into();
        self
    }
    ///Return a reference to `schan`
    #[inline]
    pub fn r#schan(&self) -> &u32 {
        &self.r#schan
    }
    ///Return a mutable reference to `schan`
    #[inline]
    pub fn mut_schan(&mut self) -> &mut u32 {
        &mut self.r#schan
    }
    ///Set the value of `schan`
    #[inline]
    pub fn set_schan(&mut self, value: u32) -> &mut Self {
        self.r#schan = value.into();
        self
    }
    ///Builder method that sets the value of `schan`. Useful for initializing the message.
    #[inline]
    pub fn init_schan(mut self, value: u32) -> Self {
        self.r#schan = value.into();
        self
    }
    ///Return a reference to `nchan`
    #[inline]
    pub fn r#nchan(&self) -> &u32 {
        &self.r#nchan
    }
    ///Return a mutable reference to `nchan`
    #[inline]
    pub fn mut_nchan(&mut self) -> &mut u32 {
        &mut self.r#nchan
    }
    ///Set the value of `nchan`
    #[inline]
    pub fn set_nchan(&mut self, value: u32) -> &mut Self {
        self.r#nchan = value.into();
        self
    }
    ///Builder method that sets the value of `nchan`. Useful for initializing the message.
    #[inline]
    pub fn init_nchan(mut self, value: u32) -> Self {
        self.r#nchan = value.into();
        self
    }
    ///Return a reference to `max_tx_power`
    #[inline]
    pub fn r#max_tx_power(&self) -> &i32 {
        &self.r#max_tx_power
    }
    ///Return a mutable reference to `max_tx_power`
    #[inline]
    pub fn mut_max_tx_power(&mut self) -> &mut i32 {
        &mut self.r#max_tx_power
    }
    ///Set the value of `max_tx_power`
    #[inline]
    pub fn set_max_tx_power(&mut self, value: i32) -> &mut Self {
        self.r#max_tx_power = value.into();
        self
    }
    ///Builder method that sets the value of `max_tx_power`. Useful for initializing the message.
    #[inline]
    pub fn init_max_tx_power(mut self, value: i32) -> Self {
        self.r#max_tx_power = value.into();
        self
    }
    ///Return a reference to `policy`
    #[inline]
    pub fn r#policy(&self) -> &i32 {
        &self.r#policy
    }
    ///Return a mutable reference to `policy`
    #[inline]
    pub fn mut_policy(&mut self) -> &mut i32 {
        &mut self.r#policy
    }
    ///Set the value of `policy`
    #[inline]
    pub fn set_policy(&mut self, value: i32) -> &mut Self {
        self.r#policy = value.into();
        self
    }
    ///Builder method that sets the value of `policy`. Useful for initializing the message.
    #[inline]
    pub fn init_policy(mut self, value: i32) -> Self {
        self.r#policy = value.into();
        self
    }
}
impl ::micropb::MessageDecode for r#wifi_country {
    fn decode<IMPL_MICROPB_READ: ::micropb::PbRead>(
        &mut self,
        decoder: &mut ::micropb::PbDecoder<IMPL_MICROPB_READ>,
        len: usize,
    ) -> Result<(), ::micropb::DecodeError<IMPL_MICROPB_READ::Error>> {
        use ::micropb::{FieldDecode, PbBytes, PbMap, PbString, PbVec};
        let before = decoder.bytes_read();
        while decoder.bytes_read() - before < len {
            let tag = decoder.decode_tag()?;
            match tag.field_num() {
                0 => return Err(::micropb::DecodeError::ZeroField),
                1u32 => {
                    let mut_ref = &mut self.r#cc;
                    {
                        decoder.decode_bytes(mut_ref, ::micropb::Presence::Implicit)?;
                    };
                }
                2u32 => {
                    let mut_ref = &mut self.r#schan;
                    {
                        let val = decoder.decode_varint32()?;
                        let val_ref = &val;
                        if *val_ref != 0 {
                            *mut_ref = val as _;
                        }
                    };
                }
                3u32 => {
                    let mut_ref = &mut self.r#nchan;
                    {
                        let val = decoder.decode_varint32()?;
                        let val_ref = &val;
                        if *val_ref != 0 {
                            *mut_ref = val as _;
                        }
                    };
                }
                4u32 => {
                    let mut_ref = &mut self.r#max_tx_power;
                    {
                        let val = decoder.decode_int32()?;
                        let val_ref = &val;
                        if *val_ref != 0 {
                            *mut_ref = val as _;
                        }
                    };
                }
                5u32 => {
                    let mut_ref = &mut self.r#policy;
                    {
                        let val = decoder.decode_int32()?;
                        let val_ref = &val;
                        if *val_ref != 0 {
                            *mut_ref = val as _;
                        }
                    };
                }
                _ => {
                    decoder.skip_wire_value(tag.wire_type())?;
                }
            }
        }
        Ok(())
    }
}
impl ::micropb::MessageEncode for r#wifi_country {
    const MAX_SIZE: ::core::option::Option<usize> = 'msg: {
        let mut max_size = 0;
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(4usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(5usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(5usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(10usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(10usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        ::core::option::Option::Some(max_size)
    };
    fn encode<IMPL_MICROPB_WRITE: ::micropb::PbWrite>(
        &self,
        encoder: &mut ::micropb::PbEncoder<IMPL_MICROPB_WRITE>,
    ) -> Result<(), IMPL_MICROPB_WRITE::Error> {
        use ::micropb::{FieldEncode, PbMap};
        {
            let val_ref = &self.r#cc;
            if !val_ref.is_empty() {
                encoder.encode_varint32(10u32)?;
                encoder.encode_bytes(val_ref)?;
            }
        }
        {
            let val_ref = &self.r#schan;
            if *val_ref != 0 {
                encoder.encode_varint32(16u32)?;
                encoder.encode_varint32(*val_ref as _)?;
            }
        }
        {
            let val_ref = &self.r#nchan;
            if *val_ref != 0 {
                encoder.encode_varint32(24u32)?;
                encoder.encode_varint32(*val_ref as _)?;
            }
        }
        {
            let val_ref = &self.r#max_tx_power;
            if *val_ref != 0 {
                encoder.encode_varint32(32u32)?;
                encoder.encode_int32(*val_ref as _)?;
            }
        }
        {
            let val_ref = &self.r#policy;
            if *val_ref != 0 {
                encoder.encode_varint32(40u32)?;
                encoder.encode_int32(*val_ref as _)?;
            }
        }
        Ok(())
    }
    fn compute_size(&self) -> usize {
        use ::micropb::{FieldEncode, PbMap};
        let mut size = 0;
        {
            let val_ref = &self.r#cc;
            if !val_ref.is_empty() {
                size += 1usize + ::micropb::size::sizeof_len_record(val_ref.len());
            }
        }
        {
            let val_ref = &self.r#schan;
            if *val_ref != 0 {
                size += 1usize + ::micropb::size::sizeof_varint32(*val_ref as _);
            }
        }
        {
            let val_ref = &self.r#nchan;
            if *val_ref != 0 {
                size += 1usize + ::micropb::size::sizeof_varint32(*val_ref as _);
            }
        }
        {
            let val_ref = &self.r#max_tx_power;
            if *val_ref != 0 {
                size += 1usize + ::micropb::size::sizeof_int32(*val_ref as _);
            }
        }
        {
            let val_ref = &self.r#policy;
            if *val_ref != 0 {
                size += 1usize + ::micropb::size::sizeof_int32(*val_ref as _);
            }
        }
        size
    }
}
#[derive(Debug, Default, PartialEq, Clone)]
pub struct r#wifi_active_scan_time {
    pub r#min: u32,
    pub r#max: u32,
}
impl r#wifi_active_scan_time {
    ///Return a reference to `min`
    #[inline]
    pub fn r#min(&self) -> &u32 {
        &self.r#min
    }
    ///Return a mutable reference to `min`
    #[inline]
    pub fn mut_min(&mut self) -> &mut u32 {
        &mut self.r#min
    }
    ///Set the value of `min`
    #[inline]
    pub fn set_min(&mut self, value: u32) -> &mut Self {
        self.r#min = value.into();
        self
    }
    ///Builder method that sets the value of `min`. Useful for initializing the message.
    #[inline]
    pub fn init_min(mut self, value: u32) -> Self {
        self.r#min = value.into();
        self
    }
    ///Return a reference to `max`
    #[inline]
    pub fn r#max(&self) -> &u32 {
        &self.r#max
    }
    ///Return a mutable reference to `max`
    #[inline]
    pub fn mut_max(&mut self) -> &mut u32 {
        &mut self.r#max
    }
    ///Set the value of `max`
    #[inline]
    pub fn set_max(&mut self, value: u32) -> &mut Self {
        self.r#max = value.into();
        self
    }
    ///Builder method that sets the value of `max`. Useful for initializing the message.
    #[inline]
    pub fn init_max(mut self, value: u32) -> Self {
        self.r#max = value.into();
        self
    }
}
impl ::micropb::MessageDecode for r#wifi_active_scan_time {
    fn decode<IMPL_MICROPB_READ: ::micropb::PbRead>(
        &mut self,
        decoder: &mut ::micropb::PbDecoder<IMPL_MICROPB_READ>,
        len: usize,
    ) -> Result<(), ::micropb::DecodeError<IMPL_MICROPB_READ::Error>> {
        use ::micropb::{FieldDecode, PbBytes, PbMap, PbString, PbVec};
        let before = decoder.bytes_read();
        while decoder.bytes_read() - before < len {
            let tag = decoder.decode_tag()?;
            match tag.field_num() {
                0 => return Err(::micropb::DecodeError::ZeroField),
                1u32 => {
                    let mut_ref = &mut self.r#min;
                    {
                        let val = decoder.decode_varint32()?;
                        let val_ref = &val;
                        if *val_ref != 0 {
                            *mut_ref = val as _;
                        }
                    };
                }
                2u32 => {
                    let mut_ref = &mut self.r#max;
                    {
                        let val = decoder.decode_varint32()?;
                        let val_ref = &val;
                        if *val_ref != 0 {
                            *mut_ref = val as _;
                        }
                    };
                }
                _ => {
                    decoder.skip_wire_value(tag.wire_type())?;
                }
            }
        }
        Ok(())
    }
}
impl ::micropb::MessageEncode for r#wifi_active_scan_time {
    const MAX_SIZE: ::core::option::Option<usize> = 'msg: {
        let mut max_size = 0;
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(5usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(5usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        ::core::option::Option::Some(max_size)
    };
    fn encode<IMPL_MICROPB_WRITE: ::micropb::PbWrite>(
        &self,
        encoder: &mut ::micropb::PbEncoder<IMPL_MICROPB_WRITE>,
    ) -> Result<(), IMPL_MICROPB_WRITE::Error> {
        use ::micropb::{FieldEncode, PbMap};
        {
            let val_ref = &self.r#min;
            if *val_ref != 0 {
                encoder.encode_varint32(8u32)?;
                encoder.encode_varint32(*val_ref as _)?;
            }
        }
        {
            let val_ref = &self.r#max;
            if *val_ref != 0 {
                encoder.encode_varint32(16u32)?;
                encoder.encode_varint32(*val_ref as _)?;
            }
        }
        Ok(())
    }
    fn compute_size(&self) -> usize {
        use ::micropb::{FieldEncode, PbMap};
        let mut size = 0;
        {
            let val_ref = &self.r#min;
            if *val_ref != 0 {
                size += 1usize + ::micropb::size::sizeof_varint32(*val_ref as _);
            }
        }
        {
            let val_ref = &self.r#max;
            if *val_ref != 0 {
                size += 1usize + ::micropb::size::sizeof_varint32(*val_ref as _);
            }
        }
        size
    }
}
pub mod wifi_scan_time_ {
    #[derive(Debug, Default, PartialEq, Clone)]
    pub struct _Hazzer([u8; 1]);
    impl _Hazzer {
        ///New hazzer with all fields set to off
        #[inline]
        pub const fn _new() -> Self {
            Self([0; 1])
        }
        ///Query presence of `active`
        #[inline]
        pub const fn r#active(&self) -> bool {
            (self.0[0] & 1) != 0
        }
        ///Set presence of `active`
        #[inline]
        pub const fn set_active(&mut self) -> &mut Self {
            let elem = &mut self.0[0];
            *elem |= 1;
            self
        }
        ///Clear presence of `active`
        #[inline]
        pub const fn clear_active(&mut self) -> &mut Self {
            let elem = &mut self.0[0];
            *elem &= !1;
            self
        }
        ///Builder method that sets the presence of `active`. Useful for initializing the Hazzer.
        #[inline]
        pub const fn init_active(mut self) -> Self {
            self.set_active();
            self
        }
    }
}
#[derive(Debug, Default, Clone)]
pub struct r#wifi_scan_time {
    pub r#active: r#wifi_active_scan_time,
    pub r#passive: u32,
    pub _has: wifi_scan_time_::_Hazzer,
}
impl ::core::cmp::PartialEq for r#wifi_scan_time {
    fn eq(&self, other: &Self) -> bool {
        let mut ret = true;
        ret &= (self.r#active() == other.r#active());
        ret &= (self.r#passive == other.r#passive);
        ret
    }
}
impl r#wifi_scan_time {
    ///Return a reference to `active` as an `Option`
    #[inline]
    pub fn r#active(&self) -> ::core::option::Option<&r#wifi_active_scan_time> {
        self._has.r#active().then_some(&self.r#active)
    }
    ///Set the value and presence of `active`
    #[inline]
    pub fn set_active(&mut self, value: r#wifi_active_scan_time) -> &mut Self {
        self._has.set_active();
        self.r#active = value.into();
        self
    }
    ///Return a mutable reference to `active` as an `Option`
    #[inline]
    pub fn mut_active(&mut self) -> ::core::option::Option<&mut r#wifi_active_scan_time> {
        self._has.r#active().then_some(&mut self.r#active)
    }
    ///Clear the presence of `active`
    #[inline]
    pub fn clear_active(&mut self) -> &mut Self {
        self._has.clear_active();
        self
    }
    ///Take the value of `active` and clear its presence
    #[inline]
    pub fn take_active(&mut self) -> ::core::option::Option<r#wifi_active_scan_time> {
        let val = self
            ._has
            .r#active()
            .then(|| ::core::mem::take(&mut self.r#active));
        self._has.clear_active();
        val
    }
    ///Builder method that sets the value of `active`. Useful for initializing the message.
    #[inline]
    pub fn init_active(mut self, value: r#wifi_active_scan_time) -> Self {
        self.set_active(value);
        self
    }
    ///Return a reference to `passive`
    #[inline]
    pub fn r#passive(&self) -> &u32 {
        &self.r#passive
    }
    ///Return a mutable reference to `passive`
    #[inline]
    pub fn mut_passive(&mut self) -> &mut u32 {
        &mut self.r#passive
    }
    ///Set the value of `passive`
    #[inline]
    pub fn set_passive(&mut self, value: u32) -> &mut Self {
        self.r#passive = value.into();
        self
    }
    ///Builder method that sets the value of `passive`. Useful for initializing the message.
    #[inline]
    pub fn init_passive(mut self, value: u32) -> Self {
        self.r#passive = value.into();
        self
    }
}
impl ::micropb::MessageDecode for r#wifi_scan_time {
    fn decode<IMPL_MICROPB_READ: ::micropb::PbRead>(
        &mut self,
        decoder: &mut ::micropb::PbDecoder<IMPL_MICROPB_READ>,
        len: usize,
    ) -> Result<(), ::micropb::DecodeError<IMPL_MICROPB_READ::Error>> {
        use ::micropb::{FieldDecode, PbBytes, PbMap, PbString, PbVec};
        let before = decoder.bytes_read();
        while decoder.bytes_read() - before < len {
            let tag = decoder.decode_tag()?;
            match tag.field_num() {
                0 => return Err(::micropb::DecodeError::ZeroField),
                1u32 => {
                    let mut_ref = &mut self.r#active;
                    {
                        mut_ref.decode_len_delimited(decoder)?;
                    };
                    self._has.set_active();
                }
                2u32 => {
                    let mut_ref = &mut self.r#passive;
                    {
                        let val = decoder.decode_varint32()?;
                        let val_ref = &val;
                        if *val_ref != 0 {
                            *mut_ref = val as _;
                        }
                    };
                }
                _ => {
                    decoder.skip_wire_value(tag.wire_type())?;
                }
            }
        }
        Ok(())
    }
}
impl ::micropb::MessageEncode for r#wifi_scan_time {
    const MAX_SIZE: ::core::option::Option<usize> = 'msg: {
        let mut max_size = 0;
        if let ::core::option::Option::Some(size) = ::micropb::const_map!(
            ::micropb::const_map!(
                <r#wifi_active_scan_time as ::micropb::MessageEncode>::MAX_SIZE,
                |size| ::micropb::size::sizeof_len_record(size)
            ),
            |size| size + 1usize
        ) {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(5usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        ::core::option::Option::Some(max_size)
    };
    fn encode<IMPL_MICROPB_WRITE: ::micropb::PbWrite>(
        &self,
        encoder: &mut ::micropb::PbEncoder<IMPL_MICROPB_WRITE>,
    ) -> Result<(), IMPL_MICROPB_WRITE::Error> {
        use ::micropb::{FieldEncode, PbMap};
        {
            if let ::core::option::Option::Some(val_ref) = self.r#active() {
                encoder.encode_varint32(10u32)?;
                val_ref.encode_len_delimited(encoder)?;
            }
        }
        {
            let val_ref = &self.r#passive;
            if *val_ref != 0 {
                encoder.encode_varint32(16u32)?;
                encoder.encode_varint32(*val_ref as _)?;
            }
        }
        Ok(())
    }
    fn compute_size(&self) -> usize {
        use ::micropb::{FieldEncode, PbMap};
        let mut size = 0;
        {
            if let ::core::option::Option::Some(val_ref) = self.r#active() {
                size += 1usize + ::micropb::size::sizeof_len_record(val_ref.compute_size());
            }
        }
        {
            let val_ref = &self.r#passive;
            if *val_ref != 0 {
                size += 1usize + ::micropb::size::sizeof_varint32(*val_ref as _);
            }
        }
        size
    }
}
pub mod wifi_scan_config_ {
    #[derive(Debug, Default, PartialEq, Clone)]
    pub struct _Hazzer([u8; 1]);
    impl _Hazzer {
        ///New hazzer with all fields set to off
        #[inline]
        pub const fn _new() -> Self {
            Self([0; 1])
        }
        ///Query presence of `scan_time`
        #[inline]
        pub const fn r#scan_time(&self) -> bool {
            (self.0[0] & 1) != 0
        }
        ///Set presence of `scan_time`
        #[inline]
        pub const fn set_scan_time(&mut self) -> &mut Self {
            let elem = &mut self.0[0];
            *elem |= 1;
            self
        }
        ///Clear presence of `scan_time`
        #[inline]
        pub const fn clear_scan_time(&mut self) -> &mut Self {
            let elem = &mut self.0[0];
            *elem &= !1;
            self
        }
        ///Builder method that sets the presence of `scan_time`. Useful for initializing the Hazzer.
        #[inline]
        pub const fn init_scan_time(mut self) -> Self {
            self.set_scan_time();
            self
        }
    }
}
#[derive(Debug, Default, Clone)]
pub struct r#wifi_scan_config {
    pub r#ssid: ::micropb::heapless::Vec<u8, 33>,
    pub r#bssid: ::micropb::heapless::Vec<u8, 6>,
    pub r#channel: u32,
    pub r#show_hidden: bool,
    pub r#scan_type: i32,
    pub r#scan_time: r#wifi_scan_time,
    pub r#home_chan_dwell_time: u32,
    pub _has: wifi_scan_config_::_Hazzer,
}
impl ::core::cmp::PartialEq for r#wifi_scan_config {
    fn eq(&self, other: &Self) -> bool {
        let mut ret = true;
        ret &= (self.r#ssid == other.r#ssid);
        ret &= (self.r#bssid == other.r#bssid);
        ret &= (self.r#channel == other.r#channel);
        ret &= (self.r#show_hidden == other.r#show_hidden);
        ret &= (self.r#scan_type == other.r#scan_type);
        ret &= (self.r#scan_time() == other.r#scan_time());
        ret &= (self.r#home_chan_dwell_time == other.r#home_chan_dwell_time);
        ret
    }
}
impl r#wifi_scan_config {
    ///Return a reference to `ssid`
    #[inline]
    pub fn r#ssid(&self) -> &::micropb::heapless::Vec<u8, 33> {
        &self.r#ssid
    }
    ///Return a mutable reference to `ssid`
    #[inline]
    pub fn mut_ssid(&mut self) -> &mut ::micropb::heapless::Vec<u8, 33> {
        &mut self.r#ssid
    }
    ///Set the value of `ssid`
    #[inline]
    pub fn set_ssid(&mut self, value: ::micropb::heapless::Vec<u8, 33>) -> &mut Self {
        self.r#ssid = value.into();
        self
    }
    ///Builder method that sets the value of `ssid`. Useful for initializing the message.
    #[inline]
    pub fn init_ssid(mut self, value: ::micropb::heapless::Vec<u8, 33>) -> Self {
        self.r#ssid = value.into();
        self
    }
    ///Return a reference to `bssid`
    #[inline]
    pub fn r#bssid(&self) -> &::micropb::heapless::Vec<u8, 6> {
        &self.r#bssid
    }
    ///Return a mutable reference to `bssid`
    #[inline]
    pub fn mut_bssid(&mut self) -> &mut ::micropb::heapless::Vec<u8, 6> {
        &mut self.r#bssid
    }
    ///Set the value of `bssid`
    #[inline]
    pub fn set_bssid(&mut self, value: ::micropb::heapless::Vec<u8, 6>) -> &mut Self {
        self.r#bssid = value.into();
        self
    }
    ///Builder method that sets the value of `bssid`. Useful for initializing the message.
    #[inline]
    pub fn init_bssid(mut self, value: ::micropb::heapless::Vec<u8, 6>) -> Self {
        self.r#bssid = value.into();
        self
    }
    ///Return a reference to `channel`
    #[inline]
    pub fn r#channel(&self) -> &u32 {
        &self.r#channel
    }
    ///Return a mutable reference to `channel`
    #[inline]
    pub fn mut_channel(&mut self) -> &mut u32 {
        &mut self.r#channel
    }
    ///Set the value of `channel`
    #[inline]
    pub fn set_channel(&mut self, value: u32) -> &mut Self {
        self.r#channel = value.into();
        self
    }
    ///Builder method that sets the value of `channel`. Useful for initializing the message.
    #[inline]
    pub fn init_channel(mut self, value: u32) -> Self {
        self.r#channel = value.into();
        self
    }
    ///Return a reference to `show_hidden`
    #[inline]
    pub fn r#show_hidden(&self) -> &bool {
        &self.r#show_hidden
    }
    ///Return a mutable reference to `show_hidden`
    #[inline]
    pub fn mut_show_hidden(&mut self) -> &mut bool {
        &mut self.r#show_hidden
    }
    ///Set the value of `show_hidden`
    #[inline]
    pub fn set_show_hidden(&mut self, value: bool) -> &mut Self {
        self.r#show_hidden = value.into();
        self
    }
    ///Builder method that sets the value of `show_hidden`. Useful for initializing the message.
    #[inline]
    pub fn init_show_hidden(mut self, value: bool) -> Self {
        self.r#show_hidden = value.into();
        self
    }
    ///Return a reference to `scan_type`
    #[inline]
    pub fn r#scan_type(&self) -> &i32 {
        &self.r#scan_type
    }
    ///Return a mutable reference to `scan_type`
    #[inline]
    pub fn mut_scan_type(&mut self) -> &mut i32 {
        &mut self.r#scan_type
    }
    ///Set the value of `scan_type`
    #[inline]
    pub fn set_scan_type(&mut self, value: i32) -> &mut Self {
        self.r#scan_type = value.into();
        self
    }
    ///Builder method that sets the value of `scan_type`. Useful for initializing the message.
    #[inline]
    pub fn init_scan_type(mut self, value: i32) -> Self {
        self.r#scan_type = value.into();
        self
    }
    ///Return a reference to `scan_time` as an `Option`
    #[inline]
    pub fn r#scan_time(&self) -> ::core::option::Option<&r#wifi_scan_time> {
        self._has.r#scan_time().then_some(&self.r#scan_time)
    }
    ///Set the value and presence of `scan_time`
    #[inline]
    pub fn set_scan_time(&mut self, value: r#wifi_scan_time) -> &mut Self {
        self._has.set_scan_time();
        self.r#scan_time = value.into();
        self
    }
    ///Return a mutable reference to `scan_time` as an `Option`
    #[inline]
    pub fn mut_scan_time(&mut self) -> ::core::option::Option<&mut r#wifi_scan_time> {
        self._has.r#scan_time().then_some(&mut self.r#scan_time)
    }
    ///Clear the presence of `scan_time`
    #[inline]
    pub fn clear_scan_time(&mut self) -> &mut Self {
        self._has.clear_scan_time();
        self
    }
    ///Take the value of `scan_time` and clear its presence
    #[inline]
    pub fn take_scan_time(&mut self) -> ::core::option::Option<r#wifi_scan_time> {
        let val = self
            ._has
            .r#scan_time()
            .then(|| ::core::mem::take(&mut self.r#scan_time));
        self._has.clear_scan_time();
        val
    }
    ///Builder method that sets the value of `scan_time`. Useful for initializing the message.
    #[inline]
    pub fn init_scan_time(mut self, value: r#wifi_scan_time) -> Self {
        self.set_scan_time(value);
        self
    }
    ///Return a reference to `home_chan_dwell_time`
    #[inline]
    pub fn r#home_chan_dwell_time(&self) -> &u32 {
        &self.r#home_chan_dwell_time
    }
    ///Return a mutable reference to `home_chan_dwell_time`
    #[inline]
    pub fn mut_home_chan_dwell_time(&mut self) -> &mut u32 {
        &mut self.r#home_chan_dwell_time
    }
    ///Set the value of `home_chan_dwell_time`
    #[inline]
    pub fn set_home_chan_dwell_time(&mut self, value: u32) -> &mut Self {
        self.r#home_chan_dwell_time = value.into();
        self
    }
    ///Builder method that sets the value of `home_chan_dwell_time`. Useful for initializing the message.
    #[inline]
    pub fn init_home_chan_dwell_time(mut self, value: u32) -> Self {
        self.r#home_chan_dwell_time = value.into();
        self
    }
}
impl ::micropb::MessageDecode for r#wifi_scan_config {
    fn decode<IMPL_MICROPB_READ: ::micropb::PbRead>(
        &mut self,
        decoder: &mut ::micropb::PbDecoder<IMPL_MICROPB_READ>,
        len: usize,
    ) -> Result<(), ::micropb::DecodeError<IMPL_MICROPB_READ::Error>> {
        use ::micropb::{FieldDecode, PbBytes, PbMap, PbString, PbVec};
        let before = decoder.bytes_read();
        while decoder.bytes_read() - before < len {
            let tag = decoder.decode_tag()?;
            match tag.field_num() {
                0 => return Err(::micropb::DecodeError::ZeroField),
                1u32 => {
                    let mut_ref = &mut self.r#ssid;
                    {
                        decoder.decode_bytes(mut_ref, ::micropb::Presence::Implicit)?;
                    };
                }
                2u32 => {
                    let mut_ref = &mut self.r#bssid;
                    {
                        decoder.decode_bytes(mut_ref, ::micropb::Presence::Implicit)?;
                    };
                }
                3u32 => {
                    let mut_ref = &mut self.r#channel;
                    {
                        let val = decoder.decode_varint32()?;
                        let val_ref = &val;
                        if *val_ref != 0 {
                            *mut_ref = val as _;
                        }
                    };
                }
                4u32 => {
                    let mut_ref = &mut self.r#show_hidden;
                    {
                        let val = decoder.decode_bool()?;
                        let val_ref = &val;
                        if *val_ref {
                            *mut_ref = val as _;
                        }
                    };
                }
                5u32 => {
                    let mut_ref = &mut self.r#scan_type;
                    {
                        let val = decoder.decode_int32()?;
                        let val_ref = &val;
                        if *val_ref != 0 {
                            *mut_ref = val as _;
                        }
                    };
                }
                6u32 => {
                    let mut_ref = &mut self.r#scan_time;
                    {
                        mut_ref.decode_len_delimited(decoder)?;
                    };
                    self._has.set_scan_time();
                }
                7u32 => {
                    let mut_ref = &mut self.r#home_chan_dwell_time;
                    {
                        let val = decoder.decode_varint32()?;
                        let val_ref = &val;
                        if *val_ref != 0 {
                            *mut_ref = val as _;
                        }
                    };
                }
                _ => {
                    decoder.skip_wire_value(tag.wire_type())?;
                }
            }
        }
        Ok(())
    }
}
impl ::micropb::MessageEncode for r#wifi_scan_config {
    const MAX_SIZE: ::core::option::Option<usize> = 'msg: {
        let mut max_size = 0;
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(34usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(7usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(5usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(1usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(10usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        if let ::core::option::Option::Some(size) = ::micropb::const_map!(
            ::micropb::const_map!(
                <r#wifi_scan_time as ::micropb::MessageEncode>::MAX_SIZE,
                |size| ::micropb::size::sizeof_len_record(size)
            ),
            |size| size + 1usize
        ) {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(5usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        ::core::option::Option::Some(max_size)
    };
    fn encode<IMPL_MICROPB_WRITE: ::micropb::PbWrite>(
        &self,
        encoder: &mut ::micropb::PbEncoder<IMPL_MICROPB_WRITE>,
    ) -> Result<(), IMPL_MICROPB_WRITE::Error> {
        use ::micropb::{FieldEncode, PbMap};
        {
            let val_ref = &self.r#ssid;
            if !val_ref.is_empty() {
                encoder.encode_varint32(10u32)?;
                encoder.encode_bytes(val_ref)?;
            }
        }
        {
            let val_ref = &self.r#bssid;
            if !val_ref.is_empty() {
                encoder.encode_varint32(18u32)?;
                encoder.encode_bytes(val_ref)?;
            }
        }
        {
            let val_ref = &self.r#channel;
            if *val_ref != 0 {
                encoder.encode_varint32(24u32)?;
                encoder.encode_varint32(*val_ref as _)?;
            }
        }
        {
            let val_ref = &self.r#show_hidden;
            if *val_ref {
                encoder.encode_varint32(32u32)?;
                encoder.encode_bool(*val_ref)?;
            }
        }
        {
            let val_ref = &self.r#scan_type;
            if *val_ref != 0 {
                encoder.encode_varint32(40u32)?;
                encoder.encode_int32(*val_ref as _)?;
            }
        }
        {
            if let ::core::option::Option::Some(val_ref) = self.r#scan_time() {
                encoder.encode_varint32(50u32)?;
                val_ref.encode_len_delimited(encoder)?;
            }
        }
        {
            let val_ref = &self.r#home_chan_dwell_time;
            if *val_ref != 0 {
                encoder.encode_varint32(56u32)?;
                encoder.encode_varint32(*val_ref as _)?;
            }
        }
        Ok(())
    }
    fn compute_size(&self) -> usize {
        use ::micropb::{FieldEncode, PbMap};
        let mut size = 0;
        {
            let val_ref = &self.r#ssid;
            if !val_ref.is_empty() {
                size += 1usize + ::micropb::size::sizeof_len_record(val_ref.len());
            }
        }
        {
            let val_ref = &self.r#bssid;
            if !val_ref.is_empty() {
                size += 1usize + ::micropb::size::sizeof_len_record(val_ref.len());
            }
        }
        {
            let val_ref = &self.r#channel;
            if *val_ref != 0 {
                size += 1usize + ::micropb::size::sizeof_varint32(*val_ref as _);
            }
        }
        {
            let val_ref = &self.r#show_hidden;
            if *val_ref {
                size += 1usize + 1;
            }
        }
        {
            let val_ref = &self.r#scan_type;
            if *val_ref != 0 {
                size += 1usize + ::micropb::size::sizeof_int32(*val_ref as _);
            }
        }
        {
            if let ::core::option::Option::Some(val_ref) = self.r#scan_time() {
                size += 1usize + ::micropb::size::sizeof_len_record(val_ref.compute_size());
            }
        }
        {
            let val_ref = &self.r#home_chan_dwell_time;
            if *val_ref != 0 {
                size += 1usize + ::micropb::size::sizeof_varint32(*val_ref as _);
            }
        }
        size
    }
}
#[derive(Debug, Default, PartialEq, Clone)]
pub struct r#wifi_he_ap_info {
    pub r#bitmask: u32,
    pub r#bssid_index: u32,
}
impl r#wifi_he_ap_info {
    ///Return a reference to `bitmask`
    #[inline]
    pub fn r#bitmask(&self) -> &u32 {
        &self.r#bitmask
    }
    ///Return a mutable reference to `bitmask`
    #[inline]
    pub fn mut_bitmask(&mut self) -> &mut u32 {
        &mut self.r#bitmask
    }
    ///Set the value of `bitmask`
    #[inline]
    pub fn set_bitmask(&mut self, value: u32) -> &mut Self {
        self.r#bitmask = value.into();
        self
    }
    ///Builder method that sets the value of `bitmask`. Useful for initializing the message.
    #[inline]
    pub fn init_bitmask(mut self, value: u32) -> Self {
        self.r#bitmask = value.into();
        self
    }
    ///Return a reference to `bssid_index`
    #[inline]
    pub fn r#bssid_index(&self) -> &u32 {
        &self.r#bssid_index
    }
    ///Return a mutable reference to `bssid_index`
    #[inline]
    pub fn mut_bssid_index(&mut self) -> &mut u32 {
        &mut self.r#bssid_index
    }
    ///Set the value of `bssid_index`
    #[inline]
    pub fn set_bssid_index(&mut self, value: u32) -> &mut Self {
        self.r#bssid_index = value.into();
        self
    }
    ///Builder method that sets the value of `bssid_index`. Useful for initializing the message.
    #[inline]
    pub fn init_bssid_index(mut self, value: u32) -> Self {
        self.r#bssid_index = value.into();
        self
    }
}
impl ::micropb::MessageDecode for r#wifi_he_ap_info {
    fn decode<IMPL_MICROPB_READ: ::micropb::PbRead>(
        &mut self,
        decoder: &mut ::micropb::PbDecoder<IMPL_MICROPB_READ>,
        len: usize,
    ) -> Result<(), ::micropb::DecodeError<IMPL_MICROPB_READ::Error>> {
        use ::micropb::{FieldDecode, PbBytes, PbMap, PbString, PbVec};
        let before = decoder.bytes_read();
        while decoder.bytes_read() - before < len {
            let tag = decoder.decode_tag()?;
            match tag.field_num() {
                0 => return Err(::micropb::DecodeError::ZeroField),
                1u32 => {
                    let mut_ref = &mut self.r#bitmask;
                    {
                        let val = decoder.decode_varint32()?;
                        let val_ref = &val;
                        if *val_ref != 0 {
                            *mut_ref = val as _;
                        }
                    };
                }
                2u32 => {
                    let mut_ref = &mut self.r#bssid_index;
                    {
                        let val = decoder.decode_varint32()?;
                        let val_ref = &val;
                        if *val_ref != 0 {
                            *mut_ref = val as _;
                        }
                    };
                }
                _ => {
                    decoder.skip_wire_value(tag.wire_type())?;
                }
            }
        }
        Ok(())
    }
}
impl ::micropb::MessageEncode for r#wifi_he_ap_info {
    const MAX_SIZE: ::core::option::Option<usize> = 'msg: {
        let mut max_size = 0;
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(5usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(5usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        ::core::option::Option::Some(max_size)
    };
    fn encode<IMPL_MICROPB_WRITE: ::micropb::PbWrite>(
        &self,
        encoder: &mut ::micropb::PbEncoder<IMPL_MICROPB_WRITE>,
    ) -> Result<(), IMPL_MICROPB_WRITE::Error> {
        use ::micropb::{FieldEncode, PbMap};
        {
            let val_ref = &self.r#bitmask;
            if *val_ref != 0 {
                encoder.encode_varint32(8u32)?;
                encoder.encode_varint32(*val_ref as _)?;
            }
        }
        {
            let val_ref = &self.r#bssid_index;
            if *val_ref != 0 {
                encoder.encode_varint32(16u32)?;
                encoder.encode_varint32(*val_ref as _)?;
            }
        }
        Ok(())
    }
    fn compute_size(&self) -> usize {
        use ::micropb::{FieldEncode, PbMap};
        let mut size = 0;
        {
            let val_ref = &self.r#bitmask;
            if *val_ref != 0 {
                size += 1usize + ::micropb::size::sizeof_varint32(*val_ref as _);
            }
        }
        {
            let val_ref = &self.r#bssid_index;
            if *val_ref != 0 {
                size += 1usize + ::micropb::size::sizeof_varint32(*val_ref as _);
            }
        }
        size
    }
}
pub mod wifi_ap_record_ {
    #[derive(Debug, Default, PartialEq, Clone)]
    pub struct _Hazzer([u8; 1]);
    impl _Hazzer {
        ///New hazzer with all fields set to off
        #[inline]
        pub const fn _new() -> Self {
            Self([0; 1])
        }
        ///Query presence of `country`
        #[inline]
        pub const fn r#country(&self) -> bool {
            (self.0[0] & 1) != 0
        }
        ///Set presence of `country`
        #[inline]
        pub const fn set_country(&mut self) -> &mut Self {
            let elem = &mut self.0[0];
            *elem |= 1;
            self
        }
        ///Clear presence of `country`
        #[inline]
        pub const fn clear_country(&mut self) -> &mut Self {
            let elem = &mut self.0[0];
            *elem &= !1;
            self
        }
        ///Builder method that sets the presence of `country`. Useful for initializing the Hazzer.
        #[inline]
        pub const fn init_country(mut self) -> Self {
            self.set_country();
            self
        }
        ///Query presence of `he_ap`
        #[inline]
        pub const fn r#he_ap(&self) -> bool {
            (self.0[0] & 2) != 0
        }
        ///Set presence of `he_ap`
        #[inline]
        pub const fn set_he_ap(&mut self) -> &mut Self {
            let elem = &mut self.0[0];
            *elem |= 2;
            self
        }
        ///Clear presence of `he_ap`
        #[inline]
        pub const fn clear_he_ap(&mut self) -> &mut Self {
            let elem = &mut self.0[0];
            *elem &= !2;
            self
        }
        ///Builder method that sets the presence of `he_ap`. Useful for initializing the Hazzer.
        #[inline]
        pub const fn init_he_ap(mut self) -> Self {
            self.set_he_ap();
            self
        }
    }
}
#[derive(Debug, Default, Clone)]
pub struct r#wifi_ap_record {
    pub r#bssid: ::micropb::heapless::Vec<u8, 6>,
    pub r#ssid: ::micropb::heapless::Vec<u8, 33>,
    pub r#primary: u32,
    pub r#second: i32,
    pub r#rssi: i32,
    pub r#authmode: i32,
    pub r#pairwise_cipher: i32,
    pub r#group_cipher: i32,
    pub r#ant: i32,
    pub r#bitmask: u32,
    pub r#country: r#wifi_country,
    pub r#he_ap: r#wifi_he_ap_info,
    pub r#bandwidth: u32,
    pub r#vht_ch_freq1: u32,
    pub r#vht_ch_freq2: u32,
    pub _has: wifi_ap_record_::_Hazzer,
}
impl ::core::cmp::PartialEq for r#wifi_ap_record {
    fn eq(&self, other: &Self) -> bool {
        let mut ret = true;
        ret &= (self.r#bssid == other.r#bssid);
        ret &= (self.r#ssid == other.r#ssid);
        ret &= (self.r#primary == other.r#primary);
        ret &= (self.r#second == other.r#second);
        ret &= (self.r#rssi == other.r#rssi);
        ret &= (self.r#authmode == other.r#authmode);
        ret &= (self.r#pairwise_cipher == other.r#pairwise_cipher);
        ret &= (self.r#group_cipher == other.r#group_cipher);
        ret &= (self.r#ant == other.r#ant);
        ret &= (self.r#bitmask == other.r#bitmask);
        ret &= (self.r#country() == other.r#country());
        ret &= (self.r#he_ap() == other.r#he_ap());
        ret &= (self.r#bandwidth == other.r#bandwidth);
        ret &= (self.r#vht_ch_freq1 == other.r#vht_ch_freq1);
        ret &= (self.r#vht_ch_freq2 == other.r#vht_ch_freq2);
        ret
    }
}
impl r#wifi_ap_record {
    ///Return a reference to `bssid`
    #[inline]
    pub fn r#bssid(&self) -> &::micropb::heapless::Vec<u8, 6> {
        &self.r#bssid
    }
    ///Return a mutable reference to `bssid`
    #[inline]
    pub fn mut_bssid(&mut self) -> &mut ::micropb::heapless::Vec<u8, 6> {
        &mut self.r#bssid
    }
    ///Set the value of `bssid`
    #[inline]
    pub fn set_bssid(&mut self, value: ::micropb::heapless::Vec<u8, 6>) -> &mut Self {
        self.r#bssid = value.into();
        self
    }
    ///Builder method that sets the value of `bssid`. Useful for initializing the message.
    #[inline]
    pub fn init_bssid(mut self, value: ::micropb::heapless::Vec<u8, 6>) -> Self {
        self.r#bssid = value.into();
        self
    }
    ///Return a reference to `ssid`
    #[inline]
    pub fn r#ssid(&self) -> &::micropb::heapless::Vec<u8, 33> {
        &self.r#ssid
    }
    ///Return a mutable reference to `ssid`
    #[inline]
    pub fn mut_ssid(&mut self) -> &mut ::micropb::heapless::Vec<u8, 33> {
        &mut self.r#ssid
    }
    ///Set the value of `ssid`
    #[inline]
    pub fn set_ssid(&mut self, value: ::micropb::heapless::Vec<u8, 33>) -> &mut Self {
        self.r#ssid = value.into();
        self
    }
    ///Builder method that sets the value of `ssid`. Useful for initializing the message.
    #[inline]
    pub fn init_ssid(mut self, value: ::micropb::heapless::Vec<u8, 33>) -> Self {
        self.r#ssid = value.into();
        self
    }
    ///Return a reference to `primary`
    #[inline]
    pub fn r#primary(&self) -> &u32 {
        &self.r#primary
    }
    ///Return a mutable reference to `primary`
    #[inline]
    pub fn mut_primary(&mut self) -> &mut u32 {
        &mut self.r#primary
    }
    ///Set the value of `primary`
    #[inline]
    pub fn set_primary(&mut self, value: u32) -> &mut Self {
        self.r#primary = value.into();
        self
    }
    ///Builder method that sets the value of `primary`. Useful for initializing the message.
    #[inline]
    pub fn init_primary(mut self, value: u32) -> Self {
        self.r#primary = value.into();
        self
    }
    ///Return a reference to `second`
    #[inline]
    pub fn r#second(&self) -> &i32 {
        &self.r#second
    }
    ///Return a mutable reference to `second`
    #[inline]
    pub fn mut_second(&mut self) -> &mut i32 {
        &mut self.r#second
    }
    ///Set the value of `second`
    #[inline]
    pub fn set_second(&mut self, value: i32) -> &mut Self {
        self.r#second = value.into();
        self
    }
    ///Builder method that sets the value of `second`. Useful for initializing the message.
    #[inline]
    pub fn init_second(mut self, value: i32) -> Self {
        self.r#second = value.into();
        self
    }
    ///Return a reference to `rssi`
    #[inline]
    pub fn r#rssi(&self) -> &i32 {
        &self.r#rssi
    }
    ///Return a mutable reference to `rssi`
    #[inline]
    pub fn mut_rssi(&mut self) -> &mut i32 {
        &mut self.r#rssi
    }
    ///Set the value of `rssi`
    #[inline]
    pub fn set_rssi(&mut self, value: i32) -> &mut Self {
        self.r#rssi = value.into();
        self
    }
    ///Builder method that sets the value of `rssi`. Useful for initializing the message.
    #[inline]
    pub fn init_rssi(mut self, value: i32) -> Self {
        self.r#rssi = value.into();
        self
    }
    ///Return a reference to `authmode`
    #[inline]
    pub fn r#authmode(&self) -> &i32 {
        &self.r#authmode
    }
    ///Return a mutable reference to `authmode`
    #[inline]
    pub fn mut_authmode(&mut self) -> &mut i32 {
        &mut self.r#authmode
    }
    ///Set the value of `authmode`
    #[inline]
    pub fn set_authmode(&mut self, value: i32) -> &mut Self {
        self.r#authmode = value.into();
        self
    }
    ///Builder method that sets the value of `authmode`. Useful for initializing the message.
    #[inline]
    pub fn init_authmode(mut self, value: i32) -> Self {
        self.r#authmode = value.into();
        self
    }
    ///Return a reference to `pairwise_cipher`
    #[inline]
    pub fn r#pairwise_cipher(&self) -> &i32 {
        &self.r#pairwise_cipher
    }
    ///Return a mutable reference to `pairwise_cipher`
    #[inline]
    pub fn mut_pairwise_cipher(&mut self) -> &mut i32 {
        &mut self.r#pairwise_cipher
    }
    ///Set the value of `pairwise_cipher`
    #[inline]
    pub fn set_pairwise_cipher(&mut self, value: i32) -> &mut Self {
        self.r#pairwise_cipher = value.into();
        self
    }
    ///Builder method that sets the value of `pairwise_cipher`. Useful for initializing the message.
    #[inline]
    pub fn init_pairwise_cipher(mut self, value: i32) -> Self {
        self.r#pairwise_cipher = value.into();
        self
    }
    ///Return a reference to `group_cipher`
    #[inline]
    pub fn r#group_cipher(&self) -> &i32 {
        &self.r#group_cipher
    }
    ///Return a mutable reference to `group_cipher`
    #[inline]
    pub fn mut_group_cipher(&mut self) -> &mut i32 {
        &mut self.r#group_cipher
    }
    ///Set the value of `group_cipher`
    #[inline]
    pub fn set_group_cipher(&mut self, value: i32) -> &mut Self {
        self.r#group_cipher = value.into();
        self
    }
    ///Builder method that sets the value of `group_cipher`. Useful for initializing the message.
    #[inline]
    pub fn init_group_cipher(mut self, value: i32) -> Self {
        self.r#group_cipher = value.into();
        self
    }
    ///Return a reference to `ant`
    #[inline]
    pub fn r#ant(&self) -> &i32 {
        &self.r#ant
    }
    ///Return a mutable reference to `ant`
    #[inline]
    pub fn mut_ant(&mut self) -> &mut i32 {
        &mut self.r#ant
    }
    ///Set the value of `ant`
    #[inline]
    pub fn set_ant(&mut self, value: i32) -> &mut Self {
        self.r#ant = value.into();
        self
    }
    ///Builder method that sets the value of `ant`. Useful for initializing the message.
    #[inline]
    pub fn init_ant(mut self, value: i32) -> Self {
        self.r#ant = value.into();
        self
    }
    ///Return a reference to `bitmask`
    #[inline]
    pub fn r#bitmask(&self) -> &u32 {
        &self.r#bitmask
    }
    ///Return a mutable reference to `bitmask`
    #[inline]
    pub fn mut_bitmask(&mut self) -> &mut u32 {
        &mut self.r#bitmask
    }
    ///Set the value of `bitmask`
    #[inline]
    pub fn set_bitmask(&mut self, value: u32) -> &mut Self {
        self.r#bitmask = value.into();
        self
    }
    ///Builder method that sets the value of `bitmask`. Useful for initializing the message.
    #[inline]
    pub fn init_bitmask(mut self, value: u32) -> Self {
        self.r#bitmask = value.into();
        self
    }
    ///Return a reference to `country` as an `Option`
    #[inline]
    pub fn r#country(&self) -> ::core::option::Option<&r#wifi_country> {
        self._has.r#country().then_some(&self.r#country)
    }
    ///Set the value and presence of `country`
    #[inline]
    pub fn set_country(&mut self, value: r#wifi_country) -> &mut Self {
        self._has.set_country();
        self.r#country = value.into();
        self
    }
    ///Return a mutable reference to `country` as an `Option`
    #[inline]
    pub fn mut_country(&mut self) -> ::core::option::Option<&mut r#wifi_country> {
        self._has.r#country().then_some(&mut self.r#country)
    }
    ///Clear the presence of `country`
    #[inline]
    pub fn clear_country(&mut self) -> &mut Self {
        self._has.clear_country();
        self
    }
    ///Take the value of `country` and clear its presence
    #[inline]
    pub fn take_country(&mut self) -> ::core::option::Option<r#wifi_country> {
        let val = self
            ._has
            .r#country()
            .then(|| ::core::mem::take(&mut self.r#country));
        self._has.clear_country();
        val
    }
    ///Builder method that sets the value of `country`. Useful for initializing the message.
    #[inline]
    pub fn init_country(mut self, value: r#wifi_country) -> Self {
        self.set_country(value);
        self
    }
    ///Return a reference to `he_ap` as an `Option`
    #[inline]
    pub fn r#he_ap(&self) -> ::core::option::Option<&r#wifi_he_ap_info> {
        self._has.r#he_ap().then_some(&self.r#he_ap)
    }
    ///Set the value and presence of `he_ap`
    #[inline]
    pub fn set_he_ap(&mut self, value: r#wifi_he_ap_info) -> &mut Self {
        self._has.set_he_ap();
        self.r#he_ap = value.into();
        self
    }
    ///Return a mutable reference to `he_ap` as an `Option`
    #[inline]
    pub fn mut_he_ap(&mut self) -> ::core::option::Option<&mut r#wifi_he_ap_info> {
        self._has.r#he_ap().then_some(&mut self.r#he_ap)
    }
    ///Clear the presence of `he_ap`
    #[inline]
    pub fn clear_he_ap(&mut self) -> &mut Self {
        self._has.clear_he_ap();
        self
    }
    ///Take the value of `he_ap` and clear its presence
    #[inline]
    pub fn take_he_ap(&mut self) -> ::core::option::Option<r#wifi_he_ap_info> {
        let val = self
            ._has
            .r#he_ap()
            .then(|| ::core::mem::take(&mut self.r#he_ap));
        self._has.clear_he_ap();
        val
    }
    ///Builder method that sets the value of `he_ap`. Useful for initializing the message.
    #[inline]
    pub fn init_he_ap(mut self, value: r#wifi_he_ap_info) -> Self {
        self.set_he_ap(value);
        self
    }
    ///Return a reference to `bandwidth`
    #[inline]
    pub fn r#bandwidth(&self) -> &u32 {
        &self.r#bandwidth
    }
    ///Return a mutable reference to `bandwidth`
    #[inline]
    pub fn mut_bandwidth(&mut self) -> &mut u32 {
        &mut self.r#bandwidth
    }
    ///Set the value of `bandwidth`
    #[inline]
    pub fn set_bandwidth(&mut self, value: u32) -> &mut Self {
        self.r#bandwidth = value.into();
        self
    }
    ///Builder method that sets the value of `bandwidth`. Useful for initializing the message.
    #[inline]
    pub fn init_bandwidth(mut self, value: u32) -> Self {
        self.r#bandwidth = value.into();
        self
    }
    ///Return a reference to `vht_ch_freq1`
    #[inline]
    pub fn r#vht_ch_freq1(&self) -> &u32 {
        &self.r#vht_ch_freq1
    }
    ///Return a mutable reference to `vht_ch_freq1`
    #[inline]
    pub fn mut_vht_ch_freq1(&mut self) -> &mut u32 {
        &mut self.r#vht_ch_freq1
    }
    ///Set the value of `vht_ch_freq1`
    #[inline]
    pub fn set_vht_ch_freq1(&mut self, value: u32) -> &mut Self {
        self.r#vht_ch_freq1 = value.into();
        self
    }
    ///Builder method that sets the value of `vht_ch_freq1`. Useful for initializing the message.
    #[inline]
    pub fn init_vht_ch_freq1(mut self, value: u32) -> Self {
        self.r#vht_ch_freq1 = value.into();
        self
    }
    ///Return a reference to `vht_ch_freq2`
    #[inline]
    pub fn r#vht_ch_freq2(&self) -> &u32 {
        &self.r#vht_ch_freq2
    }
    ///Return a mutable reference to `vht_ch_freq2`
    #[inline]
    pub fn mut_vht_ch_freq2(&mut self) -> &mut u32 {
        &mut self.r#vht_ch_freq2
    }
    ///Set the value of `vht_ch_freq2`
    #[inline]
    pub fn set_vht_ch_freq2(&mut self, value: u32) -> &mut Self {
        self.r#vht_ch_freq2 = value.into();
        self
    }
    ///Builder method that sets the value of `vht_ch_freq2`. Useful for initializing the message.
    #[inline]
    pub fn init_vht_ch_freq2(mut self, value: u32) -> Self {
        self.r#vht_ch_freq2 = value.into();
        self
    }
}
impl ::micropb::MessageDecode for r#wifi_ap_record {
    fn decode<IMPL_MICROPB_READ: ::micropb::PbRead>(
        &mut self,
        decoder: &mut ::micropb::PbDecoder<IMPL_MICROPB_READ>,
        len: usize,
    ) -> Result<(), ::micropb::DecodeError<IMPL_MICROPB_READ::Error>> {
        use ::micropb::{FieldDecode, PbBytes, PbMap, PbString, PbVec};
        let before = decoder.bytes_read();
        while decoder.bytes_read() - before < len {
            let tag = decoder.decode_tag()?;
            match tag.field_num() {
                0 => return Err(::micropb::DecodeError::ZeroField),
                1u32 => {
                    let mut_ref = &mut self.r#bssid;
                    {
                        decoder.decode_bytes(mut_ref, ::micropb::Presence::Implicit)?;
                    };
                }
                2u32 => {
                    let mut_ref = &mut self.r#ssid;
                    {
                        decoder.decode_bytes(mut_ref, ::micropb::Presence::Implicit)?;
                    };
                }
                3u32 => {
                    let mut_ref = &mut self.r#primary;
                    {
                        let val = decoder.decode_varint32()?;
                        let val_ref = &val;
                        if *val_ref != 0 {
                            *mut_ref = val as _;
                        }
                    };
                }
                4u32 => {
                    let mut_ref = &mut self.r#second;
                    {
                        let val = decoder.decode_int32()?;
                        let val_ref = &val;
                        if *val_ref != 0 {
                            *mut_ref = val as _;
                        }
                    };
                }
                5u32 => {
                    let mut_ref = &mut self.r#rssi;
                    {
                        let val = decoder.decode_int32()?;
                        let val_ref = &val;
                        if *val_ref != 0 {
                            *mut_ref = val as _;
                        }
                    };
                }
                6u32 => {
                    let mut_ref = &mut self.r#authmode;
                    {
                        let val = decoder.decode_int32()?;
                        let val_ref = &val;
                        if *val_ref != 0 {
                            *mut_ref = val as _;
                        }
                    };
                }
                7u32 => {
                    let mut_ref = &mut self.r#pairwise_cipher;
                    {
                        let val = decoder.decode_int32()?;
                        let val_ref = &val;
                        if *val_ref != 0 {
                            *mut_ref = val as _;
                        }
                    };
                }
                8u32 => {
                    let mut_ref = &mut self.r#group_cipher;
                    {
                        let val = decoder.decode_int32()?;
                        let val_ref = &val;
                        if *val_ref != 0 {
                            *mut_ref = val as _;
                        }
                    };
                }
                9u32 => {
                    let mut_ref = &mut self.r#ant;
                    {
                        let val = decoder.decode_int32()?;
                        let val_ref = &val;
                        if *val_ref != 0 {
                            *mut_ref = val as _;
                        }
                    };
                }
                10u32 => {
                    let mut_ref = &mut self.r#bitmask;
                    {
                        let val = decoder.decode_varint32()?;
                        let val_ref = &val;
                        if *val_ref != 0 {
                            *mut_ref = val as _;
                        }
                    };
                }
                11u32 => {
                    let mut_ref = &mut self.r#country;
                    {
                        mut_ref.decode_len_delimited(decoder)?;
                    };
                    self._has.set_country();
                }
                12u32 => {
                    let mut_ref = &mut self.r#he_ap;
                    {
                        mut_ref.decode_len_delimited(decoder)?;
                    };
                    self._has.set_he_ap();
                }
                13u32 => {
                    let mut_ref = &mut self.r#bandwidth;
                    {
                        let val = decoder.decode_varint32()?;
                        let val_ref = &val;
                        if *val_ref != 0 {
                            *mut_ref = val as _;
                        }
                    };
                }
                14u32 => {
                    let mut_ref = &mut self.r#vht_ch_freq1;
                    {
                        let val = decoder.decode_varint32()?;
                        let val_ref = &val;
                        if *val_ref != 0 {
                            *mut_ref = val as _;
                        }
                    };
                }
                15u32 => {
                    let mut_ref = &mut self.r#vht_ch_freq2;
                    {
                        let val = decoder.decode_varint32()?;
                        let val_ref = &val;
                        if *val_ref != 0 {
                            *mut_ref = val as _;
                        }
                    };
                }
                _ => {
                    decoder.skip_wire_value(tag.wire_type())?;
                }
            }
        }
        Ok(())
    }
}
impl ::micropb::MessageEncode for r#wifi_ap_record {
    const MAX_SIZE: ::core::option::Option<usize> = 'msg: {
        let mut max_size = 0;
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(7usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(34usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(5usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(10usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(10usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(10usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(10usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(10usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(10usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(5usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        if let ::core::option::Option::Some(size) = ::micropb::const_map!(
            ::micropb::const_map!(
                <r#wifi_country as ::micropb::MessageEncode>::MAX_SIZE,
                |size| ::micropb::size::sizeof_len_record(size)
            ),
            |size| size + 1usize
        ) {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        if let ::core::option::Option::Some(size) = ::micropb::const_map!(
            ::micropb::const_map!(
                <r#wifi_he_ap_info as ::micropb::MessageEncode>::MAX_SIZE,
                |size| ::micropb::size::sizeof_len_record(size)
            ),
            |size| size + 1usize
        ) {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(5usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(5usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(5usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        ::core::option::Option::Some(max_size)
    };
    fn encode<IMPL_MICROPB_WRITE: ::micropb::PbWrite>(
        &self,
        encoder: &mut ::micropb::PbEncoder<IMPL_MICROPB_WRITE>,
    ) -> Result<(), IMPL_MICROPB_WRITE::Error> {
        use ::micropb::{FieldEncode, PbMap};
        {
            let val_ref = &self.r#bssid;
            if !val_ref.is_empty() {
                encoder.encode_varint32(10u32)?;
                encoder.encode_bytes(val_ref)?;
            }
        }
        {
            let val_ref = &self.r#ssid;
            if !val_ref.is_empty() {
                encoder.encode_varint32(18u32)?;
                encoder.encode_bytes(val_ref)?;
            }
        }
        {
            let val_ref = &self.r#primary;
            if *val_ref != 0 {
                encoder.encode_varint32(24u32)?;
                encoder.encode_varint32(*val_ref as _)?;
            }
        }
        {
            let val_ref = &self.r#second;
            if *val_ref != 0 {
                encoder.encode_varint32(32u32)?;
                encoder.encode_int32(*val_ref as _)?;
            }
        }
        {
            let val_ref = &self.r#rssi;
            if *val_ref != 0 {
                encoder.encode_varint32(40u32)?;
                encoder.encode_int32(*val_ref as _)?;
            }
        }
        {
            let val_ref = &self.r#authmode;
            if *val_ref != 0 {
                encoder.encode_varint32(48u32)?;
                encoder.encode_int32(*val_ref as _)?;
            }
        }
        {
            let val_ref = &self.r#pairwise_cipher;
            if *val_ref != 0 {
                encoder.encode_varint32(56u32)?;
                encoder.encode_int32(*val_ref as _)?;
            }
        }
        {
            let val_ref = &self.r#group_cipher;
            if *val_ref != 0 {
                encoder.encode_varint32(64u32)?;
                encoder.encode_int32(*val_ref as _)?;
            }
        }
        {
            let val_ref = &self.r#ant;
            if *val_ref != 0 {
                encoder.encode_varint32(72u32)?;
                encoder.encode_int32(*val_ref as _)?;
            }
        }
        {
            let val_ref = &self.r#bitmask;
            if *val_ref != 0 {
                encoder.encode_varint32(80u32)?;
                encoder.encode_varint32(*val_ref as _)?;
            }
        }
        {
            if let ::core::option::Option::Some(val_ref) = self.r#country() {
                encoder.encode_varint32(90u32)?;
                val_ref.encode_len_delimited(encoder)?;
            }
        }
        {
            if let ::core::option::Option::Some(val_ref) = self.r#he_ap() {
                encoder.encode_varint32(98u32)?;
                val_ref.encode_len_delimited(encoder)?;
            }
        }
        {
            let val_ref = &self.r#bandwidth;
            if *val_ref != 0 {
                encoder.encode_varint32(104u32)?;
                encoder.encode_varint32(*val_ref as _)?;
            }
        }
        {
            let val_ref = &self.r#vht_ch_freq1;
            if *val_ref != 0 {
                encoder.encode_varint32(112u32)?;
                encoder.encode_varint32(*val_ref as _)?;
            }
        }
        {
            let val_ref = &self.r#vht_ch_freq2;
            if *val_ref != 0 {
                encoder.encode_varint32(120u32)?;
                encoder.encode_varint32(*val_ref as _)?;
            }
        }
        Ok(())
    }
    fn compute_size(&self) -> usize {
        use ::micropb::{FieldEncode, PbMap};
        let mut size = 0;
        {
            let val_ref = &self.r#bssid;
            if !val_ref.is_empty() {
                size += 1usize + ::micropb::size::sizeof_len_record(val_ref.len());
            }
        }
        {
            let val_ref = &self.r#ssid;
            if !val_ref.is_empty() {
                size += 1usize + ::micropb::size::sizeof_len_record(val_ref.len());
            }
        }
        {
            let val_ref = &self.r#primary;
            if *val_ref != 0 {
                size += 1usize + ::micropb::size::sizeof_varint32(*val_ref as _);
            }
        }
        {
            let val_ref = &self.r#second;
            if *val_ref != 0 {
                size += 1usize + ::micropb::size::sizeof_int32(*val_ref as _);
            }
        }
        {
            let val_ref = &self.r#rssi;
            if *val_ref != 0 {
                size += 1usize + ::micropb::size::sizeof_int32(*val_ref as _);
            }
        }
        {
            let val_ref = &self.r#authmode;
            if *val_ref != 0 {
                size += 1usize + ::micropb::size::sizeof_int32(*val_ref as _);
            }
        }
        {
            let val_ref = &self.r#pairwise_cipher;
            if *val_ref != 0 {
                size += 1usize + ::micropb::size::sizeof_int32(*val_ref as _);
            }
        }
        {
            let val_ref = &self.r#group_cipher;
            if *val_ref != 0 {
                size += 1usize + ::micropb::size::sizeof_int32(*val_ref as _);
            }
        }
        {
            let val_ref = &self.r#ant;
            if *val_ref != 0 {
                size += 1usize + ::micropb::size::sizeof_int32(*val_ref as _);
            }
        }
        {
            let val_ref = &self.r#bitmask;
            if *val_ref != 0 {
                size += 1usize + ::micropb::size::sizeof_varint32(*val_ref as _);
            }
        }
        {
            if let ::core::option::Option::Some(val_ref) = self.r#country() {
                size += 1usize + ::micropb::size::sizeof_len_record(val_ref.compute_size());
            }
        }
        {
            if let ::core::option::Option::Some(val_ref) = self.r#he_ap() {
                size += 1usize + ::micropb::size::sizeof_len_record(val_ref.compute_size());
            }
        }
        {
            let val_ref = &self.r#bandwidth;
            if *val_ref != 0 {
                size += 1usize + ::micropb::size::sizeof_varint32(*val_ref as _);
            }
        }
        {
            let val_ref = &self.r#vht_ch_freq1;
            if *val_ref != 0 {
                size += 1usize + ::micropb::size::sizeof_varint32(*val_ref as _);
            }
        }
        {
            let val_ref = &self.r#vht_ch_freq2;
            if *val_ref != 0 {
                size += 1usize + ::micropb::size::sizeof_varint32(*val_ref as _);
            }
        }
        size
    }
}
#[derive(Debug, Default, PartialEq, Clone)]
pub struct r#wifi_scan_threshold {
    pub r#rssi: i32,
    pub r#authmode: i32,
}
impl r#wifi_scan_threshold {
    ///Return a reference to `rssi`
    #[inline]
    pub fn r#rssi(&self) -> &i32 {
        &self.r#rssi
    }
    ///Return a mutable reference to `rssi`
    #[inline]
    pub fn mut_rssi(&mut self) -> &mut i32 {
        &mut self.r#rssi
    }
    ///Set the value of `rssi`
    #[inline]
    pub fn set_rssi(&mut self, value: i32) -> &mut Self {
        self.r#rssi = value.into();
        self
    }
    ///Builder method that sets the value of `rssi`. Useful for initializing the message.
    #[inline]
    pub fn init_rssi(mut self, value: i32) -> Self {
        self.r#rssi = value.into();
        self
    }
    ///Return a reference to `authmode`
    #[inline]
    pub fn r#authmode(&self) -> &i32 {
        &self.r#authmode
    }
    ///Return a mutable reference to `authmode`
    #[inline]
    pub fn mut_authmode(&mut self) -> &mut i32 {
        &mut self.r#authmode
    }
    ///Set the value of `authmode`
    #[inline]
    pub fn set_authmode(&mut self, value: i32) -> &mut Self {
        self.r#authmode = value.into();
        self
    }
    ///Builder method that sets the value of `authmode`. Useful for initializing the message.
    #[inline]
    pub fn init_authmode(mut self, value: i32) -> Self {
        self.r#authmode = value.into();
        self
    }
}
impl ::micropb::MessageDecode for r#wifi_scan_threshold {
    fn decode<IMPL_MICROPB_READ: ::micropb::PbRead>(
        &mut self,
        decoder: &mut ::micropb::PbDecoder<IMPL_MICROPB_READ>,
        len: usize,
    ) -> Result<(), ::micropb::DecodeError<IMPL_MICROPB_READ::Error>> {
        use ::micropb::{FieldDecode, PbBytes, PbMap, PbString, PbVec};
        let before = decoder.bytes_read();
        while decoder.bytes_read() - before < len {
            let tag = decoder.decode_tag()?;
            match tag.field_num() {
                0 => return Err(::micropb::DecodeError::ZeroField),
                1u32 => {
                    let mut_ref = &mut self.r#rssi;
                    {
                        let val = decoder.decode_int32()?;
                        let val_ref = &val;
                        if *val_ref != 0 {
                            *mut_ref = val as _;
                        }
                    };
                }
                2u32 => {
                    let mut_ref = &mut self.r#authmode;
                    {
                        let val = decoder.decode_int32()?;
                        let val_ref = &val;
                        if *val_ref != 0 {
                            *mut_ref = val as _;
                        }
                    };
                }
                _ => {
                    decoder.skip_wire_value(tag.wire_type())?;
                }
            }
        }
        Ok(())
    }
}
impl ::micropb::MessageEncode for r#wifi_scan_threshold {
    const MAX_SIZE: ::core::option::Option<usize> = 'msg: {
        let mut max_size = 0;
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(10usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(10usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        ::core::option::Option::Some(max_size)
    };
    fn encode<IMPL_MICROPB_WRITE: ::micropb::PbWrite>(
        &self,
        encoder: &mut ::micropb::PbEncoder<IMPL_MICROPB_WRITE>,
    ) -> Result<(), IMPL_MICROPB_WRITE::Error> {
        use ::micropb::{FieldEncode, PbMap};
        {
            let val_ref = &self.r#rssi;
            if *val_ref != 0 {
                encoder.encode_varint32(8u32)?;
                encoder.encode_int32(*val_ref as _)?;
            }
        }
        {
            let val_ref = &self.r#authmode;
            if *val_ref != 0 {
                encoder.encode_varint32(16u32)?;
                encoder.encode_int32(*val_ref as _)?;
            }
        }
        Ok(())
    }
    fn compute_size(&self) -> usize {
        use ::micropb::{FieldEncode, PbMap};
        let mut size = 0;
        {
            let val_ref = &self.r#rssi;
            if *val_ref != 0 {
                size += 1usize + ::micropb::size::sizeof_int32(*val_ref as _);
            }
        }
        {
            let val_ref = &self.r#authmode;
            if *val_ref != 0 {
                size += 1usize + ::micropb::size::sizeof_int32(*val_ref as _);
            }
        }
        size
    }
}
#[derive(Debug, Default, PartialEq, Clone)]
pub struct r#wifi_pmf_config {
    pub r#capable: bool,
    pub r#required: bool,
}
impl r#wifi_pmf_config {
    ///Return a reference to `capable`
    #[inline]
    pub fn r#capable(&self) -> &bool {
        &self.r#capable
    }
    ///Return a mutable reference to `capable`
    #[inline]
    pub fn mut_capable(&mut self) -> &mut bool {
        &mut self.r#capable
    }
    ///Set the value of `capable`
    #[inline]
    pub fn set_capable(&mut self, value: bool) -> &mut Self {
        self.r#capable = value.into();
        self
    }
    ///Builder method that sets the value of `capable`. Useful for initializing the message.
    #[inline]
    pub fn init_capable(mut self, value: bool) -> Self {
        self.r#capable = value.into();
        self
    }
    ///Return a reference to `required`
    #[inline]
    pub fn r#required(&self) -> &bool {
        &self.r#required
    }
    ///Return a mutable reference to `required`
    #[inline]
    pub fn mut_required(&mut self) -> &mut bool {
        &mut self.r#required
    }
    ///Set the value of `required`
    #[inline]
    pub fn set_required(&mut self, value: bool) -> &mut Self {
        self.r#required = value.into();
        self
    }
    ///Builder method that sets the value of `required`. Useful for initializing the message.
    #[inline]
    pub fn init_required(mut self, value: bool) -> Self {
        self.r#required = value.into();
        self
    }
}
impl ::micropb::MessageDecode for r#wifi_pmf_config {
    fn decode<IMPL_MICROPB_READ: ::micropb::PbRead>(
        &mut self,
        decoder: &mut ::micropb::PbDecoder<IMPL_MICROPB_READ>,
        len: usize,
    ) -> Result<(), ::micropb::DecodeError<IMPL_MICROPB_READ::Error>> {
        use ::micropb::{FieldDecode, PbBytes, PbMap, PbString, PbVec};
        let before = decoder.bytes_read();
        while decoder.bytes_read() - before < len {
            let tag = decoder.decode_tag()?;
            match tag.field_num() {
                0 => return Err(::micropb::DecodeError::ZeroField),
                1u32 => {
                    let mut_ref = &mut self.r#capable;
                    {
                        let val = decoder.decode_bool()?;
                        let val_ref = &val;
                        if *val_ref {
                            *mut_ref = val as _;
                        }
                    };
                }
                2u32 => {
                    let mut_ref = &mut self.r#required;
                    {
                        let val = decoder.decode_bool()?;
                        let val_ref = &val;
                        if *val_ref {
                            *mut_ref = val as _;
                        }
                    };
                }
                _ => {
                    decoder.skip_wire_value(tag.wire_type())?;
                }
            }
        }
        Ok(())
    }
}
impl ::micropb::MessageEncode for r#wifi_pmf_config {
    const MAX_SIZE: ::core::option::Option<usize> = 'msg: {
        let mut max_size = 0;
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(1usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(1usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        ::core::option::Option::Some(max_size)
    };
    fn encode<IMPL_MICROPB_WRITE: ::micropb::PbWrite>(
        &self,
        encoder: &mut ::micropb::PbEncoder<IMPL_MICROPB_WRITE>,
    ) -> Result<(), IMPL_MICROPB_WRITE::Error> {
        use ::micropb::{FieldEncode, PbMap};
        {
            let val_ref = &self.r#capable;
            if *val_ref {
                encoder.encode_varint32(8u32)?;
                encoder.encode_bool(*val_ref)?;
            }
        }
        {
            let val_ref = &self.r#required;
            if *val_ref {
                encoder.encode_varint32(16u32)?;
                encoder.encode_bool(*val_ref)?;
            }
        }
        Ok(())
    }
    fn compute_size(&self) -> usize {
        use ::micropb::{FieldEncode, PbMap};
        let mut size = 0;
        {
            let val_ref = &self.r#capable;
            if *val_ref {
                size += 1usize + 1;
            }
        }
        {
            let val_ref = &self.r#required;
            if *val_ref {
                size += 1usize + 1;
            }
        }
        size
    }
}
pub mod wifi_ap_config_ {
    #[derive(Debug, Default, PartialEq, Clone)]
    pub struct _Hazzer([u8; 1]);
    impl _Hazzer {
        ///New hazzer with all fields set to off
        #[inline]
        pub const fn _new() -> Self {
            Self([0; 1])
        }
        ///Query presence of `pmf_cfg`
        #[inline]
        pub const fn r#pmf_cfg(&self) -> bool {
            (self.0[0] & 1) != 0
        }
        ///Set presence of `pmf_cfg`
        #[inline]
        pub const fn set_pmf_cfg(&mut self) -> &mut Self {
            let elem = &mut self.0[0];
            *elem |= 1;
            self
        }
        ///Clear presence of `pmf_cfg`
        #[inline]
        pub const fn clear_pmf_cfg(&mut self) -> &mut Self {
            let elem = &mut self.0[0];
            *elem &= !1;
            self
        }
        ///Builder method that sets the presence of `pmf_cfg`. Useful for initializing the Hazzer.
        #[inline]
        pub const fn init_pmf_cfg(mut self) -> Self {
            self.set_pmf_cfg();
            self
        }
    }
}
#[derive(Debug, Default, Clone)]
pub struct r#wifi_ap_config {
    pub r#ssid: ::micropb::heapless::Vec<u8, 33>,
    pub r#password: ::micropb::heapless::Vec<u8, 64>,
    pub r#ssid_len: u32,
    pub r#channel: u32,
    pub r#authmode: i32,
    pub r#ssid_hidden: u32,
    pub r#max_connection: u32,
    pub r#beacon_interval: u32,
    pub r#pairwise_cipher: i32,
    pub r#ftm_responder: bool,
    pub r#pmf_cfg: r#wifi_pmf_config,
    pub r#sae_pwe_h2e: i32,
    pub _has: wifi_ap_config_::_Hazzer,
}
impl ::core::cmp::PartialEq for r#wifi_ap_config {
    fn eq(&self, other: &Self) -> bool {
        let mut ret = true;
        ret &= (self.r#ssid == other.r#ssid);
        ret &= (self.r#password == other.r#password);
        ret &= (self.r#ssid_len == other.r#ssid_len);
        ret &= (self.r#channel == other.r#channel);
        ret &= (self.r#authmode == other.r#authmode);
        ret &= (self.r#ssid_hidden == other.r#ssid_hidden);
        ret &= (self.r#max_connection == other.r#max_connection);
        ret &= (self.r#beacon_interval == other.r#beacon_interval);
        ret &= (self.r#pairwise_cipher == other.r#pairwise_cipher);
        ret &= (self.r#ftm_responder == other.r#ftm_responder);
        ret &= (self.r#pmf_cfg() == other.r#pmf_cfg());
        ret &= (self.r#sae_pwe_h2e == other.r#sae_pwe_h2e);
        ret
    }
}
impl r#wifi_ap_config {
    ///Return a reference to `ssid`
    #[inline]
    pub fn r#ssid(&self) -> &::micropb::heapless::Vec<u8, 33> {
        &self.r#ssid
    }
    ///Return a mutable reference to `ssid`
    #[inline]
    pub fn mut_ssid(&mut self) -> &mut ::micropb::heapless::Vec<u8, 33> {
        &mut self.r#ssid
    }
    ///Set the value of `ssid`
    #[inline]
    pub fn set_ssid(&mut self, value: ::micropb::heapless::Vec<u8, 33>) -> &mut Self {
        self.r#ssid = value.into();
        self
    }
    ///Builder method that sets the value of `ssid`. Useful for initializing the message.
    #[inline]
    pub fn init_ssid(mut self, value: ::micropb::heapless::Vec<u8, 33>) -> Self {
        self.r#ssid = value.into();
        self
    }
    ///Return a reference to `password`
    #[inline]
    pub fn r#password(&self) -> &::micropb::heapless::Vec<u8, 64> {
        &self.r#password
    }
    ///Return a mutable reference to `password`
    #[inline]
    pub fn mut_password(&mut self) -> &mut ::micropb::heapless::Vec<u8, 64> {
        &mut self.r#password
    }
    ///Set the value of `password`
    #[inline]
    pub fn set_password(&mut self, value: ::micropb::heapless::Vec<u8, 64>) -> &mut Self {
        self.r#password = value.into();
        self
    }
    ///Builder method that sets the value of `password`. Useful for initializing the message.
    #[inline]
    pub fn init_password(mut self, value: ::micropb::heapless::Vec<u8, 64>) -> Self {
        self.r#password = value.into();
        self
    }
    ///Return a reference to `ssid_len`
    #[inline]
    pub fn r#ssid_len(&self) -> &u32 {
        &self.r#ssid_len
    }
    ///Return a mutable reference to `ssid_len`
    #[inline]
    pub fn mut_ssid_len(&mut self) -> &mut u32 {
        &mut self.r#ssid_len
    }
    ///Set the value of `ssid_len`
    #[inline]
    pub fn set_ssid_len(&mut self, value: u32) -> &mut Self {
        self.r#ssid_len = value.into();
        self
    }
    ///Builder method that sets the value of `ssid_len`. Useful for initializing the message.
    #[inline]
    pub fn init_ssid_len(mut self, value: u32) -> Self {
        self.r#ssid_len = value.into();
        self
    }
    ///Return a reference to `channel`
    #[inline]
    pub fn r#channel(&self) -> &u32 {
        &self.r#channel
    }
    ///Return a mutable reference to `channel`
    #[inline]
    pub fn mut_channel(&mut self) -> &mut u32 {
        &mut self.r#channel
    }
    ///Set the value of `channel`
    #[inline]
    pub fn set_channel(&mut self, value: u32) -> &mut Self {
        self.r#channel = value.into();
        self
    }
    ///Builder method that sets the value of `channel`. Useful for initializing the message.
    #[inline]
    pub fn init_channel(mut self, value: u32) -> Self {
        self.r#channel = value.into();
        self
    }
    ///Return a reference to `authmode`
    #[inline]
    pub fn r#authmode(&self) -> &i32 {
        &self.r#authmode
    }
    ///Return a mutable reference to `authmode`
    #[inline]
    pub fn mut_authmode(&mut self) -> &mut i32 {
        &mut self.r#authmode
    }
    ///Set the value of `authmode`
    #[inline]
    pub fn set_authmode(&mut self, value: i32) -> &mut Self {
        self.r#authmode = value.into();
        self
    }
    ///Builder method that sets the value of `authmode`. Useful for initializing the message.
    #[inline]
    pub fn init_authmode(mut self, value: i32) -> Self {
        self.r#authmode = value.into();
        self
    }
    ///Return a reference to `ssid_hidden`
    #[inline]
    pub fn r#ssid_hidden(&self) -> &u32 {
        &self.r#ssid_hidden
    }
    ///Return a mutable reference to `ssid_hidden`
    #[inline]
    pub fn mut_ssid_hidden(&mut self) -> &mut u32 {
        &mut self.r#ssid_hidden
    }
    ///Set the value of `ssid_hidden`
    #[inline]
    pub fn set_ssid_hidden(&mut self, value: u32) -> &mut Self {
        self.r#ssid_hidden = value.into();
        self
    }
    ///Builder method that sets the value of `ssid_hidden`. Useful for initializing the message.
    #[inline]
    pub fn init_ssid_hidden(mut self, value: u32) -> Self {
        self.r#ssid_hidden = value.into();
        self
    }
    ///Return a reference to `max_connection`
    #[inline]
    pub fn r#max_connection(&self) -> &u32 {
        &self.r#max_connection
    }
    ///Return a mutable reference to `max_connection`
    #[inline]
    pub fn mut_max_connection(&mut self) -> &mut u32 {
        &mut self.r#max_connection
    }
    ///Set the value of `max_connection`
    #[inline]
    pub fn set_max_connection(&mut self, value: u32) -> &mut Self {
        self.r#max_connection = value.into();
        self
    }
    ///Builder method that sets the value of `max_connection`. Useful for initializing the message.
    #[inline]
    pub fn init_max_connection(mut self, value: u32) -> Self {
        self.r#max_connection = value.into();
        self
    }
    ///Return a reference to `beacon_interval`
    #[inline]
    pub fn r#beacon_interval(&self) -> &u32 {
        &self.r#beacon_interval
    }
    ///Return a mutable reference to `beacon_interval`
    #[inline]
    pub fn mut_beacon_interval(&mut self) -> &mut u32 {
        &mut self.r#beacon_interval
    }
    ///Set the value of `beacon_interval`
    #[inline]
    pub fn set_beacon_interval(&mut self, value: u32) -> &mut Self {
        self.r#beacon_interval = value.into();
        self
    }
    ///Builder method that sets the value of `beacon_interval`. Useful for initializing the message.
    #[inline]
    pub fn init_beacon_interval(mut self, value: u32) -> Self {
        self.r#beacon_interval = value.into();
        self
    }
    ///Return a reference to `pairwise_cipher`
    #[inline]
    pub fn r#pairwise_cipher(&self) -> &i32 {
        &self.r#pairwise_cipher
    }
    ///Return a mutable reference to `pairwise_cipher`
    #[inline]
    pub fn mut_pairwise_cipher(&mut self) -> &mut i32 {
        &mut self.r#pairwise_cipher
    }
    ///Set the value of `pairwise_cipher`
    #[inline]
    pub fn set_pairwise_cipher(&mut self, value: i32) -> &mut Self {
        self.r#pairwise_cipher = value.into();
        self
    }
    ///Builder method that sets the value of `pairwise_cipher`. Useful for initializing the message.
    #[inline]
    pub fn init_pairwise_cipher(mut self, value: i32) -> Self {
        self.r#pairwise_cipher = value.into();
        self
    }
    ///Return a reference to `ftm_responder`
    #[inline]
    pub fn r#ftm_responder(&self) -> &bool {
        &self.r#ftm_responder
    }
    ///Return a mutable reference to `ftm_responder`
    #[inline]
    pub fn mut_ftm_responder(&mut self) -> &mut bool {
        &mut self.r#ftm_responder
    }
    ///Set the value of `ftm_responder`
    #[inline]
    pub fn set_ftm_responder(&mut self, value: bool) -> &mut Self {
        self.r#ftm_responder = value.into();
        self
    }
    ///Builder method that sets the value of `ftm_responder`. Useful for initializing the message.
    #[inline]
    pub fn init_ftm_responder(mut self, value: bool) -> Self {
        self.r#ftm_responder = value.into();
        self
    }
    ///Return a reference to `pmf_cfg` as an `Option`
    #[inline]
    pub fn r#pmf_cfg(&self) -> ::core::option::Option<&r#wifi_pmf_config> {
        self._has.r#pmf_cfg().then_some(&self.r#pmf_cfg)
    }
    ///Set the value and presence of `pmf_cfg`
    #[inline]
    pub fn set_pmf_cfg(&mut self, value: r#wifi_pmf_config) -> &mut Self {
        self._has.set_pmf_cfg();
        self.r#pmf_cfg = value.into();
        self
    }
    ///Return a mutable reference to `pmf_cfg` as an `Option`
    #[inline]
    pub fn mut_pmf_cfg(&mut self) -> ::core::option::Option<&mut r#wifi_pmf_config> {
        self._has.r#pmf_cfg().then_some(&mut self.r#pmf_cfg)
    }
    ///Clear the presence of `pmf_cfg`
    #[inline]
    pub fn clear_pmf_cfg(&mut self) -> &mut Self {
        self._has.clear_pmf_cfg();
        self
    }
    ///Take the value of `pmf_cfg` and clear its presence
    #[inline]
    pub fn take_pmf_cfg(&mut self) -> ::core::option::Option<r#wifi_pmf_config> {
        let val = self
            ._has
            .r#pmf_cfg()
            .then(|| ::core::mem::take(&mut self.r#pmf_cfg));
        self._has.clear_pmf_cfg();
        val
    }
    ///Builder method that sets the value of `pmf_cfg`. Useful for initializing the message.
    #[inline]
    pub fn init_pmf_cfg(mut self, value: r#wifi_pmf_config) -> Self {
        self.set_pmf_cfg(value);
        self
    }
    ///Return a reference to `sae_pwe_h2e`
    #[inline]
    pub fn r#sae_pwe_h2e(&self) -> &i32 {
        &self.r#sae_pwe_h2e
    }
    ///Return a mutable reference to `sae_pwe_h2e`
    #[inline]
    pub fn mut_sae_pwe_h2e(&mut self) -> &mut i32 {
        &mut self.r#sae_pwe_h2e
    }
    ///Set the value of `sae_pwe_h2e`
    #[inline]
    pub fn set_sae_pwe_h2e(&mut self, value: i32) -> &mut Self {
        self.r#sae_pwe_h2e = value.into();
        self
    }
    ///Builder method that sets the value of `sae_pwe_h2e`. Useful for initializing the message.
    #[inline]
    pub fn init_sae_pwe_h2e(mut self, value: i32) -> Self {
        self.r#sae_pwe_h2e = value.into();
        self
    }
}
impl ::micropb::MessageDecode for r#wifi_ap_config {
    fn decode<IMPL_MICROPB_READ: ::micropb::PbRead>(
        &mut self,
        decoder: &mut ::micropb::PbDecoder<IMPL_MICROPB_READ>,
        len: usize,
    ) -> Result<(), ::micropb::DecodeError<IMPL_MICROPB_READ::Error>> {
        use ::micropb::{FieldDecode, PbBytes, PbMap, PbString, PbVec};
        let before = decoder.bytes_read();
        while decoder.bytes_read() - before < len {
            let tag = decoder.decode_tag()?;
            match tag.field_num() {
                0 => return Err(::micropb::DecodeError::ZeroField),
                1u32 => {
                    let mut_ref = &mut self.r#ssid;
                    {
                        decoder.decode_bytes(mut_ref, ::micropb::Presence::Implicit)?;
                    };
                }
                2u32 => {
                    let mut_ref = &mut self.r#password;
                    {
                        decoder.decode_bytes(mut_ref, ::micropb::Presence::Implicit)?;
                    };
                }
                3u32 => {
                    let mut_ref = &mut self.r#ssid_len;
                    {
                        let val = decoder.decode_varint32()?;
                        let val_ref = &val;
                        if *val_ref != 0 {
                            *mut_ref = val as _;
                        }
                    };
                }
                4u32 => {
                    let mut_ref = &mut self.r#channel;
                    {
                        let val = decoder.decode_varint32()?;
                        let val_ref = &val;
                        if *val_ref != 0 {
                            *mut_ref = val as _;
                        }
                    };
                }
                5u32 => {
                    let mut_ref = &mut self.r#authmode;
                    {
                        let val = decoder.decode_int32()?;
                        let val_ref = &val;
                        if *val_ref != 0 {
                            *mut_ref = val as _;
                        }
                    };
                }
                6u32 => {
                    let mut_ref = &mut self.r#ssid_hidden;
                    {
                        let val = decoder.decode_varint32()?;
                        let val_ref = &val;
                        if *val_ref != 0 {
                            *mut_ref = val as _;
                        }
                    };
                }
                7u32 => {
                    let mut_ref = &mut self.r#max_connection;
                    {
                        let val = decoder.decode_varint32()?;
                        let val_ref = &val;
                        if *val_ref != 0 {
                            *mut_ref = val as _;
                        }
                    };
                }
                8u32 => {
                    let mut_ref = &mut self.r#beacon_interval;
                    {
                        let val = decoder.decode_varint32()?;
                        let val_ref = &val;
                        if *val_ref != 0 {
                            *mut_ref = val as _;
                        }
                    };
                }
                9u32 => {
                    let mut_ref = &mut self.r#pairwise_cipher;
                    {
                        let val = decoder.decode_int32()?;
                        let val_ref = &val;
                        if *val_ref != 0 {
                            *mut_ref = val as _;
                        }
                    };
                }
                10u32 => {
                    let mut_ref = &mut self.r#ftm_responder;
                    {
                        let val = decoder.decode_bool()?;
                        let val_ref = &val;
                        if *val_ref {
                            *mut_ref = val as _;
                        }
                    };
                }
                11u32 => {
                    let mut_ref = &mut self.r#pmf_cfg;
                    {
                        mut_ref.decode_len_delimited(decoder)?;
                    };
                    self._has.set_pmf_cfg();
                }
                12u32 => {
                    let mut_ref = &mut self.r#sae_pwe_h2e;
                    {
                        let val = decoder.decode_int32()?;
                        let val_ref = &val;
                        if *val_ref != 0 {
                            *mut_ref = val as _;
                        }
                    };
                }
                _ => {
                    decoder.skip_wire_value(tag.wire_type())?;
                }
            }
        }
        Ok(())
    }
}
impl ::micropb::MessageEncode for r#wifi_ap_config {
    const MAX_SIZE: ::core::option::Option<usize> = 'msg: {
        let mut max_size = 0;
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(34usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(65usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(5usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(5usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(10usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(5usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(5usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(5usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(10usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(1usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        if let ::core::option::Option::Some(size) = ::micropb::const_map!(
            ::micropb::const_map!(
                <r#wifi_pmf_config as ::micropb::MessageEncode>::MAX_SIZE,
                |size| ::micropb::size::sizeof_len_record(size)
            ),
            |size| size + 1usize
        ) {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(10usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        ::core::option::Option::Some(max_size)
    };
    fn encode<IMPL_MICROPB_WRITE: ::micropb::PbWrite>(
        &self,
        encoder: &mut ::micropb::PbEncoder<IMPL_MICROPB_WRITE>,
    ) -> Result<(), IMPL_MICROPB_WRITE::Error> {
        use ::micropb::{FieldEncode, PbMap};
        {
            let val_ref = &self.r#ssid;
            if !val_ref.is_empty() {
                encoder.encode_varint32(10u32)?;
                encoder.encode_bytes(val_ref)?;
            }
        }
        {
            let val_ref = &self.r#password;
            if !val_ref.is_empty() {
                encoder.encode_varint32(18u32)?;
                encoder.encode_bytes(val_ref)?;
            }
        }
        {
            let val_ref = &self.r#ssid_len;
            if *val_ref != 0 {
                encoder.encode_varint32(24u32)?;
                encoder.encode_varint32(*val_ref as _)?;
            }
        }
        {
            let val_ref = &self.r#channel;
            if *val_ref != 0 {
                encoder.encode_varint32(32u32)?;
                encoder.encode_varint32(*val_ref as _)?;
            }
        }
        {
            let val_ref = &self.r#authmode;
            if *val_ref != 0 {
                encoder.encode_varint32(40u32)?;
                encoder.encode_int32(*val_ref as _)?;
            }
        }
        {
            let val_ref = &self.r#ssid_hidden;
            if *val_ref != 0 {
                encoder.encode_varint32(48u32)?;
                encoder.encode_varint32(*val_ref as _)?;
            }
        }
        {
            let val_ref = &self.r#max_connection;
            if *val_ref != 0 {
                encoder.encode_varint32(56u32)?;
                encoder.encode_varint32(*val_ref as _)?;
            }
        }
        {
            let val_ref = &self.r#beacon_interval;
            if *val_ref != 0 {
                encoder.encode_varint32(64u32)?;
                encoder.encode_varint32(*val_ref as _)?;
            }
        }
        {
            let val_ref = &self.r#pairwise_cipher;
            if *val_ref != 0 {
                encoder.encode_varint32(72u32)?;
                encoder.encode_int32(*val_ref as _)?;
            }
        }
        {
            let val_ref = &self.r#ftm_responder;
            if *val_ref {
                encoder.encode_varint32(80u32)?;
                encoder.encode_bool(*val_ref)?;
            }
        }
        {
            if let ::core::option::Option::Some(val_ref) = self.r#pmf_cfg() {
                encoder.encode_varint32(90u32)?;
                val_ref.encode_len_delimited(encoder)?;
            }
        }
        {
            let val_ref = &self.r#sae_pwe_h2e;
            if *val_ref != 0 {
                encoder.encode_varint32(96u32)?;
                encoder.encode_int32(*val_ref as _)?;
            }
        }
        Ok(())
    }
    fn compute_size(&self) -> usize {
        use ::micropb::{FieldEncode, PbMap};
        let mut size = 0;
        {
            let val_ref = &self.r#ssid;
            if !val_ref.is_empty() {
                size += 1usize + ::micropb::size::sizeof_len_record(val_ref.len());
            }
        }
        {
            let val_ref = &self.r#password;
            if !val_ref.is_empty() {
                size += 1usize + ::micropb::size::sizeof_len_record(val_ref.len());
            }
        }
        {
            let val_ref = &self.r#ssid_len;
            if *val_ref != 0 {
                size += 1usize + ::micropb::size::sizeof_varint32(*val_ref as _);
            }
        }
        {
            let val_ref = &self.r#channel;
            if *val_ref != 0 {
                size += 1usize + ::micropb::size::sizeof_varint32(*val_ref as _);
            }
        }
        {
            let val_ref = &self.r#authmode;
            if *val_ref != 0 {
                size += 1usize + ::micropb::size::sizeof_int32(*val_ref as _);
            }
        }
        {
            let val_ref = &self.r#ssid_hidden;
            if *val_ref != 0 {
                size += 1usize + ::micropb::size::sizeof_varint32(*val_ref as _);
            }
        }
        {
            let val_ref = &self.r#max_connection;
            if *val_ref != 0 {
                size += 1usize + ::micropb::size::sizeof_varint32(*val_ref as _);
            }
        }
        {
            let val_ref = &self.r#beacon_interval;
            if *val_ref != 0 {
                size += 1usize + ::micropb::size::sizeof_varint32(*val_ref as _);
            }
        }
        {
            let val_ref = &self.r#pairwise_cipher;
            if *val_ref != 0 {
                size += 1usize + ::micropb::size::sizeof_int32(*val_ref as _);
            }
        }
        {
            let val_ref = &self.r#ftm_responder;
            if *val_ref {
                size += 1usize + 1;
            }
        }
        {
            if let ::core::option::Option::Some(val_ref) = self.r#pmf_cfg() {
                size += 1usize + ::micropb::size::sizeof_len_record(val_ref.compute_size());
            }
        }
        {
            let val_ref = &self.r#sae_pwe_h2e;
            if *val_ref != 0 {
                size += 1usize + ::micropb::size::sizeof_int32(*val_ref as _);
            }
        }
        size
    }
}
pub mod wifi_sta_config_ {
    #[derive(Debug, Default, PartialEq, Clone)]
    pub struct _Hazzer([u8; 1]);
    impl _Hazzer {
        ///New hazzer with all fields set to off
        #[inline]
        pub const fn _new() -> Self {
            Self([0; 1])
        }
        ///Query presence of `threshold`
        #[inline]
        pub const fn r#threshold(&self) -> bool {
            (self.0[0] & 1) != 0
        }
        ///Set presence of `threshold`
        #[inline]
        pub const fn set_threshold(&mut self) -> &mut Self {
            let elem = &mut self.0[0];
            *elem |= 1;
            self
        }
        ///Clear presence of `threshold`
        #[inline]
        pub const fn clear_threshold(&mut self) -> &mut Self {
            let elem = &mut self.0[0];
            *elem &= !1;
            self
        }
        ///Builder method that sets the presence of `threshold`. Useful for initializing the Hazzer.
        #[inline]
        pub const fn init_threshold(mut self) -> Self {
            self.set_threshold();
            self
        }
        ///Query presence of `pmf_cfg`
        #[inline]
        pub const fn r#pmf_cfg(&self) -> bool {
            (self.0[0] & 2) != 0
        }
        ///Set presence of `pmf_cfg`
        #[inline]
        pub const fn set_pmf_cfg(&mut self) -> &mut Self {
            let elem = &mut self.0[0];
            *elem |= 2;
            self
        }
        ///Clear presence of `pmf_cfg`
        #[inline]
        pub const fn clear_pmf_cfg(&mut self) -> &mut Self {
            let elem = &mut self.0[0];
            *elem &= !2;
            self
        }
        ///Builder method that sets the presence of `pmf_cfg`. Useful for initializing the Hazzer.
        #[inline]
        pub const fn init_pmf_cfg(mut self) -> Self {
            self.set_pmf_cfg();
            self
        }
    }
}
#[derive(Debug, Default, Clone)]
pub struct r#wifi_sta_config {
    pub r#ssid: ::micropb::heapless::Vec<u8, 33>,
    pub r#password: ::micropb::heapless::Vec<u8, 64>,
    pub r#scan_method: i32,
    pub r#bssid_set: bool,
    pub r#bssid: ::micropb::heapless::Vec<u8, 6>,
    pub r#channel: u32,
    pub r#listen_interval: u32,
    pub r#sort_method: i32,
    pub r#threshold: r#wifi_scan_threshold,
    pub r#pmf_cfg: r#wifi_pmf_config,
    pub r#bitmask: u32,
    pub r#sae_pwe_h2e: i32,
    pub r#failure_retry_cnt: u32,
    pub r#he_bitmask: u32,
    pub r#sae_h2e_identifier: ::micropb::heapless::Vec<u8, 16>,
    pub _has: wifi_sta_config_::_Hazzer,
}
impl ::core::cmp::PartialEq for r#wifi_sta_config {
    fn eq(&self, other: &Self) -> bool {
        let mut ret = true;
        ret &= (self.r#ssid == other.r#ssid);
        ret &= (self.r#password == other.r#password);
        ret &= (self.r#scan_method == other.r#scan_method);
        ret &= (self.r#bssid_set == other.r#bssid_set);
        ret &= (self.r#bssid == other.r#bssid);
        ret &= (self.r#channel == other.r#channel);
        ret &= (self.r#listen_interval == other.r#listen_interval);
        ret &= (self.r#sort_method == other.r#sort_method);
        ret &= (self.r#threshold() == other.r#threshold());
        ret &= (self.r#pmf_cfg() == other.r#pmf_cfg());
        ret &= (self.r#bitmask == other.r#bitmask);
        ret &= (self.r#sae_pwe_h2e == other.r#sae_pwe_h2e);
        ret &= (self.r#failure_retry_cnt == other.r#failure_retry_cnt);
        ret &= (self.r#he_bitmask == other.r#he_bitmask);
        ret &= (self.r#sae_h2e_identifier == other.r#sae_h2e_identifier);
        ret
    }
}
impl r#wifi_sta_config {
    ///Return a reference to `ssid`
    #[inline]
    pub fn r#ssid(&self) -> &::micropb::heapless::Vec<u8, 33> {
        &self.r#ssid
    }
    ///Return a mutable reference to `ssid`
    #[inline]
    pub fn mut_ssid(&mut self) -> &mut ::micropb::heapless::Vec<u8, 33> {
        &mut self.r#ssid
    }
    ///Set the value of `ssid`
    #[inline]
    pub fn set_ssid(&mut self, value: ::micropb::heapless::Vec<u8, 33>) -> &mut Self {
        self.r#ssid = value.into();
        self
    }
    ///Builder method that sets the value of `ssid`. Useful for initializing the message.
    #[inline]
    pub fn init_ssid(mut self, value: ::micropb::heapless::Vec<u8, 33>) -> Self {
        self.r#ssid = value.into();
        self
    }
    ///Return a reference to `password`
    #[inline]
    pub fn r#password(&self) -> &::micropb::heapless::Vec<u8, 64> {
        &self.r#password
    }
    ///Return a mutable reference to `password`
    #[inline]
    pub fn mut_password(&mut self) -> &mut ::micropb::heapless::Vec<u8, 64> {
        &mut self.r#password
    }
    ///Set the value of `password`
    #[inline]
    pub fn set_password(&mut self, value: ::micropb::heapless::Vec<u8, 64>) -> &mut Self {
        self.r#password = value.into();
        self
    }
    ///Builder method that sets the value of `password`. Useful for initializing the message.
    #[inline]
    pub fn init_password(mut self, value: ::micropb::heapless::Vec<u8, 64>) -> Self {
        self.r#password = value.into();
        self
    }
    ///Return a reference to `scan_method`
    #[inline]
    pub fn r#scan_method(&self) -> &i32 {
        &self.r#scan_method
    }
    ///Return a mutable reference to `scan_method`
    #[inline]
    pub fn mut_scan_method(&mut self) -> &mut i32 {
        &mut self.r#scan_method
    }
    ///Set the value of `scan_method`
    #[inline]
    pub fn set_scan_method(&mut self, value: i32) -> &mut Self {
        self.r#scan_method = value.into();
        self
    }
    ///Builder method that sets the value of `scan_method`. Useful for initializing the message.
    #[inline]
    pub fn init_scan_method(mut self, value: i32) -> Self {
        self.r#scan_method = value.into();
        self
    }
    ///Return a reference to `bssid_set`
    #[inline]
    pub fn r#bssid_set(&self) -> &bool {
        &self.r#bssid_set
    }
    ///Return a mutable reference to `bssid_set`
    #[inline]
    pub fn mut_bssid_set(&mut self) -> &mut bool {
        &mut self.r#bssid_set
    }
    ///Set the value of `bssid_set`
    #[inline]
    pub fn set_bssid_set(&mut self, value: bool) -> &mut Self {
        self.r#bssid_set = value.into();
        self
    }
    ///Builder method that sets the value of `bssid_set`. Useful for initializing the message.
    #[inline]
    pub fn init_bssid_set(mut self, value: bool) -> Self {
        self.r#bssid_set = value.into();
        self
    }
    ///Return a reference to `bssid`
    #[inline]
    pub fn r#bssid(&self) -> &::micropb::heapless::Vec<u8, 6> {
        &self.r#bssid
    }
    ///Return a mutable reference to `bssid`
    #[inline]
    pub fn mut_bssid(&mut self) -> &mut ::micropb::heapless::Vec<u8, 6> {
        &mut self.r#bssid
    }
    ///Set the value of `bssid`
    #[inline]
    pub fn set_bssid(&mut self, value: ::micropb::heapless::Vec<u8, 6>) -> &mut Self {
        self.r#bssid = value.into();
        self
    }
    ///Builder method that sets the value of `bssid`. Useful for initializing the message.
    #[inline]
    pub fn init_bssid(mut self, value: ::micropb::heapless::Vec<u8, 6>) -> Self {
        self.r#bssid = value.into();
        self
    }
    ///Return a reference to `channel`
    #[inline]
    pub fn r#channel(&self) -> &u32 {
        &self.r#channel
    }
    ///Return a mutable reference to `channel`
    #[inline]
    pub fn mut_channel(&mut self) -> &mut u32 {
        &mut self.r#channel
    }
    ///Set the value of `channel`
    #[inline]
    pub fn set_channel(&mut self, value: u32) -> &mut Self {
        self.r#channel = value.into();
        self
    }
    ///Builder method that sets the value of `channel`. Useful for initializing the message.
    #[inline]
    pub fn init_channel(mut self, value: u32) -> Self {
        self.r#channel = value.into();
        self
    }
    ///Return a reference to `listen_interval`
    #[inline]
    pub fn r#listen_interval(&self) -> &u32 {
        &self.r#listen_interval
    }
    ///Return a mutable reference to `listen_interval`
    #[inline]
    pub fn mut_listen_interval(&mut self) -> &mut u32 {
        &mut self.r#listen_interval
    }
    ///Set the value of `listen_interval`
    #[inline]
    pub fn set_listen_interval(&mut self, value: u32) -> &mut Self {
        self.r#listen_interval = value.into();
        self
    }
    ///Builder method that sets the value of `listen_interval`. Useful for initializing the message.
    #[inline]
    pub fn init_listen_interval(mut self, value: u32) -> Self {
        self.r#listen_interval = value.into();
        self
    }
    ///Return a reference to `sort_method`
    #[inline]
    pub fn r#sort_method(&self) -> &i32 {
        &self.r#sort_method
    }
    ///Return a mutable reference to `sort_method`
    #[inline]
    pub fn mut_sort_method(&mut self) -> &mut i32 {
        &mut self.r#sort_method
    }
    ///Set the value of `sort_method`
    #[inline]
    pub fn set_sort_method(&mut self, value: i32) -> &mut Self {
        self.r#sort_method = value.into();
        self
    }
    ///Builder method that sets the value of `sort_method`. Useful for initializing the message.
    #[inline]
    pub fn init_sort_method(mut self, value: i32) -> Self {
        self.r#sort_method = value.into();
        self
    }
    ///Return a reference to `threshold` as an `Option`
    #[inline]
    pub fn r#threshold(&self) -> ::core::option::Option<&r#wifi_scan_threshold> {
        self._has.r#threshold().then_some(&self.r#threshold)
    }
    ///Set the value and presence of `threshold`
    #[inline]
    pub fn set_threshold(&mut self, value: r#wifi_scan_threshold) -> &mut Self {
        self._has.set_threshold();
        self.r#threshold = value.into();
        self
    }
    ///Return a mutable reference to `threshold` as an `Option`
    #[inline]
    pub fn mut_threshold(&mut self) -> ::core::option::Option<&mut r#wifi_scan_threshold> {
        self._has.r#threshold().then_some(&mut self.r#threshold)
    }
    ///Clear the presence of `threshold`
    #[inline]
    pub fn clear_threshold(&mut self) -> &mut Self {
        self._has.clear_threshold();
        self
    }
    ///Take the value of `threshold` and clear its presence
    #[inline]
    pub fn take_threshold(&mut self) -> ::core::option::Option<r#wifi_scan_threshold> {
        let val = self
            ._has
            .r#threshold()
            .then(|| ::core::mem::take(&mut self.r#threshold));
        self._has.clear_threshold();
        val
    }
    ///Builder method that sets the value of `threshold`. Useful for initializing the message.
    #[inline]
    pub fn init_threshold(mut self, value: r#wifi_scan_threshold) -> Self {
        self.set_threshold(value);
        self
    }
    ///Return a reference to `pmf_cfg` as an `Option`
    #[inline]
    pub fn r#pmf_cfg(&self) -> ::core::option::Option<&r#wifi_pmf_config> {
        self._has.r#pmf_cfg().then_some(&self.r#pmf_cfg)
    }
    ///Set the value and presence of `pmf_cfg`
    #[inline]
    pub fn set_pmf_cfg(&mut self, value: r#wifi_pmf_config) -> &mut Self {
        self._has.set_pmf_cfg();
        self.r#pmf_cfg = value.into();
        self
    }
    ///Return a mutable reference to `pmf_cfg` as an `Option`
    #[inline]
    pub fn mut_pmf_cfg(&mut self) -> ::core::option::Option<&mut r#wifi_pmf_config> {
        self._has.r#pmf_cfg().then_some(&mut self.r#pmf_cfg)
    }
    ///Clear the presence of `pmf_cfg`
    #[inline]
    pub fn clear_pmf_cfg(&mut self) -> &mut Self {
        self._has.clear_pmf_cfg();
        self
    }
    ///Take the value of `pmf_cfg` and clear its presence
    #[inline]
    pub fn take_pmf_cfg(&mut self) -> ::core::option::Option<r#wifi_pmf_config> {
        let val = self
            ._has
            .r#pmf_cfg()
            .then(|| ::core::mem::take(&mut self.r#pmf_cfg));
        self._has.clear_pmf_cfg();
        val
    }
    ///Builder method that sets the value of `pmf_cfg`. Useful for initializing the message.
    #[inline]
    pub fn init_pmf_cfg(mut self, value: r#wifi_pmf_config) -> Self {
        self.set_pmf_cfg(value);
        self
    }
    ///Return a reference to `bitmask`
    #[inline]
    pub fn r#bitmask(&self) -> &u32 {
        &self.r#bitmask
    }
    ///Return a mutable reference to `bitmask`
    #[inline]
    pub fn mut_bitmask(&mut self) -> &mut u32 {
        &mut self.r#bitmask
    }
    ///Set the value of `bitmask`
    #[inline]
    pub fn set_bitmask(&mut self, value: u32) -> &mut Self {
        self.r#bitmask = value.into();
        self
    }
    ///Builder method that sets the value of `bitmask`. Useful for initializing the message.
    #[inline]
    pub fn init_bitmask(mut self, value: u32) -> Self {
        self.r#bitmask = value.into();
        self
    }
    ///Return a reference to `sae_pwe_h2e`
    #[inline]
    pub fn r#sae_pwe_h2e(&self) -> &i32 {
        &self.r#sae_pwe_h2e
    }
    ///Return a mutable reference to `sae_pwe_h2e`
    #[inline]
    pub fn mut_sae_pwe_h2e(&mut self) -> &mut i32 {
        &mut self.r#sae_pwe_h2e
    }
    ///Set the value of `sae_pwe_h2e`
    #[inline]
    pub fn set_sae_pwe_h2e(&mut self, value: i32) -> &mut Self {
        self.r#sae_pwe_h2e = value.into();
        self
    }
    ///Builder method that sets the value of `sae_pwe_h2e`. Useful for initializing the message.
    #[inline]
    pub fn init_sae_pwe_h2e(mut self, value: i32) -> Self {
        self.r#sae_pwe_h2e = value.into();
        self
    }
    ///Return a reference to `failure_retry_cnt`
    #[inline]
    pub fn r#failure_retry_cnt(&self) -> &u32 {
        &self.r#failure_retry_cnt
    }
    ///Return a mutable reference to `failure_retry_cnt`
    #[inline]
    pub fn mut_failure_retry_cnt(&mut self) -> &mut u32 {
        &mut self.r#failure_retry_cnt
    }
    ///Set the value of `failure_retry_cnt`
    #[inline]
    pub fn set_failure_retry_cnt(&mut self, value: u32) -> &mut Self {
        self.r#failure_retry_cnt = value.into();
        self
    }
    ///Builder method that sets the value of `failure_retry_cnt`. Useful for initializing the message.
    #[inline]
    pub fn init_failure_retry_cnt(mut self, value: u32) -> Self {
        self.r#failure_retry_cnt = value.into();
        self
    }
    ///Return a reference to `he_bitmask`
    #[inline]
    pub fn r#he_bitmask(&self) -> &u32 {
        &self.r#he_bitmask
    }
    ///Return a mutable reference to `he_bitmask`
    #[inline]
    pub fn mut_he_bitmask(&mut self) -> &mut u32 {
        &mut self.r#he_bitmask
    }
    ///Set the value of `he_bitmask`
    #[inline]
    pub fn set_he_bitmask(&mut self, value: u32) -> &mut Self {
        self.r#he_bitmask = value.into();
        self
    }
    ///Builder method that sets the value of `he_bitmask`. Useful for initializing the message.
    #[inline]
    pub fn init_he_bitmask(mut self, value: u32) -> Self {
        self.r#he_bitmask = value.into();
        self
    }
    ///Return a reference to `sae_h2e_identifier`
    #[inline]
    pub fn r#sae_h2e_identifier(&self) -> &::micropb::heapless::Vec<u8, 16> {
        &self.r#sae_h2e_identifier
    }
    ///Return a mutable reference to `sae_h2e_identifier`
    #[inline]
    pub fn mut_sae_h2e_identifier(&mut self) -> &mut ::micropb::heapless::Vec<u8, 16> {
        &mut self.r#sae_h2e_identifier
    }
    ///Set the value of `sae_h2e_identifier`
    #[inline]
    pub fn set_sae_h2e_identifier(&mut self, value: ::micropb::heapless::Vec<u8, 16>) -> &mut Self {
        self.r#sae_h2e_identifier = value.into();
        self
    }
    ///Builder method that sets the value of `sae_h2e_identifier`. Useful for initializing the message.
    #[inline]
    pub fn init_sae_h2e_identifier(mut self, value: ::micropb::heapless::Vec<u8, 16>) -> Self {
        self.r#sae_h2e_identifier = value.into();
        self
    }
}
impl ::micropb::MessageDecode for r#wifi_sta_config {
    fn decode<IMPL_MICROPB_READ: ::micropb::PbRead>(
        &mut self,
        decoder: &mut ::micropb::PbDecoder<IMPL_MICROPB_READ>,
        len: usize,
    ) -> Result<(), ::micropb::DecodeError<IMPL_MICROPB_READ::Error>> {
        use ::micropb::{FieldDecode, PbBytes, PbMap, PbString, PbVec};
        let before = decoder.bytes_read();
        while decoder.bytes_read() - before < len {
            let tag = decoder.decode_tag()?;
            match tag.field_num() {
                0 => return Err(::micropb::DecodeError::ZeroField),
                1u32 => {
                    let mut_ref = &mut self.r#ssid;
                    {
                        decoder.decode_bytes(mut_ref, ::micropb::Presence::Implicit)?;
                    };
                }
                2u32 => {
                    let mut_ref = &mut self.r#password;
                    {
                        decoder.decode_bytes(mut_ref, ::micropb::Presence::Implicit)?;
                    };
                }
                3u32 => {
                    let mut_ref = &mut self.r#scan_method;
                    {
                        let val = decoder.decode_int32()?;
                        let val_ref = &val;
                        if *val_ref != 0 {
                            *mut_ref = val as _;
                        }
                    };
                }
                4u32 => {
                    let mut_ref = &mut self.r#bssid_set;
                    {
                        let val = decoder.decode_bool()?;
                        let val_ref = &val;
                        if *val_ref {
                            *mut_ref = val as _;
                        }
                    };
                }
                5u32 => {
                    let mut_ref = &mut self.r#bssid;
                    {
                        decoder.decode_bytes(mut_ref, ::micropb::Presence::Implicit)?;
                    };
                }
                6u32 => {
                    let mut_ref = &mut self.r#channel;
                    {
                        let val = decoder.decode_varint32()?;
                        let val_ref = &val;
                        if *val_ref != 0 {
                            *mut_ref = val as _;
                        }
                    };
                }
                7u32 => {
                    let mut_ref = &mut self.r#listen_interval;
                    {
                        let val = decoder.decode_varint32()?;
                        let val_ref = &val;
                        if *val_ref != 0 {
                            *mut_ref = val as _;
                        }
                    };
                }
                8u32 => {
                    let mut_ref = &mut self.r#sort_method;
                    {
                        let val = decoder.decode_int32()?;
                        let val_ref = &val;
                        if *val_ref != 0 {
                            *mut_ref = val as _;
                        }
                    };
                }
                9u32 => {
                    let mut_ref = &mut self.r#threshold;
                    {
                        mut_ref.decode_len_delimited(decoder)?;
                    };
                    self._has.set_threshold();
                }
                10u32 => {
                    let mut_ref = &mut self.r#pmf_cfg;
                    {
                        mut_ref.decode_len_delimited(decoder)?;
                    };
                    self._has.set_pmf_cfg();
                }
                11u32 => {
                    let mut_ref = &mut self.r#bitmask;
                    {
                        let val = decoder.decode_varint32()?;
                        let val_ref = &val;
                        if *val_ref != 0 {
                            *mut_ref = val as _;
                        }
                    };
                }
                12u32 => {
                    let mut_ref = &mut self.r#sae_pwe_h2e;
                    {
                        let val = decoder.decode_int32()?;
                        let val_ref = &val;
                        if *val_ref != 0 {
                            *mut_ref = val as _;
                        }
                    };
                }
                13u32 => {
                    let mut_ref = &mut self.r#failure_retry_cnt;
                    {
                        let val = decoder.decode_varint32()?;
                        let val_ref = &val;
                        if *val_ref != 0 {
                            *mut_ref = val as _;
                        }
                    };
                }
                14u32 => {
                    let mut_ref = &mut self.r#he_bitmask;
                    {
                        let val = decoder.decode_varint32()?;
                        let val_ref = &val;
                        if *val_ref != 0 {
                            *mut_ref = val as _;
                        }
                    };
                }
                15u32 => {
                    let mut_ref = &mut self.r#sae_h2e_identifier;
                    {
                        decoder.decode_bytes(mut_ref, ::micropb::Presence::Implicit)?;
                    };
                }
                _ => {
                    decoder.skip_wire_value(tag.wire_type())?;
                }
            }
        }
        Ok(())
    }
}
impl ::micropb::MessageEncode for r#wifi_sta_config {
    const MAX_SIZE: ::core::option::Option<usize> = 'msg: {
        let mut max_size = 0;
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(34usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(65usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(10usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(1usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(7usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(5usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(5usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(10usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        if let ::core::option::Option::Some(size) = ::micropb::const_map!(
            ::micropb::const_map!(
                <r#wifi_scan_threshold as ::micropb::MessageEncode>::MAX_SIZE,
                |size| ::micropb::size::sizeof_len_record(size)
            ),
            |size| size + 1usize
        ) {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        if let ::core::option::Option::Some(size) = ::micropb::const_map!(
            ::micropb::const_map!(
                <r#wifi_pmf_config as ::micropb::MessageEncode>::MAX_SIZE,
                |size| ::micropb::size::sizeof_len_record(size)
            ),
            |size| size + 1usize
        ) {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(5usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(10usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(5usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(5usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(17usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        ::core::option::Option::Some(max_size)
    };
    fn encode<IMPL_MICROPB_WRITE: ::micropb::PbWrite>(
        &self,
        encoder: &mut ::micropb::PbEncoder<IMPL_MICROPB_WRITE>,
    ) -> Result<(), IMPL_MICROPB_WRITE::Error> {
        use ::micropb::{FieldEncode, PbMap};
        {
            let val_ref = &self.r#ssid;
            if !val_ref.is_empty() {
                encoder.encode_varint32(10u32)?;
                encoder.encode_bytes(val_ref)?;
            }
        }
        {
            let val_ref = &self.r#password;
            if !val_ref.is_empty() {
                encoder.encode_varint32(18u32)?;
                encoder.encode_bytes(val_ref)?;
            }
        }
        {
            let val_ref = &self.r#scan_method;
            if *val_ref != 0 {
                encoder.encode_varint32(24u32)?;
                encoder.encode_int32(*val_ref as _)?;
            }
        }
        {
            let val_ref = &self.r#bssid_set;
            if *val_ref {
                encoder.encode_varint32(32u32)?;
                encoder.encode_bool(*val_ref)?;
            }
        }
        {
            let val_ref = &self.r#bssid;
            if !val_ref.is_empty() {
                encoder.encode_varint32(42u32)?;
                encoder.encode_bytes(val_ref)?;
            }
        }
        {
            let val_ref = &self.r#channel;
            if *val_ref != 0 {
                encoder.encode_varint32(48u32)?;
                encoder.encode_varint32(*val_ref as _)?;
            }
        }
        {
            let val_ref = &self.r#listen_interval;
            if *val_ref != 0 {
                encoder.encode_varint32(56u32)?;
                encoder.encode_varint32(*val_ref as _)?;
            }
        }
        {
            let val_ref = &self.r#sort_method;
            if *val_ref != 0 {
                encoder.encode_varint32(64u32)?;
                encoder.encode_int32(*val_ref as _)?;
            }
        }
        {
            if let ::core::option::Option::Some(val_ref) = self.r#threshold() {
                encoder.encode_varint32(74u32)?;
                val_ref.encode_len_delimited(encoder)?;
            }
        }
        {
            if let ::core::option::Option::Some(val_ref) = self.r#pmf_cfg() {
                encoder.encode_varint32(82u32)?;
                val_ref.encode_len_delimited(encoder)?;
            }
        }
        {
            let val_ref = &self.r#bitmask;
            if *val_ref != 0 {
                encoder.encode_varint32(88u32)?;
                encoder.encode_varint32(*val_ref as _)?;
            }
        }
        {
            let val_ref = &self.r#sae_pwe_h2e;
            if *val_ref != 0 {
                encoder.encode_varint32(96u32)?;
                encoder.encode_int32(*val_ref as _)?;
            }
        }
        {
            let val_ref = &self.r#failure_retry_cnt;
            if *val_ref != 0 {
                encoder.encode_varint32(104u32)?;
                encoder.encode_varint32(*val_ref as _)?;
            }
        }
        {
            let val_ref = &self.r#he_bitmask;
            if *val_ref != 0 {
                encoder.encode_varint32(112u32)?;
                encoder.encode_varint32(*val_ref as _)?;
            }
        }
        {
            let val_ref = &self.r#sae_h2e_identifier;
            if !val_ref.is_empty() {
                encoder.encode_varint32(122u32)?;
                encoder.encode_bytes(val_ref)?;
            }
        }
        Ok(())
    }
    fn compute_size(&self) -> usize {
        use ::micropb::{FieldEncode, PbMap};
        let mut size = 0;
        {
            let val_ref = &self.r#ssid;
            if !val_ref.is_empty() {
                size += 1usize + ::micropb::size::sizeof_len_record(val_ref.len());
            }
        }
        {
            let val_ref = &self.r#password;
            if !val_ref.is_empty() {
                size += 1usize + ::micropb::size::sizeof_len_record(val_ref.len());
            }
        }
        {
            let val_ref = &self.r#scan_method;
            if *val_ref != 0 {
                size += 1usize + ::micropb::size::sizeof_int32(*val_ref as _);
            }
        }
        {
            let val_ref = &self.r#bssid_set;
            if *val_ref {
                size += 1usize + 1;
            }
        }
        {
            let val_ref = &self.r#bssid;
            if !val_ref.is_empty() {
                size += 1usize + ::micropb::size::sizeof_len_record(val_ref.len());
            }
        }
        {
            let val_ref = &self.r#channel;
            if *val_ref != 0 {
                size += 1usize + ::micropb::size::sizeof_varint32(*val_ref as _);
            }
        }
        {
            let val_ref = &self.r#listen_interval;
            if *val_ref != 0 {
                size += 1usize + ::micropb::size::sizeof_varint32(*val_ref as _);
            }
        }
        {
            let val_ref = &self.r#sort_method;
            if *val_ref != 0 {
                size += 1usize + ::micropb::size::sizeof_int32(*val_ref as _);
            }
        }
        {
            if let ::core::option::Option::Some(val_ref) = self.r#threshold() {
                size += 1usize + ::micropb::size::sizeof_len_record(val_ref.compute_size());
            }
        }
        {
            if let ::core::option::Option::Some(val_ref) = self.r#pmf_cfg() {
                size += 1usize + ::micropb::size::sizeof_len_record(val_ref.compute_size());
            }
        }
        {
            let val_ref = &self.r#bitmask;
            if *val_ref != 0 {
                size += 1usize + ::micropb::size::sizeof_varint32(*val_ref as _);
            }
        }
        {
            let val_ref = &self.r#sae_pwe_h2e;
            if *val_ref != 0 {
                size += 1usize + ::micropb::size::sizeof_int32(*val_ref as _);
            }
        }
        {
            let val_ref = &self.r#failure_retry_cnt;
            if *val_ref != 0 {
                size += 1usize + ::micropb::size::sizeof_varint32(*val_ref as _);
            }
        }
        {
            let val_ref = &self.r#he_bitmask;
            if *val_ref != 0 {
                size += 1usize + ::micropb::size::sizeof_varint32(*val_ref as _);
            }
        }
        {
            let val_ref = &self.r#sae_h2e_identifier;
            if !val_ref.is_empty() {
                size += 1usize + ::micropb::size::sizeof_len_record(val_ref.len());
            }
        }
        size
    }
}
pub mod wifi_config_ {
    #[derive(Debug, PartialEq, Clone)]
    pub enum U {
        Ap(super::r#wifi_ap_config),
        Sta(super::r#wifi_sta_config),
    }
}
#[derive(Debug, Default, PartialEq, Clone)]
pub struct r#wifi_config {
    pub r#u: ::core::option::Option<wifi_config_::U>,
}
impl r#wifi_config {}
impl ::micropb::MessageDecode for r#wifi_config {
    fn decode<IMPL_MICROPB_READ: ::micropb::PbRead>(
        &mut self,
        decoder: &mut ::micropb::PbDecoder<IMPL_MICROPB_READ>,
        len: usize,
    ) -> Result<(), ::micropb::DecodeError<IMPL_MICROPB_READ::Error>> {
        use ::micropb::{FieldDecode, PbBytes, PbMap, PbString, PbVec};
        let before = decoder.bytes_read();
        while decoder.bytes_read() - before < len {
            let tag = decoder.decode_tag()?;
            match tag.field_num() {
                0 => return Err(::micropb::DecodeError::ZeroField),
                1u32 => {
                    let mut_ref = loop {
                        if let ::core::option::Option::Some(variant) = &mut self.r#u {
                            if let wifi_config_::U::Ap(variant) = &mut *variant {
                                break &mut *variant;
                            }
                        }
                        self.r#u = ::core::option::Option::Some(wifi_config_::U::Ap(
                            ::core::default::Default::default(),
                        ));
                    };
                    mut_ref.decode_len_delimited(decoder)?;
                }
                2u32 => {
                    let mut_ref = loop {
                        if let ::core::option::Option::Some(variant) = &mut self.r#u {
                            if let wifi_config_::U::Sta(variant) = &mut *variant {
                                break &mut *variant;
                            }
                        }
                        self.r#u = ::core::option::Option::Some(wifi_config_::U::Sta(
                            ::core::default::Default::default(),
                        ));
                    };
                    mut_ref.decode_len_delimited(decoder)?;
                }
                _ => {
                    decoder.skip_wire_value(tag.wire_type())?;
                }
            }
        }
        Ok(())
    }
}
impl ::micropb::MessageEncode for r#wifi_config {
    const MAX_SIZE: ::core::option::Option<usize> = 'msg: {
        let mut max_size = 0;
        if let ::core::option::Option::Some(size) = 'oneof: {
            let mut max_size = 0;
            if let ::core::option::Option::Some(size) = ::micropb::const_map!(
                ::micropb::const_map!(
                    <r#wifi_ap_config as ::micropb::MessageEncode>::MAX_SIZE,
                    |size| ::micropb::size::sizeof_len_record(size)
                ),
                |size| size + 1usize
            ) {
                if size > max_size {
                    max_size = size;
                }
            } else {
                break 'oneof (::core::option::Option::<usize>::None);
            }
            if let ::core::option::Option::Some(size) = ::micropb::const_map!(
                ::micropb::const_map!(
                    <r#wifi_sta_config as ::micropb::MessageEncode>::MAX_SIZE,
                    |size| ::micropb::size::sizeof_len_record(size)
                ),
                |size| size + 1usize
            ) {
                if size > max_size {
                    max_size = size;
                }
            } else {
                break 'oneof (::core::option::Option::<usize>::None);
            }
            ::core::option::Option::Some(max_size)
        } {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        ::core::option::Option::Some(max_size)
    };
    fn encode<IMPL_MICROPB_WRITE: ::micropb::PbWrite>(
        &self,
        encoder: &mut ::micropb::PbEncoder<IMPL_MICROPB_WRITE>,
    ) -> Result<(), IMPL_MICROPB_WRITE::Error> {
        use ::micropb::{FieldEncode, PbMap};
        if let Some(oneof) = &self.r#u {
            match &*oneof {
                wifi_config_::U::Ap(val_ref) => {
                    let val_ref = &*val_ref;
                    encoder.encode_varint32(10u32)?;
                    val_ref.encode_len_delimited(encoder)?;
                }
                wifi_config_::U::Sta(val_ref) => {
                    let val_ref = &*val_ref;
                    encoder.encode_varint32(18u32)?;
                    val_ref.encode_len_delimited(encoder)?;
                }
            }
        }
        Ok(())
    }
    fn compute_size(&self) -> usize {
        use ::micropb::{FieldEncode, PbMap};
        let mut size = 0;
        if let Some(oneof) = &self.r#u {
            match &*oneof {
                wifi_config_::U::Ap(val_ref) => {
                    let val_ref = &*val_ref;
                    size += 1usize + ::micropb::size::sizeof_len_record(val_ref.compute_size());
                }
                wifi_config_::U::Sta(val_ref) => {
                    let val_ref = &*val_ref;
                    size += 1usize + ::micropb::size::sizeof_len_record(val_ref.compute_size());
                }
            }
        }
        size
    }
}
#[derive(Debug, Default, PartialEq, Clone)]
pub struct r#wifi_sta_info {
    pub r#mac: ::micropb::heapless::Vec<u8, 6>,
    pub r#rssi: i32,
    pub r#bitmask: u32,
}
impl r#wifi_sta_info {
    ///Return a reference to `mac`
    #[inline]
    pub fn r#mac(&self) -> &::micropb::heapless::Vec<u8, 6> {
        &self.r#mac
    }
    ///Return a mutable reference to `mac`
    #[inline]
    pub fn mut_mac(&mut self) -> &mut ::micropb::heapless::Vec<u8, 6> {
        &mut self.r#mac
    }
    ///Set the value of `mac`
    #[inline]
    pub fn set_mac(&mut self, value: ::micropb::heapless::Vec<u8, 6>) -> &mut Self {
        self.r#mac = value.into();
        self
    }
    ///Builder method that sets the value of `mac`. Useful for initializing the message.
    #[inline]
    pub fn init_mac(mut self, value: ::micropb::heapless::Vec<u8, 6>) -> Self {
        self.r#mac = value.into();
        self
    }
    ///Return a reference to `rssi`
    #[inline]
    pub fn r#rssi(&self) -> &i32 {
        &self.r#rssi
    }
    ///Return a mutable reference to `rssi`
    #[inline]
    pub fn mut_rssi(&mut self) -> &mut i32 {
        &mut self.r#rssi
    }
    ///Set the value of `rssi`
    #[inline]
    pub fn set_rssi(&mut self, value: i32) -> &mut Self {
        self.r#rssi = value.into();
        self
    }
    ///Builder method that sets the value of `rssi`. Useful for initializing the message.
    #[inline]
    pub fn init_rssi(mut self, value: i32) -> Self {
        self.r#rssi = value.into();
        self
    }
    ///Return a reference to `bitmask`
    #[inline]
    pub fn r#bitmask(&self) -> &u32 {
        &self.r#bitmask
    }
    ///Return a mutable reference to `bitmask`
    #[inline]
    pub fn mut_bitmask(&mut self) -> &mut u32 {
        &mut self.r#bitmask
    }
    ///Set the value of `bitmask`
    #[inline]
    pub fn set_bitmask(&mut self, value: u32) -> &mut Self {
        self.r#bitmask = value.into();
        self
    }
    ///Builder method that sets the value of `bitmask`. Useful for initializing the message.
    #[inline]
    pub fn init_bitmask(mut self, value: u32) -> Self {
        self.r#bitmask = value.into();
        self
    }
}
impl ::micropb::MessageDecode for r#wifi_sta_info {
    fn decode<IMPL_MICROPB_READ: ::micropb::PbRead>(
        &mut self,
        decoder: &mut ::micropb::PbDecoder<IMPL_MICROPB_READ>,
        len: usize,
    ) -> Result<(), ::micropb::DecodeError<IMPL_MICROPB_READ::Error>> {
        use ::micropb::{FieldDecode, PbBytes, PbMap, PbString, PbVec};
        let before = decoder.bytes_read();
        while decoder.bytes_read() - before < len {
            let tag = decoder.decode_tag()?;
            match tag.field_num() {
                0 => return Err(::micropb::DecodeError::ZeroField),
                1u32 => {
                    let mut_ref = &mut self.r#mac;
                    {
                        decoder.decode_bytes(mut_ref, ::micropb::Presence::Implicit)?;
                    };
                }
                2u32 => {
                    let mut_ref = &mut self.r#rssi;
                    {
                        let val = decoder.decode_int32()?;
                        let val_ref = &val;
                        if *val_ref != 0 {
                            *mut_ref = val as _;
                        }
                    };
                }
                3u32 => {
                    let mut_ref = &mut self.r#bitmask;
                    {
                        let val = decoder.decode_varint32()?;
                        let val_ref = &val;
                        if *val_ref != 0 {
                            *mut_ref = val as _;
                        }
                    };
                }
                _ => {
                    decoder.skip_wire_value(tag.wire_type())?;
                }
            }
        }
        Ok(())
    }
}
impl ::micropb::MessageEncode for r#wifi_sta_info {
    const MAX_SIZE: ::core::option::Option<usize> = 'msg: {
        let mut max_size = 0;
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(7usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(10usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(5usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        ::core::option::Option::Some(max_size)
    };
    fn encode<IMPL_MICROPB_WRITE: ::micropb::PbWrite>(
        &self,
        encoder: &mut ::micropb::PbEncoder<IMPL_MICROPB_WRITE>,
    ) -> Result<(), IMPL_MICROPB_WRITE::Error> {
        use ::micropb::{FieldEncode, PbMap};
        {
            let val_ref = &self.r#mac;
            if !val_ref.is_empty() {
                encoder.encode_varint32(10u32)?;
                encoder.encode_bytes(val_ref)?;
            }
        }
        {
            let val_ref = &self.r#rssi;
            if *val_ref != 0 {
                encoder.encode_varint32(16u32)?;
                encoder.encode_int32(*val_ref as _)?;
            }
        }
        {
            let val_ref = &self.r#bitmask;
            if *val_ref != 0 {
                encoder.encode_varint32(24u32)?;
                encoder.encode_varint32(*val_ref as _)?;
            }
        }
        Ok(())
    }
    fn compute_size(&self) -> usize {
        use ::micropb::{FieldEncode, PbMap};
        let mut size = 0;
        {
            let val_ref = &self.r#mac;
            if !val_ref.is_empty() {
                size += 1usize + ::micropb::size::sizeof_len_record(val_ref.len());
            }
        }
        {
            let val_ref = &self.r#rssi;
            if *val_ref != 0 {
                size += 1usize + ::micropb::size::sizeof_int32(*val_ref as _);
            }
        }
        {
            let val_ref = &self.r#bitmask;
            if *val_ref != 0 {
                size += 1usize + ::micropb::size::sizeof_varint32(*val_ref as _);
            }
        }
        size
    }
}
#[derive(Debug, Default, PartialEq, Clone)]
pub struct r#wifi_sta_list {
    pub r#sta: ::micropb::heapless::Vec<r#wifi_sta_info, 20>,
    pub r#num: i32,
}
impl r#wifi_sta_list {
    ///Return a reference to `num`
    #[inline]
    pub fn r#num(&self) -> &i32 {
        &self.r#num
    }
    ///Return a mutable reference to `num`
    #[inline]
    pub fn mut_num(&mut self) -> &mut i32 {
        &mut self.r#num
    }
    ///Set the value of `num`
    #[inline]
    pub fn set_num(&mut self, value: i32) -> &mut Self {
        self.r#num = value.into();
        self
    }
    ///Builder method that sets the value of `num`. Useful for initializing the message.
    #[inline]
    pub fn init_num(mut self, value: i32) -> Self {
        self.r#num = value.into();
        self
    }
}
impl ::micropb::MessageDecode for r#wifi_sta_list {
    fn decode<IMPL_MICROPB_READ: ::micropb::PbRead>(
        &mut self,
        decoder: &mut ::micropb::PbDecoder<IMPL_MICROPB_READ>,
        len: usize,
    ) -> Result<(), ::micropb::DecodeError<IMPL_MICROPB_READ::Error>> {
        use ::micropb::{FieldDecode, PbBytes, PbMap, PbString, PbVec};
        let before = decoder.bytes_read();
        while decoder.bytes_read() - before < len {
            let tag = decoder.decode_tag()?;
            match tag.field_num() {
                0 => return Err(::micropb::DecodeError::ZeroField),
                1u32 => {
                    let mut val: r#wifi_sta_info = ::core::default::Default::default();
                    let mut_ref = &mut val;
                    {
                        mut_ref.decode_len_delimited(decoder)?;
                    };
                    if let (Err(_), false) =
                        (self.r#sta.pb_push(val), decoder.ignore_repeated_cap_err)
                    {
                        return Err(::micropb::DecodeError::Capacity);
                    }
                }
                2u32 => {
                    let mut_ref = &mut self.r#num;
                    {
                        let val = decoder.decode_int32()?;
                        let val_ref = &val;
                        if *val_ref != 0 {
                            *mut_ref = val as _;
                        }
                    };
                }
                _ => {
                    decoder.skip_wire_value(tag.wire_type())?;
                }
            }
        }
        Ok(())
    }
}
impl ::micropb::MessageEncode for r#wifi_sta_list {
    const MAX_SIZE: ::core::option::Option<usize> = 'msg: {
        let mut max_size = 0;
        if let ::core::option::Option::Some(size) = ::micropb::const_map!(
            ::micropb::const_map!(
                <r#wifi_sta_info as ::micropb::MessageEncode>::MAX_SIZE,
                |size| ::micropb::size::sizeof_len_record(size)
            ),
            |size| (size + 1usize) * 20usize
        ) {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(10usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        ::core::option::Option::Some(max_size)
    };
    fn encode<IMPL_MICROPB_WRITE: ::micropb::PbWrite>(
        &self,
        encoder: &mut ::micropb::PbEncoder<IMPL_MICROPB_WRITE>,
    ) -> Result<(), IMPL_MICROPB_WRITE::Error> {
        use ::micropb::{FieldEncode, PbMap};
        {
            for val_ref in self.r#sta.iter() {
                encoder.encode_varint32(10u32)?;
                val_ref.encode_len_delimited(encoder)?;
            }
        }
        {
            let val_ref = &self.r#num;
            if *val_ref != 0 {
                encoder.encode_varint32(16u32)?;
                encoder.encode_int32(*val_ref as _)?;
            }
        }
        Ok(())
    }
    fn compute_size(&self) -> usize {
        use ::micropb::{FieldEncode, PbMap};
        let mut size = 0;
        {
            for val_ref in self.r#sta.iter() {
                size += 1usize + ::micropb::size::sizeof_len_record(val_ref.compute_size());
            }
        }
        {
            let val_ref = &self.r#num;
            if *val_ref != 0 {
                size += 1usize + ::micropb::size::sizeof_int32(*val_ref as _);
            }
        }
        size
    }
}
#[derive(Debug, Default, PartialEq, Clone)]
pub struct r#wifi_pkt_rx_ctrl {
    pub r#rssi: i32,
    pub r#rate: u32,
    pub r#sig_mode: u32,
    pub r#mcs: u32,
    pub r#cwb: u32,
    pub r#smoothing: u32,
    pub r#not_sounding: u32,
    pub r#aggregation: u32,
    pub r#stbc: u32,
    pub r#fec_coding: u32,
    pub r#sgi: u32,
    pub r#noise_floor: i32,
    pub r#ampdu_cnt: u32,
    pub r#channel: u32,
    pub r#secondary_channel: u32,
    pub r#timestamp: u32,
    pub r#ant: u32,
    pub r#sig_len: u32,
    pub r#rx_state: u32,
}
impl r#wifi_pkt_rx_ctrl {
    ///Return a reference to `rssi`
    #[inline]
    pub fn r#rssi(&self) -> &i32 {
        &self.r#rssi
    }
    ///Return a mutable reference to `rssi`
    #[inline]
    pub fn mut_rssi(&mut self) -> &mut i32 {
        &mut self.r#rssi
    }
    ///Set the value of `rssi`
    #[inline]
    pub fn set_rssi(&mut self, value: i32) -> &mut Self {
        self.r#rssi = value.into();
        self
    }
    ///Builder method that sets the value of `rssi`. Useful for initializing the message.
    #[inline]
    pub fn init_rssi(mut self, value: i32) -> Self {
        self.r#rssi = value.into();
        self
    }
    ///Return a reference to `rate`
    #[inline]
    pub fn r#rate(&self) -> &u32 {
        &self.r#rate
    }
    ///Return a mutable reference to `rate`
    #[inline]
    pub fn mut_rate(&mut self) -> &mut u32 {
        &mut self.r#rate
    }
    ///Set the value of `rate`
    #[inline]
    pub fn set_rate(&mut self, value: u32) -> &mut Self {
        self.r#rate = value.into();
        self
    }
    ///Builder method that sets the value of `rate`. Useful for initializing the message.
    #[inline]
    pub fn init_rate(mut self, value: u32) -> Self {
        self.r#rate = value.into();
        self
    }
    ///Return a reference to `sig_mode`
    #[inline]
    pub fn r#sig_mode(&self) -> &u32 {
        &self.r#sig_mode
    }
    ///Return a mutable reference to `sig_mode`
    #[inline]
    pub fn mut_sig_mode(&mut self) -> &mut u32 {
        &mut self.r#sig_mode
    }
    ///Set the value of `sig_mode`
    #[inline]
    pub fn set_sig_mode(&mut self, value: u32) -> &mut Self {
        self.r#sig_mode = value.into();
        self
    }
    ///Builder method that sets the value of `sig_mode`. Useful for initializing the message.
    #[inline]
    pub fn init_sig_mode(mut self, value: u32) -> Self {
        self.r#sig_mode = value.into();
        self
    }
    ///Return a reference to `mcs`
    #[inline]
    pub fn r#mcs(&self) -> &u32 {
        &self.r#mcs
    }
    ///Return a mutable reference to `mcs`
    #[inline]
    pub fn mut_mcs(&mut self) -> &mut u32 {
        &mut self.r#mcs
    }
    ///Set the value of `mcs`
    #[inline]
    pub fn set_mcs(&mut self, value: u32) -> &mut Self {
        self.r#mcs = value.into();
        self
    }
    ///Builder method that sets the value of `mcs`. Useful for initializing the message.
    #[inline]
    pub fn init_mcs(mut self, value: u32) -> Self {
        self.r#mcs = value.into();
        self
    }
    ///Return a reference to `cwb`
    #[inline]
    pub fn r#cwb(&self) -> &u32 {
        &self.r#cwb
    }
    ///Return a mutable reference to `cwb`
    #[inline]
    pub fn mut_cwb(&mut self) -> &mut u32 {
        &mut self.r#cwb
    }
    ///Set the value of `cwb`
    #[inline]
    pub fn set_cwb(&mut self, value: u32) -> &mut Self {
        self.r#cwb = value.into();
        self
    }
    ///Builder method that sets the value of `cwb`. Useful for initializing the message.
    #[inline]
    pub fn init_cwb(mut self, value: u32) -> Self {
        self.r#cwb = value.into();
        self
    }
    ///Return a reference to `smoothing`
    #[inline]
    pub fn r#smoothing(&self) -> &u32 {
        &self.r#smoothing
    }
    ///Return a mutable reference to `smoothing`
    #[inline]
    pub fn mut_smoothing(&mut self) -> &mut u32 {
        &mut self.r#smoothing
    }
    ///Set the value of `smoothing`
    #[inline]
    pub fn set_smoothing(&mut self, value: u32) -> &mut Self {
        self.r#smoothing = value.into();
        self
    }
    ///Builder method that sets the value of `smoothing`. Useful for initializing the message.
    #[inline]
    pub fn init_smoothing(mut self, value: u32) -> Self {
        self.r#smoothing = value.into();
        self
    }
    ///Return a reference to `not_sounding`
    #[inline]
    pub fn r#not_sounding(&self) -> &u32 {
        &self.r#not_sounding
    }
    ///Return a mutable reference to `not_sounding`
    #[inline]
    pub fn mut_not_sounding(&mut self) -> &mut u32 {
        &mut self.r#not_sounding
    }
    ///Set the value of `not_sounding`
    #[inline]
    pub fn set_not_sounding(&mut self, value: u32) -> &mut Self {
        self.r#not_sounding = value.into();
        self
    }
    ///Builder method that sets the value of `not_sounding`. Useful for initializing the message.
    #[inline]
    pub fn init_not_sounding(mut self, value: u32) -> Self {
        self.r#not_sounding = value.into();
        self
    }
    ///Return a reference to `aggregation`
    #[inline]
    pub fn r#aggregation(&self) -> &u32 {
        &self.r#aggregation
    }
    ///Return a mutable reference to `aggregation`
    #[inline]
    pub fn mut_aggregation(&mut self) -> &mut u32 {
        &mut self.r#aggregation
    }
    ///Set the value of `aggregation`
    #[inline]
    pub fn set_aggregation(&mut self, value: u32) -> &mut Self {
        self.r#aggregation = value.into();
        self
    }
    ///Builder method that sets the value of `aggregation`. Useful for initializing the message.
    #[inline]
    pub fn init_aggregation(mut self, value: u32) -> Self {
        self.r#aggregation = value.into();
        self
    }
    ///Return a reference to `stbc`
    #[inline]
    pub fn r#stbc(&self) -> &u32 {
        &self.r#stbc
    }
    ///Return a mutable reference to `stbc`
    #[inline]
    pub fn mut_stbc(&mut self) -> &mut u32 {
        &mut self.r#stbc
    }
    ///Set the value of `stbc`
    #[inline]
    pub fn set_stbc(&mut self, value: u32) -> &mut Self {
        self.r#stbc = value.into();
        self
    }
    ///Builder method that sets the value of `stbc`. Useful for initializing the message.
    #[inline]
    pub fn init_stbc(mut self, value: u32) -> Self {
        self.r#stbc = value.into();
        self
    }
    ///Return a reference to `fec_coding`
    #[inline]
    pub fn r#fec_coding(&self) -> &u32 {
        &self.r#fec_coding
    }
    ///Return a mutable reference to `fec_coding`
    #[inline]
    pub fn mut_fec_coding(&mut self) -> &mut u32 {
        &mut self.r#fec_coding
    }
    ///Set the value of `fec_coding`
    #[inline]
    pub fn set_fec_coding(&mut self, value: u32) -> &mut Self {
        self.r#fec_coding = value.into();
        self
    }
    ///Builder method that sets the value of `fec_coding`. Useful for initializing the message.
    #[inline]
    pub fn init_fec_coding(mut self, value: u32) -> Self {
        self.r#fec_coding = value.into();
        self
    }
    ///Return a reference to `sgi`
    #[inline]
    pub fn r#sgi(&self) -> &u32 {
        &self.r#sgi
    }
    ///Return a mutable reference to `sgi`
    #[inline]
    pub fn mut_sgi(&mut self) -> &mut u32 {
        &mut self.r#sgi
    }
    ///Set the value of `sgi`
    #[inline]
    pub fn set_sgi(&mut self, value: u32) -> &mut Self {
        self.r#sgi = value.into();
        self
    }
    ///Builder method that sets the value of `sgi`. Useful for initializing the message.
    #[inline]
    pub fn init_sgi(mut self, value: u32) -> Self {
        self.r#sgi = value.into();
        self
    }
    ///Return a reference to `noise_floor`
    #[inline]
    pub fn r#noise_floor(&self) -> &i32 {
        &self.r#noise_floor
    }
    ///Return a mutable reference to `noise_floor`
    #[inline]
    pub fn mut_noise_floor(&mut self) -> &mut i32 {
        &mut self.r#noise_floor
    }
    ///Set the value of `noise_floor`
    #[inline]
    pub fn set_noise_floor(&mut self, value: i32) -> &mut Self {
        self.r#noise_floor = value.into();
        self
    }
    ///Builder method that sets the value of `noise_floor`. Useful for initializing the message.
    #[inline]
    pub fn init_noise_floor(mut self, value: i32) -> Self {
        self.r#noise_floor = value.into();
        self
    }
    ///Return a reference to `ampdu_cnt`
    #[inline]
    pub fn r#ampdu_cnt(&self) -> &u32 {
        &self.r#ampdu_cnt
    }
    ///Return a mutable reference to `ampdu_cnt`
    #[inline]
    pub fn mut_ampdu_cnt(&mut self) -> &mut u32 {
        &mut self.r#ampdu_cnt
    }
    ///Set the value of `ampdu_cnt`
    #[inline]
    pub fn set_ampdu_cnt(&mut self, value: u32) -> &mut Self {
        self.r#ampdu_cnt = value.into();
        self
    }
    ///Builder method that sets the value of `ampdu_cnt`. Useful for initializing the message.
    #[inline]
    pub fn init_ampdu_cnt(mut self, value: u32) -> Self {
        self.r#ampdu_cnt = value.into();
        self
    }
    ///Return a reference to `channel`
    #[inline]
    pub fn r#channel(&self) -> &u32 {
        &self.r#channel
    }
    ///Return a mutable reference to `channel`
    #[inline]
    pub fn mut_channel(&mut self) -> &mut u32 {
        &mut self.r#channel
    }
    ///Set the value of `channel`
    #[inline]
    pub fn set_channel(&mut self, value: u32) -> &mut Self {
        self.r#channel = value.into();
        self
    }
    ///Builder method that sets the value of `channel`. Useful for initializing the message.
    #[inline]
    pub fn init_channel(mut self, value: u32) -> Self {
        self.r#channel = value.into();
        self
    }
    ///Return a reference to `secondary_channel`
    #[inline]
    pub fn r#secondary_channel(&self) -> &u32 {
        &self.r#secondary_channel
    }
    ///Return a mutable reference to `secondary_channel`
    #[inline]
    pub fn mut_secondary_channel(&mut self) -> &mut u32 {
        &mut self.r#secondary_channel
    }
    ///Set the value of `secondary_channel`
    #[inline]
    pub fn set_secondary_channel(&mut self, value: u32) -> &mut Self {
        self.r#secondary_channel = value.into();
        self
    }
    ///Builder method that sets the value of `secondary_channel`. Useful for initializing the message.
    #[inline]
    pub fn init_secondary_channel(mut self, value: u32) -> Self {
        self.r#secondary_channel = value.into();
        self
    }
    ///Return a reference to `timestamp`
    #[inline]
    pub fn r#timestamp(&self) -> &u32 {
        &self.r#timestamp
    }
    ///Return a mutable reference to `timestamp`
    #[inline]
    pub fn mut_timestamp(&mut self) -> &mut u32 {
        &mut self.r#timestamp
    }
    ///Set the value of `timestamp`
    #[inline]
    pub fn set_timestamp(&mut self, value: u32) -> &mut Self {
        self.r#timestamp = value.into();
        self
    }
    ///Builder method that sets the value of `timestamp`. Useful for initializing the message.
    #[inline]
    pub fn init_timestamp(mut self, value: u32) -> Self {
        self.r#timestamp = value.into();
        self
    }
    ///Return a reference to `ant`
    #[inline]
    pub fn r#ant(&self) -> &u32 {
        &self.r#ant
    }
    ///Return a mutable reference to `ant`
    #[inline]
    pub fn mut_ant(&mut self) -> &mut u32 {
        &mut self.r#ant
    }
    ///Set the value of `ant`
    #[inline]
    pub fn set_ant(&mut self, value: u32) -> &mut Self {
        self.r#ant = value.into();
        self
    }
    ///Builder method that sets the value of `ant`. Useful for initializing the message.
    #[inline]
    pub fn init_ant(mut self, value: u32) -> Self {
        self.r#ant = value.into();
        self
    }
    ///Return a reference to `sig_len`
    #[inline]
    pub fn r#sig_len(&self) -> &u32 {
        &self.r#sig_len
    }
    ///Return a mutable reference to `sig_len`
    #[inline]
    pub fn mut_sig_len(&mut self) -> &mut u32 {
        &mut self.r#sig_len
    }
    ///Set the value of `sig_len`
    #[inline]
    pub fn set_sig_len(&mut self, value: u32) -> &mut Self {
        self.r#sig_len = value.into();
        self
    }
    ///Builder method that sets the value of `sig_len`. Useful for initializing the message.
    #[inline]
    pub fn init_sig_len(mut self, value: u32) -> Self {
        self.r#sig_len = value.into();
        self
    }
    ///Return a reference to `rx_state`
    #[inline]
    pub fn r#rx_state(&self) -> &u32 {
        &self.r#rx_state
    }
    ///Return a mutable reference to `rx_state`
    #[inline]
    pub fn mut_rx_state(&mut self) -> &mut u32 {
        &mut self.r#rx_state
    }
    ///Set the value of `rx_state`
    #[inline]
    pub fn set_rx_state(&mut self, value: u32) -> &mut Self {
        self.r#rx_state = value.into();
        self
    }
    ///Builder method that sets the value of `rx_state`. Useful for initializing the message.
    #[inline]
    pub fn init_rx_state(mut self, value: u32) -> Self {
        self.r#rx_state = value.into();
        self
    }
}
impl ::micropb::MessageDecode for r#wifi_pkt_rx_ctrl {
    fn decode<IMPL_MICROPB_READ: ::micropb::PbRead>(
        &mut self,
        decoder: &mut ::micropb::PbDecoder<IMPL_MICROPB_READ>,
        len: usize,
    ) -> Result<(), ::micropb::DecodeError<IMPL_MICROPB_READ::Error>> {
        use ::micropb::{FieldDecode, PbBytes, PbMap, PbString, PbVec};
        let before = decoder.bytes_read();
        while decoder.bytes_read() - before < len {
            let tag = decoder.decode_tag()?;
            match tag.field_num() {
                0 => return Err(::micropb::DecodeError::ZeroField),
                1u32 => {
                    let mut_ref = &mut self.r#rssi;
                    {
                        let val = decoder.decode_int32()?;
                        let val_ref = &val;
                        if *val_ref != 0 {
                            *mut_ref = val as _;
                        }
                    };
                }
                2u32 => {
                    let mut_ref = &mut self.r#rate;
                    {
                        let val = decoder.decode_varint32()?;
                        let val_ref = &val;
                        if *val_ref != 0 {
                            *mut_ref = val as _;
                        }
                    };
                }
                3u32 => {
                    let mut_ref = &mut self.r#sig_mode;
                    {
                        let val = decoder.decode_varint32()?;
                        let val_ref = &val;
                        if *val_ref != 0 {
                            *mut_ref = val as _;
                        }
                    };
                }
                4u32 => {
                    let mut_ref = &mut self.r#mcs;
                    {
                        let val = decoder.decode_varint32()?;
                        let val_ref = &val;
                        if *val_ref != 0 {
                            *mut_ref = val as _;
                        }
                    };
                }
                5u32 => {
                    let mut_ref = &mut self.r#cwb;
                    {
                        let val = decoder.decode_varint32()?;
                        let val_ref = &val;
                        if *val_ref != 0 {
                            *mut_ref = val as _;
                        }
                    };
                }
                6u32 => {
                    let mut_ref = &mut self.r#smoothing;
                    {
                        let val = decoder.decode_varint32()?;
                        let val_ref = &val;
                        if *val_ref != 0 {
                            *mut_ref = val as _;
                        }
                    };
                }
                7u32 => {
                    let mut_ref = &mut self.r#not_sounding;
                    {
                        let val = decoder.decode_varint32()?;
                        let val_ref = &val;
                        if *val_ref != 0 {
                            *mut_ref = val as _;
                        }
                    };
                }
                8u32 => {
                    let mut_ref = &mut self.r#aggregation;
                    {
                        let val = decoder.decode_varint32()?;
                        let val_ref = &val;
                        if *val_ref != 0 {
                            *mut_ref = val as _;
                        }
                    };
                }
                9u32 => {
                    let mut_ref = &mut self.r#stbc;
                    {
                        let val = decoder.decode_varint32()?;
                        let val_ref = &val;
                        if *val_ref != 0 {
                            *mut_ref = val as _;
                        }
                    };
                }
                10u32 => {
                    let mut_ref = &mut self.r#fec_coding;
                    {
                        let val = decoder.decode_varint32()?;
                        let val_ref = &val;
                        if *val_ref != 0 {
                            *mut_ref = val as _;
                        }
                    };
                }
                11u32 => {
                    let mut_ref = &mut self.r#sgi;
                    {
                        let val = decoder.decode_varint32()?;
                        let val_ref = &val;
                        if *val_ref != 0 {
                            *mut_ref = val as _;
                        }
                    };
                }
                12u32 => {
                    let mut_ref = &mut self.r#noise_floor;
                    {
                        let val = decoder.decode_int32()?;
                        let val_ref = &val;
                        if *val_ref != 0 {
                            *mut_ref = val as _;
                        }
                    };
                }
                13u32 => {
                    let mut_ref = &mut self.r#ampdu_cnt;
                    {
                        let val = decoder.decode_varint32()?;
                        let val_ref = &val;
                        if *val_ref != 0 {
                            *mut_ref = val as _;
                        }
                    };
                }
                14u32 => {
                    let mut_ref = &mut self.r#channel;
                    {
                        let val = decoder.decode_varint32()?;
                        let val_ref = &val;
                        if *val_ref != 0 {
                            *mut_ref = val as _;
                        }
                    };
                }
                15u32 => {
                    let mut_ref = &mut self.r#secondary_channel;
                    {
                        let val = decoder.decode_varint32()?;
                        let val_ref = &val;
                        if *val_ref != 0 {
                            *mut_ref = val as _;
                        }
                    };
                }
                16u32 => {
                    let mut_ref = &mut self.r#timestamp;
                    {
                        let val = decoder.decode_varint32()?;
                        let val_ref = &val;
                        if *val_ref != 0 {
                            *mut_ref = val as _;
                        }
                    };
                }
                17u32 => {
                    let mut_ref = &mut self.r#ant;
                    {
                        let val = decoder.decode_varint32()?;
                        let val_ref = &val;
                        if *val_ref != 0 {
                            *mut_ref = val as _;
                        }
                    };
                }
                18u32 => {
                    let mut_ref = &mut self.r#sig_len;
                    {
                        let val = decoder.decode_varint32()?;
                        let val_ref = &val;
                        if *val_ref != 0 {
                            *mut_ref = val as _;
                        }
                    };
                }
                19u32 => {
                    let mut_ref = &mut self.r#rx_state;
                    {
                        let val = decoder.decode_varint32()?;
                        let val_ref = &val;
                        if *val_ref != 0 {
                            *mut_ref = val as _;
                        }
                    };
                }
                _ => {
                    decoder.skip_wire_value(tag.wire_type())?;
                }
            }
        }
        Ok(())
    }
}
impl ::micropb::MessageEncode for r#wifi_pkt_rx_ctrl {
    const MAX_SIZE: ::core::option::Option<usize> = 'msg: {
        let mut max_size = 0;
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(10usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(5usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(5usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(5usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(5usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(5usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(5usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(5usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(5usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(5usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(5usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(10usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(5usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(5usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(5usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(5usize), |size| size + 2usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(5usize), |size| size + 2usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(5usize), |size| size + 2usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(5usize), |size| size + 2usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        ::core::option::Option::Some(max_size)
    };
    fn encode<IMPL_MICROPB_WRITE: ::micropb::PbWrite>(
        &self,
        encoder: &mut ::micropb::PbEncoder<IMPL_MICROPB_WRITE>,
    ) -> Result<(), IMPL_MICROPB_WRITE::Error> {
        use ::micropb::{FieldEncode, PbMap};
        {
            let val_ref = &self.r#rssi;
            if *val_ref != 0 {
                encoder.encode_varint32(8u32)?;
                encoder.encode_int32(*val_ref as _)?;
            }
        }
        {
            let val_ref = &self.r#rate;
            if *val_ref != 0 {
                encoder.encode_varint32(16u32)?;
                encoder.encode_varint32(*val_ref as _)?;
            }
        }
        {
            let val_ref = &self.r#sig_mode;
            if *val_ref != 0 {
                encoder.encode_varint32(24u32)?;
                encoder.encode_varint32(*val_ref as _)?;
            }
        }
        {
            let val_ref = &self.r#mcs;
            if *val_ref != 0 {
                encoder.encode_varint32(32u32)?;
                encoder.encode_varint32(*val_ref as _)?;
            }
        }
        {
            let val_ref = &self.r#cwb;
            if *val_ref != 0 {
                encoder.encode_varint32(40u32)?;
                encoder.encode_varint32(*val_ref as _)?;
            }
        }
        {
            let val_ref = &self.r#smoothing;
            if *val_ref != 0 {
                encoder.encode_varint32(48u32)?;
                encoder.encode_varint32(*val_ref as _)?;
            }
        }
        {
            let val_ref = &self.r#not_sounding;
            if *val_ref != 0 {
                encoder.encode_varint32(56u32)?;
                encoder.encode_varint32(*val_ref as _)?;
            }
        }
        {
            let val_ref = &self.r#aggregation;
            if *val_ref != 0 {
                encoder.encode_varint32(64u32)?;
                encoder.encode_varint32(*val_ref as _)?;
            }
        }
        {
            let val_ref = &self.r#stbc;
            if *val_ref != 0 {
                encoder.encode_varint32(72u32)?;
                encoder.encode_varint32(*val_ref as _)?;
            }
        }
        {
            let val_ref = &self.r#fec_coding;
            if *val_ref != 0 {
                encoder.encode_varint32(80u32)?;
                encoder.encode_varint32(*val_ref as _)?;
            }
        }
        {
            let val_ref = &self.r#sgi;
            if *val_ref != 0 {
                encoder.encode_varint32(88u32)?;
                encoder.encode_varint32(*val_ref as _)?;
            }
        }
        {
            let val_ref = &self.r#noise_floor;
            if *val_ref != 0 {
                encoder.encode_varint32(96u32)?;
                encoder.encode_int32(*val_ref as _)?;
            }
        }
        {
            let val_ref = &self.r#ampdu_cnt;
            if *val_ref != 0 {
                encoder.encode_varint32(104u32)?;
                encoder.encode_varint32(*val_ref as _)?;
            }
        }
        {
            let val_ref = &self.r#channel;
            if *val_ref != 0 {
                encoder.encode_varint32(112u32)?;
                encoder.encode_varint32(*val_ref as _)?;
            }
        }
        {
            let val_ref = &self.r#secondary_channel;
            if *val_ref != 0 {
                encoder.encode_varint32(120u32)?;
                encoder.encode_varint32(*val_ref as _)?;
            }
        }
        {
            let val_ref = &self.r#timestamp;
            if *val_ref != 0 {
                encoder.encode_varint32(128u32)?;
                encoder.encode_varint32(*val_ref as _)?;
            }
        }
        {
            let val_ref = &self.r#ant;
            if *val_ref != 0 {
                encoder.encode_varint32(136u32)?;
                encoder.encode_varint32(*val_ref as _)?;
            }
        }
        {
            let val_ref = &self.r#sig_len;
            if *val_ref != 0 {
                encoder.encode_varint32(144u32)?;
                encoder.encode_varint32(*val_ref as _)?;
            }
        }
        {
            let val_ref = &self.r#rx_state;
            if *val_ref != 0 {
                encoder.encode_varint32(152u32)?;
                encoder.encode_varint32(*val_ref as _)?;
            }
        }
        Ok(())
    }
    fn compute_size(&self) -> usize {
        use ::micropb::{FieldEncode, PbMap};
        let mut size = 0;
        {
            let val_ref = &self.r#rssi;
            if *val_ref != 0 {
                size += 1usize + ::micropb::size::sizeof_int32(*val_ref as _);
            }
        }
        {
            let val_ref = &self.r#rate;
            if *val_ref != 0 {
                size += 1usize + ::micropb::size::sizeof_varint32(*val_ref as _);
            }
        }
        {
            let val_ref = &self.r#sig_mode;
            if *val_ref != 0 {
                size += 1usize + ::micropb::size::sizeof_varint32(*val_ref as _);
            }
        }
        {
            let val_ref = &self.r#mcs;
            if *val_ref != 0 {
                size += 1usize + ::micropb::size::sizeof_varint32(*val_ref as _);
            }
        }
        {
            let val_ref = &self.r#cwb;
            if *val_ref != 0 {
                size += 1usize + ::micropb::size::sizeof_varint32(*val_ref as _);
            }
        }
        {
            let val_ref = &self.r#smoothing;
            if *val_ref != 0 {
                size += 1usize + ::micropb::size::sizeof_varint32(*val_ref as _);
            }
        }
        {
            let val_ref = &self.r#not_sounding;
            if *val_ref != 0 {
                size += 1usize + ::micropb::size::sizeof_varint32(*val_ref as _);
            }
        }
        {
            let val_ref = &self.r#aggregation;
            if *val_ref != 0 {
                size += 1usize + ::micropb::size::sizeof_varint32(*val_ref as _);
            }
        }
        {
            let val_ref = &self.r#stbc;
            if *val_ref != 0 {
                size += 1usize + ::micropb::size::sizeof_varint32(*val_ref as _);
            }
        }
        {
            let val_ref = &self.r#fec_coding;
            if *val_ref != 0 {
                size += 1usize + ::micropb::size::sizeof_varint32(*val_ref as _);
            }
        }
        {
            let val_ref = &self.r#sgi;
            if *val_ref != 0 {
                size += 1usize + ::micropb::size::sizeof_varint32(*val_ref as _);
            }
        }
        {
            let val_ref = &self.r#noise_floor;
            if *val_ref != 0 {
                size += 1usize + ::micropb::size::sizeof_int32(*val_ref as _);
            }
        }
        {
            let val_ref = &self.r#ampdu_cnt;
            if *val_ref != 0 {
                size += 1usize + ::micropb::size::sizeof_varint32(*val_ref as _);
            }
        }
        {
            let val_ref = &self.r#channel;
            if *val_ref != 0 {
                size += 1usize + ::micropb::size::sizeof_varint32(*val_ref as _);
            }
        }
        {
            let val_ref = &self.r#secondary_channel;
            if *val_ref != 0 {
                size += 1usize + ::micropb::size::sizeof_varint32(*val_ref as _);
            }
        }
        {
            let val_ref = &self.r#timestamp;
            if *val_ref != 0 {
                size += 2usize + ::micropb::size::sizeof_varint32(*val_ref as _);
            }
        }
        {
            let val_ref = &self.r#ant;
            if *val_ref != 0 {
                size += 2usize + ::micropb::size::sizeof_varint32(*val_ref as _);
            }
        }
        {
            let val_ref = &self.r#sig_len;
            if *val_ref != 0 {
                size += 2usize + ::micropb::size::sizeof_varint32(*val_ref as _);
            }
        }
        {
            let val_ref = &self.r#rx_state;
            if *val_ref != 0 {
                size += 2usize + ::micropb::size::sizeof_varint32(*val_ref as _);
            }
        }
        size
    }
}
pub mod wifi_promiscuous_pkt_ {
    #[derive(Debug, Default, PartialEq, Clone)]
    pub struct _Hazzer([u8; 1]);
    impl _Hazzer {
        ///New hazzer with all fields set to off
        #[inline]
        pub const fn _new() -> Self {
            Self([0; 1])
        }
        ///Query presence of `rx_ctrl`
        #[inline]
        pub const fn r#rx_ctrl(&self) -> bool {
            (self.0[0] & 1) != 0
        }
        ///Set presence of `rx_ctrl`
        #[inline]
        pub const fn set_rx_ctrl(&mut self) -> &mut Self {
            let elem = &mut self.0[0];
            *elem |= 1;
            self
        }
        ///Clear presence of `rx_ctrl`
        #[inline]
        pub const fn clear_rx_ctrl(&mut self) -> &mut Self {
            let elem = &mut self.0[0];
            *elem &= !1;
            self
        }
        ///Builder method that sets the presence of `rx_ctrl`. Useful for initializing the Hazzer.
        #[inline]
        pub const fn init_rx_ctrl(mut self) -> Self {
            self.set_rx_ctrl();
            self
        }
    }
}
#[derive(Debug, Default, Clone)]
pub struct r#wifi_promiscuous_pkt {
    pub r#rx_ctrl: r#wifi_pkt_rx_ctrl,
    pub r#payload: ::micropb::heapless::Vec<u8, 500>,
    pub _has: wifi_promiscuous_pkt_::_Hazzer,
}
impl ::core::cmp::PartialEq for r#wifi_promiscuous_pkt {
    fn eq(&self, other: &Self) -> bool {
        let mut ret = true;
        ret &= (self.r#rx_ctrl() == other.r#rx_ctrl());
        ret &= (self.r#payload == other.r#payload);
        ret
    }
}
impl r#wifi_promiscuous_pkt {
    ///Return a reference to `rx_ctrl` as an `Option`
    #[inline]
    pub fn r#rx_ctrl(&self) -> ::core::option::Option<&r#wifi_pkt_rx_ctrl> {
        self._has.r#rx_ctrl().then_some(&self.r#rx_ctrl)
    }
    ///Set the value and presence of `rx_ctrl`
    #[inline]
    pub fn set_rx_ctrl(&mut self, value: r#wifi_pkt_rx_ctrl) -> &mut Self {
        self._has.set_rx_ctrl();
        self.r#rx_ctrl = value.into();
        self
    }
    ///Return a mutable reference to `rx_ctrl` as an `Option`
    #[inline]
    pub fn mut_rx_ctrl(&mut self) -> ::core::option::Option<&mut r#wifi_pkt_rx_ctrl> {
        self._has.r#rx_ctrl().then_some(&mut self.r#rx_ctrl)
    }
    ///Clear the presence of `rx_ctrl`
    #[inline]
    pub fn clear_rx_ctrl(&mut self) -> &mut Self {
        self._has.clear_rx_ctrl();
        self
    }
    ///Take the value of `rx_ctrl` and clear its presence
    #[inline]
    pub fn take_rx_ctrl(&mut self) -> ::core::option::Option<r#wifi_pkt_rx_ctrl> {
        let val = self
            ._has
            .r#rx_ctrl()
            .then(|| ::core::mem::take(&mut self.r#rx_ctrl));
        self._has.clear_rx_ctrl();
        val
    }
    ///Builder method that sets the value of `rx_ctrl`. Useful for initializing the message.
    #[inline]
    pub fn init_rx_ctrl(mut self, value: r#wifi_pkt_rx_ctrl) -> Self {
        self.set_rx_ctrl(value);
        self
    }
    ///Return a reference to `payload`
    #[inline]
    pub fn r#payload(&self) -> &::micropb::heapless::Vec<u8, 500> {
        &self.r#payload
    }
    ///Return a mutable reference to `payload`
    #[inline]
    pub fn mut_payload(&mut self) -> &mut ::micropb::heapless::Vec<u8, 500> {
        &mut self.r#payload
    }
    ///Set the value of `payload`
    #[inline]
    pub fn set_payload(&mut self, value: ::micropb::heapless::Vec<u8, 500>) -> &mut Self {
        self.r#payload = value.into();
        self
    }
    ///Builder method that sets the value of `payload`. Useful for initializing the message.
    #[inline]
    pub fn init_payload(mut self, value: ::micropb::heapless::Vec<u8, 500>) -> Self {
        self.r#payload = value.into();
        self
    }
}
impl ::micropb::MessageDecode for r#wifi_promiscuous_pkt {
    fn decode<IMPL_MICROPB_READ: ::micropb::PbRead>(
        &mut self,
        decoder: &mut ::micropb::PbDecoder<IMPL_MICROPB_READ>,
        len: usize,
    ) -> Result<(), ::micropb::DecodeError<IMPL_MICROPB_READ::Error>> {
        use ::micropb::{FieldDecode, PbBytes, PbMap, PbString, PbVec};
        let before = decoder.bytes_read();
        while decoder.bytes_read() - before < len {
            let tag = decoder.decode_tag()?;
            match tag.field_num() {
                0 => return Err(::micropb::DecodeError::ZeroField),
                1u32 => {
                    let mut_ref = &mut self.r#rx_ctrl;
                    {
                        mut_ref.decode_len_delimited(decoder)?;
                    };
                    self._has.set_rx_ctrl();
                }
                2u32 => {
                    let mut_ref = &mut self.r#payload;
                    {
                        decoder.decode_bytes(mut_ref, ::micropb::Presence::Implicit)?;
                    };
                }
                _ => {
                    decoder.skip_wire_value(tag.wire_type())?;
                }
            }
        }
        Ok(())
    }
}
impl ::micropb::MessageEncode for r#wifi_promiscuous_pkt {
    const MAX_SIZE: ::core::option::Option<usize> = 'msg: {
        let mut max_size = 0;
        if let ::core::option::Option::Some(size) = ::micropb::const_map!(
            ::micropb::const_map!(
                <r#wifi_pkt_rx_ctrl as ::micropb::MessageEncode>::MAX_SIZE,
                |size| ::micropb::size::sizeof_len_record(size)
            ),
            |size| size + 1usize
        ) {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(502usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        ::core::option::Option::Some(max_size)
    };
    fn encode<IMPL_MICROPB_WRITE: ::micropb::PbWrite>(
        &self,
        encoder: &mut ::micropb::PbEncoder<IMPL_MICROPB_WRITE>,
    ) -> Result<(), IMPL_MICROPB_WRITE::Error> {
        use ::micropb::{FieldEncode, PbMap};
        {
            if let ::core::option::Option::Some(val_ref) = self.r#rx_ctrl() {
                encoder.encode_varint32(10u32)?;
                val_ref.encode_len_delimited(encoder)?;
            }
        }
        {
            let val_ref = &self.r#payload;
            if !val_ref.is_empty() {
                encoder.encode_varint32(18u32)?;
                encoder.encode_bytes(val_ref)?;
            }
        }
        Ok(())
    }
    fn compute_size(&self) -> usize {
        use ::micropb::{FieldEncode, PbMap};
        let mut size = 0;
        {
            if let ::core::option::Option::Some(val_ref) = self.r#rx_ctrl() {
                size += 1usize + ::micropb::size::sizeof_len_record(val_ref.compute_size());
            }
        }
        {
            let val_ref = &self.r#payload;
            if !val_ref.is_empty() {
                size += 1usize + ::micropb::size::sizeof_len_record(val_ref.len());
            }
        }
        size
    }
}
#[derive(Debug, Default, PartialEq, Clone)]
pub struct r#wifi_promiscuous_filter {
    pub r#filter_mask: u32,
}
impl r#wifi_promiscuous_filter {
    ///Return a reference to `filter_mask`
    #[inline]
    pub fn r#filter_mask(&self) -> &u32 {
        &self.r#filter_mask
    }
    ///Return a mutable reference to `filter_mask`
    #[inline]
    pub fn mut_filter_mask(&mut self) -> &mut u32 {
        &mut self.r#filter_mask
    }
    ///Set the value of `filter_mask`
    #[inline]
    pub fn set_filter_mask(&mut self, value: u32) -> &mut Self {
        self.r#filter_mask = value.into();
        self
    }
    ///Builder method that sets the value of `filter_mask`. Useful for initializing the message.
    #[inline]
    pub fn init_filter_mask(mut self, value: u32) -> Self {
        self.r#filter_mask = value.into();
        self
    }
}
impl ::micropb::MessageDecode for r#wifi_promiscuous_filter {
    fn decode<IMPL_MICROPB_READ: ::micropb::PbRead>(
        &mut self,
        decoder: &mut ::micropb::PbDecoder<IMPL_MICROPB_READ>,
        len: usize,
    ) -> Result<(), ::micropb::DecodeError<IMPL_MICROPB_READ::Error>> {
        use ::micropb::{FieldDecode, PbBytes, PbMap, PbString, PbVec};
        let before = decoder.bytes_read();
        while decoder.bytes_read() - before < len {
            let tag = decoder.decode_tag()?;
            match tag.field_num() {
                0 => return Err(::micropb::DecodeError::ZeroField),
                1u32 => {
                    let mut_ref = &mut self.r#filter_mask;
                    {
                        let val = decoder.decode_varint32()?;
                        let val_ref = &val;
                        if *val_ref != 0 {
                            *mut_ref = val as _;
                        }
                    };
                }
                _ => {
                    decoder.skip_wire_value(tag.wire_type())?;
                }
            }
        }
        Ok(())
    }
}
impl ::micropb::MessageEncode for r#wifi_promiscuous_filter {
    const MAX_SIZE: ::core::option::Option<usize> = 'msg: {
        let mut max_size = 0;
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(5usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        ::core::option::Option::Some(max_size)
    };
    fn encode<IMPL_MICROPB_WRITE: ::micropb::PbWrite>(
        &self,
        encoder: &mut ::micropb::PbEncoder<IMPL_MICROPB_WRITE>,
    ) -> Result<(), IMPL_MICROPB_WRITE::Error> {
        use ::micropb::{FieldEncode, PbMap};
        {
            let val_ref = &self.r#filter_mask;
            if *val_ref != 0 {
                encoder.encode_varint32(8u32)?;
                encoder.encode_varint32(*val_ref as _)?;
            }
        }
        Ok(())
    }
    fn compute_size(&self) -> usize {
        use ::micropb::{FieldEncode, PbMap};
        let mut size = 0;
        {
            let val_ref = &self.r#filter_mask;
            if *val_ref != 0 {
                size += 1usize + ::micropb::size::sizeof_varint32(*val_ref as _);
            }
        }
        size
    }
}
#[derive(Debug, Default, PartialEq, Clone)]
pub struct r#wifi_csi_config {
    pub r#lltf_en: bool,
    pub r#htltf_en: bool,
    pub r#stbc_htltf2_en: bool,
    pub r#ltf_merge_en: bool,
    pub r#channel_filter_en: bool,
    pub r#manu_scale: bool,
    pub r#shift: u32,
}
impl r#wifi_csi_config {
    ///Return a reference to `lltf_en`
    #[inline]
    pub fn r#lltf_en(&self) -> &bool {
        &self.r#lltf_en
    }
    ///Return a mutable reference to `lltf_en`
    #[inline]
    pub fn mut_lltf_en(&mut self) -> &mut bool {
        &mut self.r#lltf_en
    }
    ///Set the value of `lltf_en`
    #[inline]
    pub fn set_lltf_en(&mut self, value: bool) -> &mut Self {
        self.r#lltf_en = value.into();
        self
    }
    ///Builder method that sets the value of `lltf_en`. Useful for initializing the message.
    #[inline]
    pub fn init_lltf_en(mut self, value: bool) -> Self {
        self.r#lltf_en = value.into();
        self
    }
    ///Return a reference to `htltf_en`
    #[inline]
    pub fn r#htltf_en(&self) -> &bool {
        &self.r#htltf_en
    }
    ///Return a mutable reference to `htltf_en`
    #[inline]
    pub fn mut_htltf_en(&mut self) -> &mut bool {
        &mut self.r#htltf_en
    }
    ///Set the value of `htltf_en`
    #[inline]
    pub fn set_htltf_en(&mut self, value: bool) -> &mut Self {
        self.r#htltf_en = value.into();
        self
    }
    ///Builder method that sets the value of `htltf_en`. Useful for initializing the message.
    #[inline]
    pub fn init_htltf_en(mut self, value: bool) -> Self {
        self.r#htltf_en = value.into();
        self
    }
    ///Return a reference to `stbc_htltf2_en`
    #[inline]
    pub fn r#stbc_htltf2_en(&self) -> &bool {
        &self.r#stbc_htltf2_en
    }
    ///Return a mutable reference to `stbc_htltf2_en`
    #[inline]
    pub fn mut_stbc_htltf2_en(&mut self) -> &mut bool {
        &mut self.r#stbc_htltf2_en
    }
    ///Set the value of `stbc_htltf2_en`
    #[inline]
    pub fn set_stbc_htltf2_en(&mut self, value: bool) -> &mut Self {
        self.r#stbc_htltf2_en = value.into();
        self
    }
    ///Builder method that sets the value of `stbc_htltf2_en`. Useful for initializing the message.
    #[inline]
    pub fn init_stbc_htltf2_en(mut self, value: bool) -> Self {
        self.r#stbc_htltf2_en = value.into();
        self
    }
    ///Return a reference to `ltf_merge_en`
    #[inline]
    pub fn r#ltf_merge_en(&self) -> &bool {
        &self.r#ltf_merge_en
    }
    ///Return a mutable reference to `ltf_merge_en`
    #[inline]
    pub fn mut_ltf_merge_en(&mut self) -> &mut bool {
        &mut self.r#ltf_merge_en
    }
    ///Set the value of `ltf_merge_en`
    #[inline]
    pub fn set_ltf_merge_en(&mut self, value: bool) -> &mut Self {
        self.r#ltf_merge_en = value.into();
        self
    }
    ///Builder method that sets the value of `ltf_merge_en`. Useful for initializing the message.
    #[inline]
    pub fn init_ltf_merge_en(mut self, value: bool) -> Self {
        self.r#ltf_merge_en = value.into();
        self
    }
    ///Return a reference to `channel_filter_en`
    #[inline]
    pub fn r#channel_filter_en(&self) -> &bool {
        &self.r#channel_filter_en
    }
    ///Return a mutable reference to `channel_filter_en`
    #[inline]
    pub fn mut_channel_filter_en(&mut self) -> &mut bool {
        &mut self.r#channel_filter_en
    }
    ///Set the value of `channel_filter_en`
    #[inline]
    pub fn set_channel_filter_en(&mut self, value: bool) -> &mut Self {
        self.r#channel_filter_en = value.into();
        self
    }
    ///Builder method that sets the value of `channel_filter_en`. Useful for initializing the message.
    #[inline]
    pub fn init_channel_filter_en(mut self, value: bool) -> Self {
        self.r#channel_filter_en = value.into();
        self
    }
    ///Return a reference to `manu_scale`
    #[inline]
    pub fn r#manu_scale(&self) -> &bool {
        &self.r#manu_scale
    }
    ///Return a mutable reference to `manu_scale`
    #[inline]
    pub fn mut_manu_scale(&mut self) -> &mut bool {
        &mut self.r#manu_scale
    }
    ///Set the value of `manu_scale`
    #[inline]
    pub fn set_manu_scale(&mut self, value: bool) -> &mut Self {
        self.r#manu_scale = value.into();
        self
    }
    ///Builder method that sets the value of `manu_scale`. Useful for initializing the message.
    #[inline]
    pub fn init_manu_scale(mut self, value: bool) -> Self {
        self.r#manu_scale = value.into();
        self
    }
    ///Return a reference to `shift`
    #[inline]
    pub fn r#shift(&self) -> &u32 {
        &self.r#shift
    }
    ///Return a mutable reference to `shift`
    #[inline]
    pub fn mut_shift(&mut self) -> &mut u32 {
        &mut self.r#shift
    }
    ///Set the value of `shift`
    #[inline]
    pub fn set_shift(&mut self, value: u32) -> &mut Self {
        self.r#shift = value.into();
        self
    }
    ///Builder method that sets the value of `shift`. Useful for initializing the message.
    #[inline]
    pub fn init_shift(mut self, value: u32) -> Self {
        self.r#shift = value.into();
        self
    }
}
impl ::micropb::MessageDecode for r#wifi_csi_config {
    fn decode<IMPL_MICROPB_READ: ::micropb::PbRead>(
        &mut self,
        decoder: &mut ::micropb::PbDecoder<IMPL_MICROPB_READ>,
        len: usize,
    ) -> Result<(), ::micropb::DecodeError<IMPL_MICROPB_READ::Error>> {
        use ::micropb::{FieldDecode, PbBytes, PbMap, PbString, PbVec};
        let before = decoder.bytes_read();
        while decoder.bytes_read() - before < len {
            let tag = decoder.decode_tag()?;
            match tag.field_num() {
                0 => return Err(::micropb::DecodeError::ZeroField),
                1u32 => {
                    let mut_ref = &mut self.r#lltf_en;
                    {
                        let val = decoder.decode_bool()?;
                        let val_ref = &val;
                        if *val_ref {
                            *mut_ref = val as _;
                        }
                    };
                }
                2u32 => {
                    let mut_ref = &mut self.r#htltf_en;
                    {
                        let val = decoder.decode_bool()?;
                        let val_ref = &val;
                        if *val_ref {
                            *mut_ref = val as _;
                        }
                    };
                }
                3u32 => {
                    let mut_ref = &mut self.r#stbc_htltf2_en;
                    {
                        let val = decoder.decode_bool()?;
                        let val_ref = &val;
                        if *val_ref {
                            *mut_ref = val as _;
                        }
                    };
                }
                4u32 => {
                    let mut_ref = &mut self.r#ltf_merge_en;
                    {
                        let val = decoder.decode_bool()?;
                        let val_ref = &val;
                        if *val_ref {
                            *mut_ref = val as _;
                        }
                    };
                }
                5u32 => {
                    let mut_ref = &mut self.r#channel_filter_en;
                    {
                        let val = decoder.decode_bool()?;
                        let val_ref = &val;
                        if *val_ref {
                            *mut_ref = val as _;
                        }
                    };
                }
                6u32 => {
                    let mut_ref = &mut self.r#manu_scale;
                    {
                        let val = decoder.decode_bool()?;
                        let val_ref = &val;
                        if *val_ref {
                            *mut_ref = val as _;
                        }
                    };
                }
                7u32 => {
                    let mut_ref = &mut self.r#shift;
                    {
                        let val = decoder.decode_varint32()?;
                        let val_ref = &val;
                        if *val_ref != 0 {
                            *mut_ref = val as _;
                        }
                    };
                }
                _ => {
                    decoder.skip_wire_value(tag.wire_type())?;
                }
            }
        }
        Ok(())
    }
}
impl ::micropb::MessageEncode for r#wifi_csi_config {
    const MAX_SIZE: ::core::option::Option<usize> = 'msg: {
        let mut max_size = 0;
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(1usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(1usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(1usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(1usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(1usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(1usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(5usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        ::core::option::Option::Some(max_size)
    };
    fn encode<IMPL_MICROPB_WRITE: ::micropb::PbWrite>(
        &self,
        encoder: &mut ::micropb::PbEncoder<IMPL_MICROPB_WRITE>,
    ) -> Result<(), IMPL_MICROPB_WRITE::Error> {
        use ::micropb::{FieldEncode, PbMap};
        {
            let val_ref = &self.r#lltf_en;
            if *val_ref {
                encoder.encode_varint32(8u32)?;
                encoder.encode_bool(*val_ref)?;
            }
        }
        {
            let val_ref = &self.r#htltf_en;
            if *val_ref {
                encoder.encode_varint32(16u32)?;
                encoder.encode_bool(*val_ref)?;
            }
        }
        {
            let val_ref = &self.r#stbc_htltf2_en;
            if *val_ref {
                encoder.encode_varint32(24u32)?;
                encoder.encode_bool(*val_ref)?;
            }
        }
        {
            let val_ref = &self.r#ltf_merge_en;
            if *val_ref {
                encoder.encode_varint32(32u32)?;
                encoder.encode_bool(*val_ref)?;
            }
        }
        {
            let val_ref = &self.r#channel_filter_en;
            if *val_ref {
                encoder.encode_varint32(40u32)?;
                encoder.encode_bool(*val_ref)?;
            }
        }
        {
            let val_ref = &self.r#manu_scale;
            if *val_ref {
                encoder.encode_varint32(48u32)?;
                encoder.encode_bool(*val_ref)?;
            }
        }
        {
            let val_ref = &self.r#shift;
            if *val_ref != 0 {
                encoder.encode_varint32(56u32)?;
                encoder.encode_varint32(*val_ref as _)?;
            }
        }
        Ok(())
    }
    fn compute_size(&self) -> usize {
        use ::micropb::{FieldEncode, PbMap};
        let mut size = 0;
        {
            let val_ref = &self.r#lltf_en;
            if *val_ref {
                size += 1usize + 1;
            }
        }
        {
            let val_ref = &self.r#htltf_en;
            if *val_ref {
                size += 1usize + 1;
            }
        }
        {
            let val_ref = &self.r#stbc_htltf2_en;
            if *val_ref {
                size += 1usize + 1;
            }
        }
        {
            let val_ref = &self.r#ltf_merge_en;
            if *val_ref {
                size += 1usize + 1;
            }
        }
        {
            let val_ref = &self.r#channel_filter_en;
            if *val_ref {
                size += 1usize + 1;
            }
        }
        {
            let val_ref = &self.r#manu_scale;
            if *val_ref {
                size += 1usize + 1;
            }
        }
        {
            let val_ref = &self.r#shift;
            if *val_ref != 0 {
                size += 1usize + ::micropb::size::sizeof_varint32(*val_ref as _);
            }
        }
        size
    }
}
pub mod wifi_csi_info_ {
    #[derive(Debug, Default, PartialEq, Clone)]
    pub struct _Hazzer([u8; 1]);
    impl _Hazzer {
        ///New hazzer with all fields set to off
        #[inline]
        pub const fn _new() -> Self {
            Self([0; 1])
        }
        ///Query presence of `rx_ctrl`
        #[inline]
        pub const fn r#rx_ctrl(&self) -> bool {
            (self.0[0] & 1) != 0
        }
        ///Set presence of `rx_ctrl`
        #[inline]
        pub const fn set_rx_ctrl(&mut self) -> &mut Self {
            let elem = &mut self.0[0];
            *elem |= 1;
            self
        }
        ///Clear presence of `rx_ctrl`
        #[inline]
        pub const fn clear_rx_ctrl(&mut self) -> &mut Self {
            let elem = &mut self.0[0];
            *elem &= !1;
            self
        }
        ///Builder method that sets the presence of `rx_ctrl`. Useful for initializing the Hazzer.
        #[inline]
        pub const fn init_rx_ctrl(mut self) -> Self {
            self.set_rx_ctrl();
            self
        }
    }
}
#[derive(Debug, Default, Clone)]
pub struct r#wifi_csi_info {
    pub r#rx_ctrl: r#wifi_pkt_rx_ctrl,
    pub r#mac: ::micropb::heapless::Vec<u8, 6>,
    pub r#dmac: ::micropb::heapless::Vec<u8, 6>,
    pub r#first_word_invalid: bool,
    pub r#buf: ::micropb::heapless::Vec<u8, 30>,
    pub r#len: u32,
    pub _has: wifi_csi_info_::_Hazzer,
}
impl ::core::cmp::PartialEq for r#wifi_csi_info {
    fn eq(&self, other: &Self) -> bool {
        let mut ret = true;
        ret &= (self.r#rx_ctrl() == other.r#rx_ctrl());
        ret &= (self.r#mac == other.r#mac);
        ret &= (self.r#dmac == other.r#dmac);
        ret &= (self.r#first_word_invalid == other.r#first_word_invalid);
        ret &= (self.r#buf == other.r#buf);
        ret &= (self.r#len == other.r#len);
        ret
    }
}
impl r#wifi_csi_info {
    ///Return a reference to `rx_ctrl` as an `Option`
    #[inline]
    pub fn r#rx_ctrl(&self) -> ::core::option::Option<&r#wifi_pkt_rx_ctrl> {
        self._has.r#rx_ctrl().then_some(&self.r#rx_ctrl)
    }
    ///Set the value and presence of `rx_ctrl`
    #[inline]
    pub fn set_rx_ctrl(&mut self, value: r#wifi_pkt_rx_ctrl) -> &mut Self {
        self._has.set_rx_ctrl();
        self.r#rx_ctrl = value.into();
        self
    }
    ///Return a mutable reference to `rx_ctrl` as an `Option`
    #[inline]
    pub fn mut_rx_ctrl(&mut self) -> ::core::option::Option<&mut r#wifi_pkt_rx_ctrl> {
        self._has.r#rx_ctrl().then_some(&mut self.r#rx_ctrl)
    }
    ///Clear the presence of `rx_ctrl`
    #[inline]
    pub fn clear_rx_ctrl(&mut self) -> &mut Self {
        self._has.clear_rx_ctrl();
        self
    }
    ///Take the value of `rx_ctrl` and clear its presence
    #[inline]
    pub fn take_rx_ctrl(&mut self) -> ::core::option::Option<r#wifi_pkt_rx_ctrl> {
        let val = self
            ._has
            .r#rx_ctrl()
            .then(|| ::core::mem::take(&mut self.r#rx_ctrl));
        self._has.clear_rx_ctrl();
        val
    }
    ///Builder method that sets the value of `rx_ctrl`. Useful for initializing the message.
    #[inline]
    pub fn init_rx_ctrl(mut self, value: r#wifi_pkt_rx_ctrl) -> Self {
        self.set_rx_ctrl(value);
        self
    }
    ///Return a reference to `mac`
    #[inline]
    pub fn r#mac(&self) -> &::micropb::heapless::Vec<u8, 6> {
        &self.r#mac
    }
    ///Return a mutable reference to `mac`
    #[inline]
    pub fn mut_mac(&mut self) -> &mut ::micropb::heapless::Vec<u8, 6> {
        &mut self.r#mac
    }
    ///Set the value of `mac`
    #[inline]
    pub fn set_mac(&mut self, value: ::micropb::heapless::Vec<u8, 6>) -> &mut Self {
        self.r#mac = value.into();
        self
    }
    ///Builder method that sets the value of `mac`. Useful for initializing the message.
    #[inline]
    pub fn init_mac(mut self, value: ::micropb::heapless::Vec<u8, 6>) -> Self {
        self.r#mac = value.into();
        self
    }
    ///Return a reference to `dmac`
    #[inline]
    pub fn r#dmac(&self) -> &::micropb::heapless::Vec<u8, 6> {
        &self.r#dmac
    }
    ///Return a mutable reference to `dmac`
    #[inline]
    pub fn mut_dmac(&mut self) -> &mut ::micropb::heapless::Vec<u8, 6> {
        &mut self.r#dmac
    }
    ///Set the value of `dmac`
    #[inline]
    pub fn set_dmac(&mut self, value: ::micropb::heapless::Vec<u8, 6>) -> &mut Self {
        self.r#dmac = value.into();
        self
    }
    ///Builder method that sets the value of `dmac`. Useful for initializing the message.
    #[inline]
    pub fn init_dmac(mut self, value: ::micropb::heapless::Vec<u8, 6>) -> Self {
        self.r#dmac = value.into();
        self
    }
    ///Return a reference to `first_word_invalid`
    #[inline]
    pub fn r#first_word_invalid(&self) -> &bool {
        &self.r#first_word_invalid
    }
    ///Return a mutable reference to `first_word_invalid`
    #[inline]
    pub fn mut_first_word_invalid(&mut self) -> &mut bool {
        &mut self.r#first_word_invalid
    }
    ///Set the value of `first_word_invalid`
    #[inline]
    pub fn set_first_word_invalid(&mut self, value: bool) -> &mut Self {
        self.r#first_word_invalid = value.into();
        self
    }
    ///Builder method that sets the value of `first_word_invalid`. Useful for initializing the message.
    #[inline]
    pub fn init_first_word_invalid(mut self, value: bool) -> Self {
        self.r#first_word_invalid = value.into();
        self
    }
    ///Return a reference to `buf`
    #[inline]
    pub fn r#buf(&self) -> &::micropb::heapless::Vec<u8, 30> {
        &self.r#buf
    }
    ///Return a mutable reference to `buf`
    #[inline]
    pub fn mut_buf(&mut self) -> &mut ::micropb::heapless::Vec<u8, 30> {
        &mut self.r#buf
    }
    ///Set the value of `buf`
    #[inline]
    pub fn set_buf(&mut self, value: ::micropb::heapless::Vec<u8, 30>) -> &mut Self {
        self.r#buf = value.into();
        self
    }
    ///Builder method that sets the value of `buf`. Useful for initializing the message.
    #[inline]
    pub fn init_buf(mut self, value: ::micropb::heapless::Vec<u8, 30>) -> Self {
        self.r#buf = value.into();
        self
    }
    ///Return a reference to `len`
    #[inline]
    pub fn r#len(&self) -> &u32 {
        &self.r#len
    }
    ///Return a mutable reference to `len`
    #[inline]
    pub fn mut_len(&mut self) -> &mut u32 {
        &mut self.r#len
    }
    ///Set the value of `len`
    #[inline]
    pub fn set_len(&mut self, value: u32) -> &mut Self {
        self.r#len = value.into();
        self
    }
    ///Builder method that sets the value of `len`. Useful for initializing the message.
    #[inline]
    pub fn init_len(mut self, value: u32) -> Self {
        self.r#len = value.into();
        self
    }
}
impl ::micropb::MessageDecode for r#wifi_csi_info {
    fn decode<IMPL_MICROPB_READ: ::micropb::PbRead>(
        &mut self,
        decoder: &mut ::micropb::PbDecoder<IMPL_MICROPB_READ>,
        len: usize,
    ) -> Result<(), ::micropb::DecodeError<IMPL_MICROPB_READ::Error>> {
        use ::micropb::{FieldDecode, PbBytes, PbMap, PbString, PbVec};
        let before = decoder.bytes_read();
        while decoder.bytes_read() - before < len {
            let tag = decoder.decode_tag()?;
            match tag.field_num() {
                0 => return Err(::micropb::DecodeError::ZeroField),
                1u32 => {
                    let mut_ref = &mut self.r#rx_ctrl;
                    {
                        mut_ref.decode_len_delimited(decoder)?;
                    };
                    self._has.set_rx_ctrl();
                }
                2u32 => {
                    let mut_ref = &mut self.r#mac;
                    {
                        decoder.decode_bytes(mut_ref, ::micropb::Presence::Implicit)?;
                    };
                }
                3u32 => {
                    let mut_ref = &mut self.r#dmac;
                    {
                        decoder.decode_bytes(mut_ref, ::micropb::Presence::Implicit)?;
                    };
                }
                4u32 => {
                    let mut_ref = &mut self.r#first_word_invalid;
                    {
                        let val = decoder.decode_bool()?;
                        let val_ref = &val;
                        if *val_ref {
                            *mut_ref = val as _;
                        }
                    };
                }
                5u32 => {
                    let mut_ref = &mut self.r#buf;
                    {
                        decoder.decode_bytes(mut_ref, ::micropb::Presence::Implicit)?;
                    };
                }
                6u32 => {
                    let mut_ref = &mut self.r#len;
                    {
                        let val = decoder.decode_varint32()?;
                        let val_ref = &val;
                        if *val_ref != 0 {
                            *mut_ref = val as _;
                        }
                    };
                }
                _ => {
                    decoder.skip_wire_value(tag.wire_type())?;
                }
            }
        }
        Ok(())
    }
}
impl ::micropb::MessageEncode for r#wifi_csi_info {
    const MAX_SIZE: ::core::option::Option<usize> = 'msg: {
        let mut max_size = 0;
        if let ::core::option::Option::Some(size) = ::micropb::const_map!(
            ::micropb::const_map!(
                <r#wifi_pkt_rx_ctrl as ::micropb::MessageEncode>::MAX_SIZE,
                |size| ::micropb::size::sizeof_len_record(size)
            ),
            |size| size + 1usize
        ) {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(7usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(7usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(1usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(31usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(5usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        ::core::option::Option::Some(max_size)
    };
    fn encode<IMPL_MICROPB_WRITE: ::micropb::PbWrite>(
        &self,
        encoder: &mut ::micropb::PbEncoder<IMPL_MICROPB_WRITE>,
    ) -> Result<(), IMPL_MICROPB_WRITE::Error> {
        use ::micropb::{FieldEncode, PbMap};
        {
            if let ::core::option::Option::Some(val_ref) = self.r#rx_ctrl() {
                encoder.encode_varint32(10u32)?;
                val_ref.encode_len_delimited(encoder)?;
            }
        }
        {
            let val_ref = &self.r#mac;
            if !val_ref.is_empty() {
                encoder.encode_varint32(18u32)?;
                encoder.encode_bytes(val_ref)?;
            }
        }
        {
            let val_ref = &self.r#dmac;
            if !val_ref.is_empty() {
                encoder.encode_varint32(26u32)?;
                encoder.encode_bytes(val_ref)?;
            }
        }
        {
            let val_ref = &self.r#first_word_invalid;
            if *val_ref {
                encoder.encode_varint32(32u32)?;
                encoder.encode_bool(*val_ref)?;
            }
        }
        {
            let val_ref = &self.r#buf;
            if !val_ref.is_empty() {
                encoder.encode_varint32(42u32)?;
                encoder.encode_bytes(val_ref)?;
            }
        }
        {
            let val_ref = &self.r#len;
            if *val_ref != 0 {
                encoder.encode_varint32(48u32)?;
                encoder.encode_varint32(*val_ref as _)?;
            }
        }
        Ok(())
    }
    fn compute_size(&self) -> usize {
        use ::micropb::{FieldEncode, PbMap};
        let mut size = 0;
        {
            if let ::core::option::Option::Some(val_ref) = self.r#rx_ctrl() {
                size += 1usize + ::micropb::size::sizeof_len_record(val_ref.compute_size());
            }
        }
        {
            let val_ref = &self.r#mac;
            if !val_ref.is_empty() {
                size += 1usize + ::micropb::size::sizeof_len_record(val_ref.len());
            }
        }
        {
            let val_ref = &self.r#dmac;
            if !val_ref.is_empty() {
                size += 1usize + ::micropb::size::sizeof_len_record(val_ref.len());
            }
        }
        {
            let val_ref = &self.r#first_word_invalid;
            if *val_ref {
                size += 1usize + 1;
            }
        }
        {
            let val_ref = &self.r#buf;
            if !val_ref.is_empty() {
                size += 1usize + ::micropb::size::sizeof_len_record(val_ref.len());
            }
        }
        {
            let val_ref = &self.r#len;
            if *val_ref != 0 {
                size += 1usize + ::micropb::size::sizeof_varint32(*val_ref as _);
            }
        }
        size
    }
}
#[derive(Debug, Default, PartialEq, Clone)]
pub struct r#wifi_ant_gpio {
    pub r#gpio_select: u32,
    pub r#gpio_num: u32,
}
impl r#wifi_ant_gpio {
    ///Return a reference to `gpio_select`
    #[inline]
    pub fn r#gpio_select(&self) -> &u32 {
        &self.r#gpio_select
    }
    ///Return a mutable reference to `gpio_select`
    #[inline]
    pub fn mut_gpio_select(&mut self) -> &mut u32 {
        &mut self.r#gpio_select
    }
    ///Set the value of `gpio_select`
    #[inline]
    pub fn set_gpio_select(&mut self, value: u32) -> &mut Self {
        self.r#gpio_select = value.into();
        self
    }
    ///Builder method that sets the value of `gpio_select`. Useful for initializing the message.
    #[inline]
    pub fn init_gpio_select(mut self, value: u32) -> Self {
        self.r#gpio_select = value.into();
        self
    }
    ///Return a reference to `gpio_num`
    #[inline]
    pub fn r#gpio_num(&self) -> &u32 {
        &self.r#gpio_num
    }
    ///Return a mutable reference to `gpio_num`
    #[inline]
    pub fn mut_gpio_num(&mut self) -> &mut u32 {
        &mut self.r#gpio_num
    }
    ///Set the value of `gpio_num`
    #[inline]
    pub fn set_gpio_num(&mut self, value: u32) -> &mut Self {
        self.r#gpio_num = value.into();
        self
    }
    ///Builder method that sets the value of `gpio_num`. Useful for initializing the message.
    #[inline]
    pub fn init_gpio_num(mut self, value: u32) -> Self {
        self.r#gpio_num = value.into();
        self
    }
}
impl ::micropb::MessageDecode for r#wifi_ant_gpio {
    fn decode<IMPL_MICROPB_READ: ::micropb::PbRead>(
        &mut self,
        decoder: &mut ::micropb::PbDecoder<IMPL_MICROPB_READ>,
        len: usize,
    ) -> Result<(), ::micropb::DecodeError<IMPL_MICROPB_READ::Error>> {
        use ::micropb::{FieldDecode, PbBytes, PbMap, PbString, PbVec};
        let before = decoder.bytes_read();
        while decoder.bytes_read() - before < len {
            let tag = decoder.decode_tag()?;
            match tag.field_num() {
                0 => return Err(::micropb::DecodeError::ZeroField),
                1u32 => {
                    let mut_ref = &mut self.r#gpio_select;
                    {
                        let val = decoder.decode_varint32()?;
                        let val_ref = &val;
                        if *val_ref != 0 {
                            *mut_ref = val as _;
                        }
                    };
                }
                2u32 => {
                    let mut_ref = &mut self.r#gpio_num;
                    {
                        let val = decoder.decode_varint32()?;
                        let val_ref = &val;
                        if *val_ref != 0 {
                            *mut_ref = val as _;
                        }
                    };
                }
                _ => {
                    decoder.skip_wire_value(tag.wire_type())?;
                }
            }
        }
        Ok(())
    }
}
impl ::micropb::MessageEncode for r#wifi_ant_gpio {
    const MAX_SIZE: ::core::option::Option<usize> = 'msg: {
        let mut max_size = 0;
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(5usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(5usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        ::core::option::Option::Some(max_size)
    };
    fn encode<IMPL_MICROPB_WRITE: ::micropb::PbWrite>(
        &self,
        encoder: &mut ::micropb::PbEncoder<IMPL_MICROPB_WRITE>,
    ) -> Result<(), IMPL_MICROPB_WRITE::Error> {
        use ::micropb::{FieldEncode, PbMap};
        {
            let val_ref = &self.r#gpio_select;
            if *val_ref != 0 {
                encoder.encode_varint32(8u32)?;
                encoder.encode_varint32(*val_ref as _)?;
            }
        }
        {
            let val_ref = &self.r#gpio_num;
            if *val_ref != 0 {
                encoder.encode_varint32(16u32)?;
                encoder.encode_varint32(*val_ref as _)?;
            }
        }
        Ok(())
    }
    fn compute_size(&self) -> usize {
        use ::micropb::{FieldEncode, PbMap};
        let mut size = 0;
        {
            let val_ref = &self.r#gpio_select;
            if *val_ref != 0 {
                size += 1usize + ::micropb::size::sizeof_varint32(*val_ref as _);
            }
        }
        {
            let val_ref = &self.r#gpio_num;
            if *val_ref != 0 {
                size += 1usize + ::micropb::size::sizeof_varint32(*val_ref as _);
            }
        }
        size
    }
}
#[derive(Debug, Default, PartialEq, Clone)]
pub struct r#wifi_ant_gpio_config {
    pub r#gpio_cfgs: ::micropb::heapless::Vec<r#wifi_ant_gpio, 8>,
}
impl r#wifi_ant_gpio_config {}
impl ::micropb::MessageDecode for r#wifi_ant_gpio_config {
    fn decode<IMPL_MICROPB_READ: ::micropb::PbRead>(
        &mut self,
        decoder: &mut ::micropb::PbDecoder<IMPL_MICROPB_READ>,
        len: usize,
    ) -> Result<(), ::micropb::DecodeError<IMPL_MICROPB_READ::Error>> {
        use ::micropb::{FieldDecode, PbBytes, PbMap, PbString, PbVec};
        let before = decoder.bytes_read();
        while decoder.bytes_read() - before < len {
            let tag = decoder.decode_tag()?;
            match tag.field_num() {
                0 => return Err(::micropb::DecodeError::ZeroField),
                1u32 => {
                    let mut val: r#wifi_ant_gpio = ::core::default::Default::default();
                    let mut_ref = &mut val;
                    {
                        mut_ref.decode_len_delimited(decoder)?;
                    };
                    if let (Err(_), false) = (
                        self.r#gpio_cfgs.pb_push(val),
                        decoder.ignore_repeated_cap_err,
                    ) {
                        return Err(::micropb::DecodeError::Capacity);
                    }
                }
                _ => {
                    decoder.skip_wire_value(tag.wire_type())?;
                }
            }
        }
        Ok(())
    }
}
impl ::micropb::MessageEncode for r#wifi_ant_gpio_config {
    const MAX_SIZE: ::core::option::Option<usize> = 'msg: {
        let mut max_size = 0;
        if let ::core::option::Option::Some(size) = ::micropb::const_map!(
            ::micropb::const_map!(
                <r#wifi_ant_gpio as ::micropb::MessageEncode>::MAX_SIZE,
                |size| ::micropb::size::sizeof_len_record(size)
            ),
            |size| (size + 1usize) * 8usize
        ) {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        ::core::option::Option::Some(max_size)
    };
    fn encode<IMPL_MICROPB_WRITE: ::micropb::PbWrite>(
        &self,
        encoder: &mut ::micropb::PbEncoder<IMPL_MICROPB_WRITE>,
    ) -> Result<(), IMPL_MICROPB_WRITE::Error> {
        use ::micropb::{FieldEncode, PbMap};
        {
            for val_ref in self.r#gpio_cfgs.iter() {
                encoder.encode_varint32(10u32)?;
                val_ref.encode_len_delimited(encoder)?;
            }
        }
        Ok(())
    }
    fn compute_size(&self) -> usize {
        use ::micropb::{FieldEncode, PbMap};
        let mut size = 0;
        {
            for val_ref in self.r#gpio_cfgs.iter() {
                size += 1usize + ::micropb::size::sizeof_len_record(val_ref.compute_size());
            }
        }
        size
    }
}
#[derive(Debug, Default, PartialEq, Clone)]
pub struct r#wifi_ant_config {
    pub r#rx_ant_mode: i32,
    pub r#rx_ant_default: i32,
    pub r#tx_ant_mode: i32,
    pub r#enabled_ant0: u32,
    pub r#enabled_ant1: u32,
}
impl r#wifi_ant_config {
    ///Return a reference to `rx_ant_mode`
    #[inline]
    pub fn r#rx_ant_mode(&self) -> &i32 {
        &self.r#rx_ant_mode
    }
    ///Return a mutable reference to `rx_ant_mode`
    #[inline]
    pub fn mut_rx_ant_mode(&mut self) -> &mut i32 {
        &mut self.r#rx_ant_mode
    }
    ///Set the value of `rx_ant_mode`
    #[inline]
    pub fn set_rx_ant_mode(&mut self, value: i32) -> &mut Self {
        self.r#rx_ant_mode = value.into();
        self
    }
    ///Builder method that sets the value of `rx_ant_mode`. Useful for initializing the message.
    #[inline]
    pub fn init_rx_ant_mode(mut self, value: i32) -> Self {
        self.r#rx_ant_mode = value.into();
        self
    }
    ///Return a reference to `rx_ant_default`
    #[inline]
    pub fn r#rx_ant_default(&self) -> &i32 {
        &self.r#rx_ant_default
    }
    ///Return a mutable reference to `rx_ant_default`
    #[inline]
    pub fn mut_rx_ant_default(&mut self) -> &mut i32 {
        &mut self.r#rx_ant_default
    }
    ///Set the value of `rx_ant_default`
    #[inline]
    pub fn set_rx_ant_default(&mut self, value: i32) -> &mut Self {
        self.r#rx_ant_default = value.into();
        self
    }
    ///Builder method that sets the value of `rx_ant_default`. Useful for initializing the message.
    #[inline]
    pub fn init_rx_ant_default(mut self, value: i32) -> Self {
        self.r#rx_ant_default = value.into();
        self
    }
    ///Return a reference to `tx_ant_mode`
    #[inline]
    pub fn r#tx_ant_mode(&self) -> &i32 {
        &self.r#tx_ant_mode
    }
    ///Return a mutable reference to `tx_ant_mode`
    #[inline]
    pub fn mut_tx_ant_mode(&mut self) -> &mut i32 {
        &mut self.r#tx_ant_mode
    }
    ///Set the value of `tx_ant_mode`
    #[inline]
    pub fn set_tx_ant_mode(&mut self, value: i32) -> &mut Self {
        self.r#tx_ant_mode = value.into();
        self
    }
    ///Builder method that sets the value of `tx_ant_mode`. Useful for initializing the message.
    #[inline]
    pub fn init_tx_ant_mode(mut self, value: i32) -> Self {
        self.r#tx_ant_mode = value.into();
        self
    }
    ///Return a reference to `enabled_ant0`
    #[inline]
    pub fn r#enabled_ant0(&self) -> &u32 {
        &self.r#enabled_ant0
    }
    ///Return a mutable reference to `enabled_ant0`
    #[inline]
    pub fn mut_enabled_ant0(&mut self) -> &mut u32 {
        &mut self.r#enabled_ant0
    }
    ///Set the value of `enabled_ant0`
    #[inline]
    pub fn set_enabled_ant0(&mut self, value: u32) -> &mut Self {
        self.r#enabled_ant0 = value.into();
        self
    }
    ///Builder method that sets the value of `enabled_ant0`. Useful for initializing the message.
    #[inline]
    pub fn init_enabled_ant0(mut self, value: u32) -> Self {
        self.r#enabled_ant0 = value.into();
        self
    }
    ///Return a reference to `enabled_ant1`
    #[inline]
    pub fn r#enabled_ant1(&self) -> &u32 {
        &self.r#enabled_ant1
    }
    ///Return a mutable reference to `enabled_ant1`
    #[inline]
    pub fn mut_enabled_ant1(&mut self) -> &mut u32 {
        &mut self.r#enabled_ant1
    }
    ///Set the value of `enabled_ant1`
    #[inline]
    pub fn set_enabled_ant1(&mut self, value: u32) -> &mut Self {
        self.r#enabled_ant1 = value.into();
        self
    }
    ///Builder method that sets the value of `enabled_ant1`. Useful for initializing the message.
    #[inline]
    pub fn init_enabled_ant1(mut self, value: u32) -> Self {
        self.r#enabled_ant1 = value.into();
        self
    }
}
impl ::micropb::MessageDecode for r#wifi_ant_config {
    fn decode<IMPL_MICROPB_READ: ::micropb::PbRead>(
        &mut self,
        decoder: &mut ::micropb::PbDecoder<IMPL_MICROPB_READ>,
        len: usize,
    ) -> Result<(), ::micropb::DecodeError<IMPL_MICROPB_READ::Error>> {
        use ::micropb::{FieldDecode, PbBytes, PbMap, PbString, PbVec};
        let before = decoder.bytes_read();
        while decoder.bytes_read() - before < len {
            let tag = decoder.decode_tag()?;
            match tag.field_num() {
                0 => return Err(::micropb::DecodeError::ZeroField),
                1u32 => {
                    let mut_ref = &mut self.r#rx_ant_mode;
                    {
                        let val = decoder.decode_int32()?;
                        let val_ref = &val;
                        if *val_ref != 0 {
                            *mut_ref = val as _;
                        }
                    };
                }
                2u32 => {
                    let mut_ref = &mut self.r#rx_ant_default;
                    {
                        let val = decoder.decode_int32()?;
                        let val_ref = &val;
                        if *val_ref != 0 {
                            *mut_ref = val as _;
                        }
                    };
                }
                3u32 => {
                    let mut_ref = &mut self.r#tx_ant_mode;
                    {
                        let val = decoder.decode_int32()?;
                        let val_ref = &val;
                        if *val_ref != 0 {
                            *mut_ref = val as _;
                        }
                    };
                }
                4u32 => {
                    let mut_ref = &mut self.r#enabled_ant0;
                    {
                        let val = decoder.decode_varint32()?;
                        let val_ref = &val;
                        if *val_ref != 0 {
                            *mut_ref = val as _;
                        }
                    };
                }
                5u32 => {
                    let mut_ref = &mut self.r#enabled_ant1;
                    {
                        let val = decoder.decode_varint32()?;
                        let val_ref = &val;
                        if *val_ref != 0 {
                            *mut_ref = val as _;
                        }
                    };
                }
                _ => {
                    decoder.skip_wire_value(tag.wire_type())?;
                }
            }
        }
        Ok(())
    }
}
impl ::micropb::MessageEncode for r#wifi_ant_config {
    const MAX_SIZE: ::core::option::Option<usize> = 'msg: {
        let mut max_size = 0;
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(10usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(10usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(10usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(5usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(5usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        ::core::option::Option::Some(max_size)
    };
    fn encode<IMPL_MICROPB_WRITE: ::micropb::PbWrite>(
        &self,
        encoder: &mut ::micropb::PbEncoder<IMPL_MICROPB_WRITE>,
    ) -> Result<(), IMPL_MICROPB_WRITE::Error> {
        use ::micropb::{FieldEncode, PbMap};
        {
            let val_ref = &self.r#rx_ant_mode;
            if *val_ref != 0 {
                encoder.encode_varint32(8u32)?;
                encoder.encode_int32(*val_ref as _)?;
            }
        }
        {
            let val_ref = &self.r#rx_ant_default;
            if *val_ref != 0 {
                encoder.encode_varint32(16u32)?;
                encoder.encode_int32(*val_ref as _)?;
            }
        }
        {
            let val_ref = &self.r#tx_ant_mode;
            if *val_ref != 0 {
                encoder.encode_varint32(24u32)?;
                encoder.encode_int32(*val_ref as _)?;
            }
        }
        {
            let val_ref = &self.r#enabled_ant0;
            if *val_ref != 0 {
                encoder.encode_varint32(32u32)?;
                encoder.encode_varint32(*val_ref as _)?;
            }
        }
        {
            let val_ref = &self.r#enabled_ant1;
            if *val_ref != 0 {
                encoder.encode_varint32(40u32)?;
                encoder.encode_varint32(*val_ref as _)?;
            }
        }
        Ok(())
    }
    fn compute_size(&self) -> usize {
        use ::micropb::{FieldEncode, PbMap};
        let mut size = 0;
        {
            let val_ref = &self.r#rx_ant_mode;
            if *val_ref != 0 {
                size += 1usize + ::micropb::size::sizeof_int32(*val_ref as _);
            }
        }
        {
            let val_ref = &self.r#rx_ant_default;
            if *val_ref != 0 {
                size += 1usize + ::micropb::size::sizeof_int32(*val_ref as _);
            }
        }
        {
            let val_ref = &self.r#tx_ant_mode;
            if *val_ref != 0 {
                size += 1usize + ::micropb::size::sizeof_int32(*val_ref as _);
            }
        }
        {
            let val_ref = &self.r#enabled_ant0;
            if *val_ref != 0 {
                size += 1usize + ::micropb::size::sizeof_varint32(*val_ref as _);
            }
        }
        {
            let val_ref = &self.r#enabled_ant1;
            if *val_ref != 0 {
                size += 1usize + ::micropb::size::sizeof_varint32(*val_ref as _);
            }
        }
        size
    }
}
#[derive(Debug, Default, PartialEq, Clone)]
pub struct r#wifi_action_tx_req {
    pub r#ifx: i32,
    pub r#dest_mac: ::micropb::heapless::Vec<u8, 6>,
    pub r#no_ack: bool,
    pub r#data_len: u32,
    pub r#data: ::micropb::heapless::Vec<u8, 16>,
}
impl r#wifi_action_tx_req {
    ///Return a reference to `ifx`
    #[inline]
    pub fn r#ifx(&self) -> &i32 {
        &self.r#ifx
    }
    ///Return a mutable reference to `ifx`
    #[inline]
    pub fn mut_ifx(&mut self) -> &mut i32 {
        &mut self.r#ifx
    }
    ///Set the value of `ifx`
    #[inline]
    pub fn set_ifx(&mut self, value: i32) -> &mut Self {
        self.r#ifx = value.into();
        self
    }
    ///Builder method that sets the value of `ifx`. Useful for initializing the message.
    #[inline]
    pub fn init_ifx(mut self, value: i32) -> Self {
        self.r#ifx = value.into();
        self
    }
    ///Return a reference to `dest_mac`
    #[inline]
    pub fn r#dest_mac(&self) -> &::micropb::heapless::Vec<u8, 6> {
        &self.r#dest_mac
    }
    ///Return a mutable reference to `dest_mac`
    #[inline]
    pub fn mut_dest_mac(&mut self) -> &mut ::micropb::heapless::Vec<u8, 6> {
        &mut self.r#dest_mac
    }
    ///Set the value of `dest_mac`
    #[inline]
    pub fn set_dest_mac(&mut self, value: ::micropb::heapless::Vec<u8, 6>) -> &mut Self {
        self.r#dest_mac = value.into();
        self
    }
    ///Builder method that sets the value of `dest_mac`. Useful for initializing the message.
    #[inline]
    pub fn init_dest_mac(mut self, value: ::micropb::heapless::Vec<u8, 6>) -> Self {
        self.r#dest_mac = value.into();
        self
    }
    ///Return a reference to `no_ack`
    #[inline]
    pub fn r#no_ack(&self) -> &bool {
        &self.r#no_ack
    }
    ///Return a mutable reference to `no_ack`
    #[inline]
    pub fn mut_no_ack(&mut self) -> &mut bool {
        &mut self.r#no_ack
    }
    ///Set the value of `no_ack`
    #[inline]
    pub fn set_no_ack(&mut self, value: bool) -> &mut Self {
        self.r#no_ack = value.into();
        self
    }
    ///Builder method that sets the value of `no_ack`. Useful for initializing the message.
    #[inline]
    pub fn init_no_ack(mut self, value: bool) -> Self {
        self.r#no_ack = value.into();
        self
    }
    ///Return a reference to `data_len`
    #[inline]
    pub fn r#data_len(&self) -> &u32 {
        &self.r#data_len
    }
    ///Return a mutable reference to `data_len`
    #[inline]
    pub fn mut_data_len(&mut self) -> &mut u32 {
        &mut self.r#data_len
    }
    ///Set the value of `data_len`
    #[inline]
    pub fn set_data_len(&mut self, value: u32) -> &mut Self {
        self.r#data_len = value.into();
        self
    }
    ///Builder method that sets the value of `data_len`. Useful for initializing the message.
    #[inline]
    pub fn init_data_len(mut self, value: u32) -> Self {
        self.r#data_len = value.into();
        self
    }
    ///Return a reference to `data`
    #[inline]
    pub fn r#data(&self) -> &::micropb::heapless::Vec<u8, 16> {
        &self.r#data
    }
    ///Return a mutable reference to `data`
    #[inline]
    pub fn mut_data(&mut self) -> &mut ::micropb::heapless::Vec<u8, 16> {
        &mut self.r#data
    }
    ///Set the value of `data`
    #[inline]
    pub fn set_data(&mut self, value: ::micropb::heapless::Vec<u8, 16>) -> &mut Self {
        self.r#data = value.into();
        self
    }
    ///Builder method that sets the value of `data`. Useful for initializing the message.
    #[inline]
    pub fn init_data(mut self, value: ::micropb::heapless::Vec<u8, 16>) -> Self {
        self.r#data = value.into();
        self
    }
}
impl ::micropb::MessageDecode for r#wifi_action_tx_req {
    fn decode<IMPL_MICROPB_READ: ::micropb::PbRead>(
        &mut self,
        decoder: &mut ::micropb::PbDecoder<IMPL_MICROPB_READ>,
        len: usize,
    ) -> Result<(), ::micropb::DecodeError<IMPL_MICROPB_READ::Error>> {
        use ::micropb::{FieldDecode, PbBytes, PbMap, PbString, PbVec};
        let before = decoder.bytes_read();
        while decoder.bytes_read() - before < len {
            let tag = decoder.decode_tag()?;
            match tag.field_num() {
                0 => return Err(::micropb::DecodeError::ZeroField),
                1u32 => {
                    let mut_ref = &mut self.r#ifx;
                    {
                        let val = decoder.decode_int32()?;
                        let val_ref = &val;
                        if *val_ref != 0 {
                            *mut_ref = val as _;
                        }
                    };
                }
                2u32 => {
                    let mut_ref = &mut self.r#dest_mac;
                    {
                        decoder.decode_bytes(mut_ref, ::micropb::Presence::Implicit)?;
                    };
                }
                3u32 => {
                    let mut_ref = &mut self.r#no_ack;
                    {
                        let val = decoder.decode_bool()?;
                        let val_ref = &val;
                        if *val_ref {
                            *mut_ref = val as _;
                        }
                    };
                }
                4u32 => {
                    let mut_ref = &mut self.r#data_len;
                    {
                        let val = decoder.decode_varint32()?;
                        let val_ref = &val;
                        if *val_ref != 0 {
                            *mut_ref = val as _;
                        }
                    };
                }
                5u32 => {
                    let mut_ref = &mut self.r#data;
                    {
                        decoder.decode_bytes(mut_ref, ::micropb::Presence::Implicit)?;
                    };
                }
                _ => {
                    decoder.skip_wire_value(tag.wire_type())?;
                }
            }
        }
        Ok(())
    }
}
impl ::micropb::MessageEncode for r#wifi_action_tx_req {
    const MAX_SIZE: ::core::option::Option<usize> = 'msg: {
        let mut max_size = 0;
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(10usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(7usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(1usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(5usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(17usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        ::core::option::Option::Some(max_size)
    };
    fn encode<IMPL_MICROPB_WRITE: ::micropb::PbWrite>(
        &self,
        encoder: &mut ::micropb::PbEncoder<IMPL_MICROPB_WRITE>,
    ) -> Result<(), IMPL_MICROPB_WRITE::Error> {
        use ::micropb::{FieldEncode, PbMap};
        {
            let val_ref = &self.r#ifx;
            if *val_ref != 0 {
                encoder.encode_varint32(8u32)?;
                encoder.encode_int32(*val_ref as _)?;
            }
        }
        {
            let val_ref = &self.r#dest_mac;
            if !val_ref.is_empty() {
                encoder.encode_varint32(18u32)?;
                encoder.encode_bytes(val_ref)?;
            }
        }
        {
            let val_ref = &self.r#no_ack;
            if *val_ref {
                encoder.encode_varint32(24u32)?;
                encoder.encode_bool(*val_ref)?;
            }
        }
        {
            let val_ref = &self.r#data_len;
            if *val_ref != 0 {
                encoder.encode_varint32(32u32)?;
                encoder.encode_varint32(*val_ref as _)?;
            }
        }
        {
            let val_ref = &self.r#data;
            if !val_ref.is_empty() {
                encoder.encode_varint32(42u32)?;
                encoder.encode_bytes(val_ref)?;
            }
        }
        Ok(())
    }
    fn compute_size(&self) -> usize {
        use ::micropb::{FieldEncode, PbMap};
        let mut size = 0;
        {
            let val_ref = &self.r#ifx;
            if *val_ref != 0 {
                size += 1usize + ::micropb::size::sizeof_int32(*val_ref as _);
            }
        }
        {
            let val_ref = &self.r#dest_mac;
            if !val_ref.is_empty() {
                size += 1usize + ::micropb::size::sizeof_len_record(val_ref.len());
            }
        }
        {
            let val_ref = &self.r#no_ack;
            if *val_ref {
                size += 1usize + 1;
            }
        }
        {
            let val_ref = &self.r#data_len;
            if *val_ref != 0 {
                size += 1usize + ::micropb::size::sizeof_varint32(*val_ref as _);
            }
        }
        {
            let val_ref = &self.r#data;
            if !val_ref.is_empty() {
                size += 1usize + ::micropb::size::sizeof_len_record(val_ref.len());
            }
        }
        size
    }
}
#[derive(Debug, Default, PartialEq, Clone)]
pub struct r#wifi_ftm_initiator_cfg {
    pub r#resp_mac: ::micropb::heapless::Vec<u8, 6>,
    pub r#channel: u32,
    pub r#frm_count: u32,
    pub r#burst_period: u32,
}
impl r#wifi_ftm_initiator_cfg {
    ///Return a reference to `resp_mac`
    #[inline]
    pub fn r#resp_mac(&self) -> &::micropb::heapless::Vec<u8, 6> {
        &self.r#resp_mac
    }
    ///Return a mutable reference to `resp_mac`
    #[inline]
    pub fn mut_resp_mac(&mut self) -> &mut ::micropb::heapless::Vec<u8, 6> {
        &mut self.r#resp_mac
    }
    ///Set the value of `resp_mac`
    #[inline]
    pub fn set_resp_mac(&mut self, value: ::micropb::heapless::Vec<u8, 6>) -> &mut Self {
        self.r#resp_mac = value.into();
        self
    }
    ///Builder method that sets the value of `resp_mac`. Useful for initializing the message.
    #[inline]
    pub fn init_resp_mac(mut self, value: ::micropb::heapless::Vec<u8, 6>) -> Self {
        self.r#resp_mac = value.into();
        self
    }
    ///Return a reference to `channel`
    #[inline]
    pub fn r#channel(&self) -> &u32 {
        &self.r#channel
    }
    ///Return a mutable reference to `channel`
    #[inline]
    pub fn mut_channel(&mut self) -> &mut u32 {
        &mut self.r#channel
    }
    ///Set the value of `channel`
    #[inline]
    pub fn set_channel(&mut self, value: u32) -> &mut Self {
        self.r#channel = value.into();
        self
    }
    ///Builder method that sets the value of `channel`. Useful for initializing the message.
    #[inline]
    pub fn init_channel(mut self, value: u32) -> Self {
        self.r#channel = value.into();
        self
    }
    ///Return a reference to `frm_count`
    #[inline]
    pub fn r#frm_count(&self) -> &u32 {
        &self.r#frm_count
    }
    ///Return a mutable reference to `frm_count`
    #[inline]
    pub fn mut_frm_count(&mut self) -> &mut u32 {
        &mut self.r#frm_count
    }
    ///Set the value of `frm_count`
    #[inline]
    pub fn set_frm_count(&mut self, value: u32) -> &mut Self {
        self.r#frm_count = value.into();
        self
    }
    ///Builder method that sets the value of `frm_count`. Useful for initializing the message.
    #[inline]
    pub fn init_frm_count(mut self, value: u32) -> Self {
        self.r#frm_count = value.into();
        self
    }
    ///Return a reference to `burst_period`
    #[inline]
    pub fn r#burst_period(&self) -> &u32 {
        &self.r#burst_period
    }
    ///Return a mutable reference to `burst_period`
    #[inline]
    pub fn mut_burst_period(&mut self) -> &mut u32 {
        &mut self.r#burst_period
    }
    ///Set the value of `burst_period`
    #[inline]
    pub fn set_burst_period(&mut self, value: u32) -> &mut Self {
        self.r#burst_period = value.into();
        self
    }
    ///Builder method that sets the value of `burst_period`. Useful for initializing the message.
    #[inline]
    pub fn init_burst_period(mut self, value: u32) -> Self {
        self.r#burst_period = value.into();
        self
    }
}
impl ::micropb::MessageDecode for r#wifi_ftm_initiator_cfg {
    fn decode<IMPL_MICROPB_READ: ::micropb::PbRead>(
        &mut self,
        decoder: &mut ::micropb::PbDecoder<IMPL_MICROPB_READ>,
        len: usize,
    ) -> Result<(), ::micropb::DecodeError<IMPL_MICROPB_READ::Error>> {
        use ::micropb::{FieldDecode, PbBytes, PbMap, PbString, PbVec};
        let before = decoder.bytes_read();
        while decoder.bytes_read() - before < len {
            let tag = decoder.decode_tag()?;
            match tag.field_num() {
                0 => return Err(::micropb::DecodeError::ZeroField),
                1u32 => {
                    let mut_ref = &mut self.r#resp_mac;
                    {
                        decoder.decode_bytes(mut_ref, ::micropb::Presence::Implicit)?;
                    };
                }
                2u32 => {
                    let mut_ref = &mut self.r#channel;
                    {
                        let val = decoder.decode_varint32()?;
                        let val_ref = &val;
                        if *val_ref != 0 {
                            *mut_ref = val as _;
                        }
                    };
                }
                3u32 => {
                    let mut_ref = &mut self.r#frm_count;
                    {
                        let val = decoder.decode_varint32()?;
                        let val_ref = &val;
                        if *val_ref != 0 {
                            *mut_ref = val as _;
                        }
                    };
                }
                4u32 => {
                    let mut_ref = &mut self.r#burst_period;
                    {
                        let val = decoder.decode_varint32()?;
                        let val_ref = &val;
                        if *val_ref != 0 {
                            *mut_ref = val as _;
                        }
                    };
                }
                _ => {
                    decoder.skip_wire_value(tag.wire_type())?;
                }
            }
        }
        Ok(())
    }
}
impl ::micropb::MessageEncode for r#wifi_ftm_initiator_cfg {
    const MAX_SIZE: ::core::option::Option<usize> = 'msg: {
        let mut max_size = 0;
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(7usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(5usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(5usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(5usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        ::core::option::Option::Some(max_size)
    };
    fn encode<IMPL_MICROPB_WRITE: ::micropb::PbWrite>(
        &self,
        encoder: &mut ::micropb::PbEncoder<IMPL_MICROPB_WRITE>,
    ) -> Result<(), IMPL_MICROPB_WRITE::Error> {
        use ::micropb::{FieldEncode, PbMap};
        {
            let val_ref = &self.r#resp_mac;
            if !val_ref.is_empty() {
                encoder.encode_varint32(10u32)?;
                encoder.encode_bytes(val_ref)?;
            }
        }
        {
            let val_ref = &self.r#channel;
            if *val_ref != 0 {
                encoder.encode_varint32(16u32)?;
                encoder.encode_varint32(*val_ref as _)?;
            }
        }
        {
            let val_ref = &self.r#frm_count;
            if *val_ref != 0 {
                encoder.encode_varint32(24u32)?;
                encoder.encode_varint32(*val_ref as _)?;
            }
        }
        {
            let val_ref = &self.r#burst_period;
            if *val_ref != 0 {
                encoder.encode_varint32(32u32)?;
                encoder.encode_varint32(*val_ref as _)?;
            }
        }
        Ok(())
    }
    fn compute_size(&self) -> usize {
        use ::micropb::{FieldEncode, PbMap};
        let mut size = 0;
        {
            let val_ref = &self.r#resp_mac;
            if !val_ref.is_empty() {
                size += 1usize + ::micropb::size::sizeof_len_record(val_ref.len());
            }
        }
        {
            let val_ref = &self.r#channel;
            if *val_ref != 0 {
                size += 1usize + ::micropb::size::sizeof_varint32(*val_ref as _);
            }
        }
        {
            let val_ref = &self.r#frm_count;
            if *val_ref != 0 {
                size += 1usize + ::micropb::size::sizeof_varint32(*val_ref as _);
            }
        }
        {
            let val_ref = &self.r#burst_period;
            if *val_ref != 0 {
                size += 1usize + ::micropb::size::sizeof_varint32(*val_ref as _);
            }
        }
        size
    }
}
#[derive(Debug, Default, PartialEq, Clone)]
pub struct r#wifi_event_sta_scan_done {
    pub r#status: u32,
    pub r#number: u32,
    pub r#scan_id: u32,
}
impl r#wifi_event_sta_scan_done {
    ///Return a reference to `status`
    #[inline]
    pub fn r#status(&self) -> &u32 {
        &self.r#status
    }
    ///Return a mutable reference to `status`
    #[inline]
    pub fn mut_status(&mut self) -> &mut u32 {
        &mut self.r#status
    }
    ///Set the value of `status`
    #[inline]
    pub fn set_status(&mut self, value: u32) -> &mut Self {
        self.r#status = value.into();
        self
    }
    ///Builder method that sets the value of `status`. Useful for initializing the message.
    #[inline]
    pub fn init_status(mut self, value: u32) -> Self {
        self.r#status = value.into();
        self
    }
    ///Return a reference to `number`
    #[inline]
    pub fn r#number(&self) -> &u32 {
        &self.r#number
    }
    ///Return a mutable reference to `number`
    #[inline]
    pub fn mut_number(&mut self) -> &mut u32 {
        &mut self.r#number
    }
    ///Set the value of `number`
    #[inline]
    pub fn set_number(&mut self, value: u32) -> &mut Self {
        self.r#number = value.into();
        self
    }
    ///Builder method that sets the value of `number`. Useful for initializing the message.
    #[inline]
    pub fn init_number(mut self, value: u32) -> Self {
        self.r#number = value.into();
        self
    }
    ///Return a reference to `scan_id`
    #[inline]
    pub fn r#scan_id(&self) -> &u32 {
        &self.r#scan_id
    }
    ///Return a mutable reference to `scan_id`
    #[inline]
    pub fn mut_scan_id(&mut self) -> &mut u32 {
        &mut self.r#scan_id
    }
    ///Set the value of `scan_id`
    #[inline]
    pub fn set_scan_id(&mut self, value: u32) -> &mut Self {
        self.r#scan_id = value.into();
        self
    }
    ///Builder method that sets the value of `scan_id`. Useful for initializing the message.
    #[inline]
    pub fn init_scan_id(mut self, value: u32) -> Self {
        self.r#scan_id = value.into();
        self
    }
}
impl ::micropb::MessageDecode for r#wifi_event_sta_scan_done {
    fn decode<IMPL_MICROPB_READ: ::micropb::PbRead>(
        &mut self,
        decoder: &mut ::micropb::PbDecoder<IMPL_MICROPB_READ>,
        len: usize,
    ) -> Result<(), ::micropb::DecodeError<IMPL_MICROPB_READ::Error>> {
        use ::micropb::{FieldDecode, PbBytes, PbMap, PbString, PbVec};
        let before = decoder.bytes_read();
        while decoder.bytes_read() - before < len {
            let tag = decoder.decode_tag()?;
            match tag.field_num() {
                0 => return Err(::micropb::DecodeError::ZeroField),
                1u32 => {
                    let mut_ref = &mut self.r#status;
                    {
                        let val = decoder.decode_varint32()?;
                        let val_ref = &val;
                        if *val_ref != 0 {
                            *mut_ref = val as _;
                        }
                    };
                }
                2u32 => {
                    let mut_ref = &mut self.r#number;
                    {
                        let val = decoder.decode_varint32()?;
                        let val_ref = &val;
                        if *val_ref != 0 {
                            *mut_ref = val as _;
                        }
                    };
                }
                3u32 => {
                    let mut_ref = &mut self.r#scan_id;
                    {
                        let val = decoder.decode_varint32()?;
                        let val_ref = &val;
                        if *val_ref != 0 {
                            *mut_ref = val as _;
                        }
                    };
                }
                _ => {
                    decoder.skip_wire_value(tag.wire_type())?;
                }
            }
        }
        Ok(())
    }
}
impl ::micropb::MessageEncode for r#wifi_event_sta_scan_done {
    const MAX_SIZE: ::core::option::Option<usize> = 'msg: {
        let mut max_size = 0;
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(5usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(5usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(5usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        ::core::option::Option::Some(max_size)
    };
    fn encode<IMPL_MICROPB_WRITE: ::micropb::PbWrite>(
        &self,
        encoder: &mut ::micropb::PbEncoder<IMPL_MICROPB_WRITE>,
    ) -> Result<(), IMPL_MICROPB_WRITE::Error> {
        use ::micropb::{FieldEncode, PbMap};
        {
            let val_ref = &self.r#status;
            if *val_ref != 0 {
                encoder.encode_varint32(8u32)?;
                encoder.encode_varint32(*val_ref as _)?;
            }
        }
        {
            let val_ref = &self.r#number;
            if *val_ref != 0 {
                encoder.encode_varint32(16u32)?;
                encoder.encode_varint32(*val_ref as _)?;
            }
        }
        {
            let val_ref = &self.r#scan_id;
            if *val_ref != 0 {
                encoder.encode_varint32(24u32)?;
                encoder.encode_varint32(*val_ref as _)?;
            }
        }
        Ok(())
    }
    fn compute_size(&self) -> usize {
        use ::micropb::{FieldEncode, PbMap};
        let mut size = 0;
        {
            let val_ref = &self.r#status;
            if *val_ref != 0 {
                size += 1usize + ::micropb::size::sizeof_varint32(*val_ref as _);
            }
        }
        {
            let val_ref = &self.r#number;
            if *val_ref != 0 {
                size += 1usize + ::micropb::size::sizeof_varint32(*val_ref as _);
            }
        }
        {
            let val_ref = &self.r#scan_id;
            if *val_ref != 0 {
                size += 1usize + ::micropb::size::sizeof_varint32(*val_ref as _);
            }
        }
        size
    }
}
#[derive(Debug, Default, PartialEq, Clone)]
pub struct r#wifi_event_sta_connected {
    pub r#ssid: ::micropb::heapless::Vec<u8, 33>,
    pub r#ssid_len: u32,
    pub r#bssid: ::micropb::heapless::Vec<u8, 6>,
    pub r#channel: u32,
    pub r#authmode: i32,
    pub r#aid: i32,
}
impl r#wifi_event_sta_connected {
    ///Return a reference to `ssid`
    #[inline]
    pub fn r#ssid(&self) -> &::micropb::heapless::Vec<u8, 33> {
        &self.r#ssid
    }
    ///Return a mutable reference to `ssid`
    #[inline]
    pub fn mut_ssid(&mut self) -> &mut ::micropb::heapless::Vec<u8, 33> {
        &mut self.r#ssid
    }
    ///Set the value of `ssid`
    #[inline]
    pub fn set_ssid(&mut self, value: ::micropb::heapless::Vec<u8, 33>) -> &mut Self {
        self.r#ssid = value.into();
        self
    }
    ///Builder method that sets the value of `ssid`. Useful for initializing the message.
    #[inline]
    pub fn init_ssid(mut self, value: ::micropb::heapless::Vec<u8, 33>) -> Self {
        self.r#ssid = value.into();
        self
    }
    ///Return a reference to `ssid_len`
    #[inline]
    pub fn r#ssid_len(&self) -> &u32 {
        &self.r#ssid_len
    }
    ///Return a mutable reference to `ssid_len`
    #[inline]
    pub fn mut_ssid_len(&mut self) -> &mut u32 {
        &mut self.r#ssid_len
    }
    ///Set the value of `ssid_len`
    #[inline]
    pub fn set_ssid_len(&mut self, value: u32) -> &mut Self {
        self.r#ssid_len = value.into();
        self
    }
    ///Builder method that sets the value of `ssid_len`. Useful for initializing the message.
    #[inline]
    pub fn init_ssid_len(mut self, value: u32) -> Self {
        self.r#ssid_len = value.into();
        self
    }
    ///Return a reference to `bssid`
    #[inline]
    pub fn r#bssid(&self) -> &::micropb::heapless::Vec<u8, 6> {
        &self.r#bssid
    }
    ///Return a mutable reference to `bssid`
    #[inline]
    pub fn mut_bssid(&mut self) -> &mut ::micropb::heapless::Vec<u8, 6> {
        &mut self.r#bssid
    }
    ///Set the value of `bssid`
    #[inline]
    pub fn set_bssid(&mut self, value: ::micropb::heapless::Vec<u8, 6>) -> &mut Self {
        self.r#bssid = value.into();
        self
    }
    ///Builder method that sets the value of `bssid`. Useful for initializing the message.
    #[inline]
    pub fn init_bssid(mut self, value: ::micropb::heapless::Vec<u8, 6>) -> Self {
        self.r#bssid = value.into();
        self
    }
    ///Return a reference to `channel`
    #[inline]
    pub fn r#channel(&self) -> &u32 {
        &self.r#channel
    }
    ///Return a mutable reference to `channel`
    #[inline]
    pub fn mut_channel(&mut self) -> &mut u32 {
        &mut self.r#channel
    }
    ///Set the value of `channel`
    #[inline]
    pub fn set_channel(&mut self, value: u32) -> &mut Self {
        self.r#channel = value.into();
        self
    }
    ///Builder method that sets the value of `channel`. Useful for initializing the message.
    #[inline]
    pub fn init_channel(mut self, value: u32) -> Self {
        self.r#channel = value.into();
        self
    }
    ///Return a reference to `authmode`
    #[inline]
    pub fn r#authmode(&self) -> &i32 {
        &self.r#authmode
    }
    ///Return a mutable reference to `authmode`
    #[inline]
    pub fn mut_authmode(&mut self) -> &mut i32 {
        &mut self.r#authmode
    }
    ///Set the value of `authmode`
    #[inline]
    pub fn set_authmode(&mut self, value: i32) -> &mut Self {
        self.r#authmode = value.into();
        self
    }
    ///Builder method that sets the value of `authmode`. Useful for initializing the message.
    #[inline]
    pub fn init_authmode(mut self, value: i32) -> Self {
        self.r#authmode = value.into();
        self
    }
    ///Return a reference to `aid`
    #[inline]
    pub fn r#aid(&self) -> &i32 {
        &self.r#aid
    }
    ///Return a mutable reference to `aid`
    #[inline]
    pub fn mut_aid(&mut self) -> &mut i32 {
        &mut self.r#aid
    }
    ///Set the value of `aid`
    #[inline]
    pub fn set_aid(&mut self, value: i32) -> &mut Self {
        self.r#aid = value.into();
        self
    }
    ///Builder method that sets the value of `aid`. Useful for initializing the message.
    #[inline]
    pub fn init_aid(mut self, value: i32) -> Self {
        self.r#aid = value.into();
        self
    }
}
impl ::micropb::MessageDecode for r#wifi_event_sta_connected {
    fn decode<IMPL_MICROPB_READ: ::micropb::PbRead>(
        &mut self,
        decoder: &mut ::micropb::PbDecoder<IMPL_MICROPB_READ>,
        len: usize,
    ) -> Result<(), ::micropb::DecodeError<IMPL_MICROPB_READ::Error>> {
        use ::micropb::{FieldDecode, PbBytes, PbMap, PbString, PbVec};
        let before = decoder.bytes_read();
        while decoder.bytes_read() - before < len {
            let tag = decoder.decode_tag()?;
            match tag.field_num() {
                0 => return Err(::micropb::DecodeError::ZeroField),
                1u32 => {
                    let mut_ref = &mut self.r#ssid;
                    {
                        decoder.decode_bytes(mut_ref, ::micropb::Presence::Implicit)?;
                    };
                }
                2u32 => {
                    let mut_ref = &mut self.r#ssid_len;
                    {
                        let val = decoder.decode_varint32()?;
                        let val_ref = &val;
                        if *val_ref != 0 {
                            *mut_ref = val as _;
                        }
                    };
                }
                3u32 => {
                    let mut_ref = &mut self.r#bssid;
                    {
                        decoder.decode_bytes(mut_ref, ::micropb::Presence::Implicit)?;
                    };
                }
                4u32 => {
                    let mut_ref = &mut self.r#channel;
                    {
                        let val = decoder.decode_varint32()?;
                        let val_ref = &val;
                        if *val_ref != 0 {
                            *mut_ref = val as _;
                        }
                    };
                }
                5u32 => {
                    let mut_ref = &mut self.r#authmode;
                    {
                        let val = decoder.decode_int32()?;
                        let val_ref = &val;
                        if *val_ref != 0 {
                            *mut_ref = val as _;
                        }
                    };
                }
                6u32 => {
                    let mut_ref = &mut self.r#aid;
                    {
                        let val = decoder.decode_int32()?;
                        let val_ref = &val;
                        if *val_ref != 0 {
                            *mut_ref = val as _;
                        }
                    };
                }
                _ => {
                    decoder.skip_wire_value(tag.wire_type())?;
                }
            }
        }
        Ok(())
    }
}
impl ::micropb::MessageEncode for r#wifi_event_sta_connected {
    const MAX_SIZE: ::core::option::Option<usize> = 'msg: {
        let mut max_size = 0;
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(34usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(5usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(7usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(5usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(10usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(10usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        ::core::option::Option::Some(max_size)
    };
    fn encode<IMPL_MICROPB_WRITE: ::micropb::PbWrite>(
        &self,
        encoder: &mut ::micropb::PbEncoder<IMPL_MICROPB_WRITE>,
    ) -> Result<(), IMPL_MICROPB_WRITE::Error> {
        use ::micropb::{FieldEncode, PbMap};
        {
            let val_ref = &self.r#ssid;
            if !val_ref.is_empty() {
                encoder.encode_varint32(10u32)?;
                encoder.encode_bytes(val_ref)?;
            }
        }
        {
            let val_ref = &self.r#ssid_len;
            if *val_ref != 0 {
                encoder.encode_varint32(16u32)?;
                encoder.encode_varint32(*val_ref as _)?;
            }
        }
        {
            let val_ref = &self.r#bssid;
            if !val_ref.is_empty() {
                encoder.encode_varint32(26u32)?;
                encoder.encode_bytes(val_ref)?;
            }
        }
        {
            let val_ref = &self.r#channel;
            if *val_ref != 0 {
                encoder.encode_varint32(32u32)?;
                encoder.encode_varint32(*val_ref as _)?;
            }
        }
        {
            let val_ref = &self.r#authmode;
            if *val_ref != 0 {
                encoder.encode_varint32(40u32)?;
                encoder.encode_int32(*val_ref as _)?;
            }
        }
        {
            let val_ref = &self.r#aid;
            if *val_ref != 0 {
                encoder.encode_varint32(48u32)?;
                encoder.encode_int32(*val_ref as _)?;
            }
        }
        Ok(())
    }
    fn compute_size(&self) -> usize {
        use ::micropb::{FieldEncode, PbMap};
        let mut size = 0;
        {
            let val_ref = &self.r#ssid;
            if !val_ref.is_empty() {
                size += 1usize + ::micropb::size::sizeof_len_record(val_ref.len());
            }
        }
        {
            let val_ref = &self.r#ssid_len;
            if *val_ref != 0 {
                size += 1usize + ::micropb::size::sizeof_varint32(*val_ref as _);
            }
        }
        {
            let val_ref = &self.r#bssid;
            if !val_ref.is_empty() {
                size += 1usize + ::micropb::size::sizeof_len_record(val_ref.len());
            }
        }
        {
            let val_ref = &self.r#channel;
            if *val_ref != 0 {
                size += 1usize + ::micropb::size::sizeof_varint32(*val_ref as _);
            }
        }
        {
            let val_ref = &self.r#authmode;
            if *val_ref != 0 {
                size += 1usize + ::micropb::size::sizeof_int32(*val_ref as _);
            }
        }
        {
            let val_ref = &self.r#aid;
            if *val_ref != 0 {
                size += 1usize + ::micropb::size::sizeof_int32(*val_ref as _);
            }
        }
        size
    }
}
#[derive(Debug, Default, PartialEq, Clone)]
pub struct r#wifi_event_sta_disconnected {
    pub r#ssid: ::micropb::heapless::Vec<u8, 33>,
    pub r#ssid_len: u32,
    pub r#bssid: ::micropb::heapless::Vec<u8, 6>,
    pub r#reason: u32,
    pub r#rssi: i32,
}
impl r#wifi_event_sta_disconnected {
    ///Return a reference to `ssid`
    #[inline]
    pub fn r#ssid(&self) -> &::micropb::heapless::Vec<u8, 33> {
        &self.r#ssid
    }
    ///Return a mutable reference to `ssid`
    #[inline]
    pub fn mut_ssid(&mut self) -> &mut ::micropb::heapless::Vec<u8, 33> {
        &mut self.r#ssid
    }
    ///Set the value of `ssid`
    #[inline]
    pub fn set_ssid(&mut self, value: ::micropb::heapless::Vec<u8, 33>) -> &mut Self {
        self.r#ssid = value.into();
        self
    }
    ///Builder method that sets the value of `ssid`. Useful for initializing the message.
    #[inline]
    pub fn init_ssid(mut self, value: ::micropb::heapless::Vec<u8, 33>) -> Self {
        self.r#ssid = value.into();
        self
    }
    ///Return a reference to `ssid_len`
    #[inline]
    pub fn r#ssid_len(&self) -> &u32 {
        &self.r#ssid_len
    }
    ///Return a mutable reference to `ssid_len`
    #[inline]
    pub fn mut_ssid_len(&mut self) -> &mut u32 {
        &mut self.r#ssid_len
    }
    ///Set the value of `ssid_len`
    #[inline]
    pub fn set_ssid_len(&mut self, value: u32) -> &mut Self {
        self.r#ssid_len = value.into();
        self
    }
    ///Builder method that sets the value of `ssid_len`. Useful for initializing the message.
    #[inline]
    pub fn init_ssid_len(mut self, value: u32) -> Self {
        self.r#ssid_len = value.into();
        self
    }
    ///Return a reference to `bssid`
    #[inline]
    pub fn r#bssid(&self) -> &::micropb::heapless::Vec<u8, 6> {
        &self.r#bssid
    }
    ///Return a mutable reference to `bssid`
    #[inline]
    pub fn mut_bssid(&mut self) -> &mut ::micropb::heapless::Vec<u8, 6> {
        &mut self.r#bssid
    }
    ///Set the value of `bssid`
    #[inline]
    pub fn set_bssid(&mut self, value: ::micropb::heapless::Vec<u8, 6>) -> &mut Self {
        self.r#bssid = value.into();
        self
    }
    ///Builder method that sets the value of `bssid`. Useful for initializing the message.
    #[inline]
    pub fn init_bssid(mut self, value: ::micropb::heapless::Vec<u8, 6>) -> Self {
        self.r#bssid = value.into();
        self
    }
    ///Return a reference to `reason`
    #[inline]
    pub fn r#reason(&self) -> &u32 {
        &self.r#reason
    }
    ///Return a mutable reference to `reason`
    #[inline]
    pub fn mut_reason(&mut self) -> &mut u32 {
        &mut self.r#reason
    }
    ///Set the value of `reason`
    #[inline]
    pub fn set_reason(&mut self, value: u32) -> &mut Self {
        self.r#reason = value.into();
        self
    }
    ///Builder method that sets the value of `reason`. Useful for initializing the message.
    #[inline]
    pub fn init_reason(mut self, value: u32) -> Self {
        self.r#reason = value.into();
        self
    }
    ///Return a reference to `rssi`
    #[inline]
    pub fn r#rssi(&self) -> &i32 {
        &self.r#rssi
    }
    ///Return a mutable reference to `rssi`
    #[inline]
    pub fn mut_rssi(&mut self) -> &mut i32 {
        &mut self.r#rssi
    }
    ///Set the value of `rssi`
    #[inline]
    pub fn set_rssi(&mut self, value: i32) -> &mut Self {
        self.r#rssi = value.into();
        self
    }
    ///Builder method that sets the value of `rssi`. Useful for initializing the message.
    #[inline]
    pub fn init_rssi(mut self, value: i32) -> Self {
        self.r#rssi = value.into();
        self
    }
}
impl ::micropb::MessageDecode for r#wifi_event_sta_disconnected {
    fn decode<IMPL_MICROPB_READ: ::micropb::PbRead>(
        &mut self,
        decoder: &mut ::micropb::PbDecoder<IMPL_MICROPB_READ>,
        len: usize,
    ) -> Result<(), ::micropb::DecodeError<IMPL_MICROPB_READ::Error>> {
        use ::micropb::{FieldDecode, PbBytes, PbMap, PbString, PbVec};
        let before = decoder.bytes_read();
        while decoder.bytes_read() - before < len {
            let tag = decoder.decode_tag()?;
            match tag.field_num() {
                0 => return Err(::micropb::DecodeError::ZeroField),
                1u32 => {
                    let mut_ref = &mut self.r#ssid;
                    {
                        decoder.decode_bytes(mut_ref, ::micropb::Presence::Implicit)?;
                    };
                }
                2u32 => {
                    let mut_ref = &mut self.r#ssid_len;
                    {
                        let val = decoder.decode_varint32()?;
                        let val_ref = &val;
                        if *val_ref != 0 {
                            *mut_ref = val as _;
                        }
                    };
                }
                3u32 => {
                    let mut_ref = &mut self.r#bssid;
                    {
                        decoder.decode_bytes(mut_ref, ::micropb::Presence::Implicit)?;
                    };
                }
                4u32 => {
                    let mut_ref = &mut self.r#reason;
                    {
                        let val = decoder.decode_varint32()?;
                        let val_ref = &val;
                        if *val_ref != 0 {
                            *mut_ref = val as _;
                        }
                    };
                }
                5u32 => {
                    let mut_ref = &mut self.r#rssi;
                    {
                        let val = decoder.decode_int32()?;
                        let val_ref = &val;
                        if *val_ref != 0 {
                            *mut_ref = val as _;
                        }
                    };
                }
                _ => {
                    decoder.skip_wire_value(tag.wire_type())?;
                }
            }
        }
        Ok(())
    }
}
impl ::micropb::MessageEncode for r#wifi_event_sta_disconnected {
    const MAX_SIZE: ::core::option::Option<usize> = 'msg: {
        let mut max_size = 0;
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(34usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(5usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(7usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(5usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(10usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        ::core::option::Option::Some(max_size)
    };
    fn encode<IMPL_MICROPB_WRITE: ::micropb::PbWrite>(
        &self,
        encoder: &mut ::micropb::PbEncoder<IMPL_MICROPB_WRITE>,
    ) -> Result<(), IMPL_MICROPB_WRITE::Error> {
        use ::micropb::{FieldEncode, PbMap};
        {
            let val_ref = &self.r#ssid;
            if !val_ref.is_empty() {
                encoder.encode_varint32(10u32)?;
                encoder.encode_bytes(val_ref)?;
            }
        }
        {
            let val_ref = &self.r#ssid_len;
            if *val_ref != 0 {
                encoder.encode_varint32(16u32)?;
                encoder.encode_varint32(*val_ref as _)?;
            }
        }
        {
            let val_ref = &self.r#bssid;
            if !val_ref.is_empty() {
                encoder.encode_varint32(26u32)?;
                encoder.encode_bytes(val_ref)?;
            }
        }
        {
            let val_ref = &self.r#reason;
            if *val_ref != 0 {
                encoder.encode_varint32(32u32)?;
                encoder.encode_varint32(*val_ref as _)?;
            }
        }
        {
            let val_ref = &self.r#rssi;
            if *val_ref != 0 {
                encoder.encode_varint32(40u32)?;
                encoder.encode_int32(*val_ref as _)?;
            }
        }
        Ok(())
    }
    fn compute_size(&self) -> usize {
        use ::micropb::{FieldEncode, PbMap};
        let mut size = 0;
        {
            let val_ref = &self.r#ssid;
            if !val_ref.is_empty() {
                size += 1usize + ::micropb::size::sizeof_len_record(val_ref.len());
            }
        }
        {
            let val_ref = &self.r#ssid_len;
            if *val_ref != 0 {
                size += 1usize + ::micropb::size::sizeof_varint32(*val_ref as _);
            }
        }
        {
            let val_ref = &self.r#bssid;
            if !val_ref.is_empty() {
                size += 1usize + ::micropb::size::sizeof_len_record(val_ref.len());
            }
        }
        {
            let val_ref = &self.r#reason;
            if *val_ref != 0 {
                size += 1usize + ::micropb::size::sizeof_varint32(*val_ref as _);
            }
        }
        {
            let val_ref = &self.r#rssi;
            if *val_ref != 0 {
                size += 1usize + ::micropb::size::sizeof_int32(*val_ref as _);
            }
        }
        size
    }
}
#[derive(Debug, Default, PartialEq, Clone)]
pub struct r#wifi_event_sta_authmode_change {
    pub r#old_mode: i32,
    pub r#new_mode: i32,
}
impl r#wifi_event_sta_authmode_change {
    ///Return a reference to `old_mode`
    #[inline]
    pub fn r#old_mode(&self) -> &i32 {
        &self.r#old_mode
    }
    ///Return a mutable reference to `old_mode`
    #[inline]
    pub fn mut_old_mode(&mut self) -> &mut i32 {
        &mut self.r#old_mode
    }
    ///Set the value of `old_mode`
    #[inline]
    pub fn set_old_mode(&mut self, value: i32) -> &mut Self {
        self.r#old_mode = value.into();
        self
    }
    ///Builder method that sets the value of `old_mode`. Useful for initializing the message.
    #[inline]
    pub fn init_old_mode(mut self, value: i32) -> Self {
        self.r#old_mode = value.into();
        self
    }
    ///Return a reference to `new_mode`
    #[inline]
    pub fn r#new_mode(&self) -> &i32 {
        &self.r#new_mode
    }
    ///Return a mutable reference to `new_mode`
    #[inline]
    pub fn mut_new_mode(&mut self) -> &mut i32 {
        &mut self.r#new_mode
    }
    ///Set the value of `new_mode`
    #[inline]
    pub fn set_new_mode(&mut self, value: i32) -> &mut Self {
        self.r#new_mode = value.into();
        self
    }
    ///Builder method that sets the value of `new_mode`. Useful for initializing the message.
    #[inline]
    pub fn init_new_mode(mut self, value: i32) -> Self {
        self.r#new_mode = value.into();
        self
    }
}
impl ::micropb::MessageDecode for r#wifi_event_sta_authmode_change {
    fn decode<IMPL_MICROPB_READ: ::micropb::PbRead>(
        &mut self,
        decoder: &mut ::micropb::PbDecoder<IMPL_MICROPB_READ>,
        len: usize,
    ) -> Result<(), ::micropb::DecodeError<IMPL_MICROPB_READ::Error>> {
        use ::micropb::{FieldDecode, PbBytes, PbMap, PbString, PbVec};
        let before = decoder.bytes_read();
        while decoder.bytes_read() - before < len {
            let tag = decoder.decode_tag()?;
            match tag.field_num() {
                0 => return Err(::micropb::DecodeError::ZeroField),
                1u32 => {
                    let mut_ref = &mut self.r#old_mode;
                    {
                        let val = decoder.decode_int32()?;
                        let val_ref = &val;
                        if *val_ref != 0 {
                            *mut_ref = val as _;
                        }
                    };
                }
                2u32 => {
                    let mut_ref = &mut self.r#new_mode;
                    {
                        let val = decoder.decode_int32()?;
                        let val_ref = &val;
                        if *val_ref != 0 {
                            *mut_ref = val as _;
                        }
                    };
                }
                _ => {
                    decoder.skip_wire_value(tag.wire_type())?;
                }
            }
        }
        Ok(())
    }
}
impl ::micropb::MessageEncode for r#wifi_event_sta_authmode_change {
    const MAX_SIZE: ::core::option::Option<usize> = 'msg: {
        let mut max_size = 0;
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(10usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(10usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        ::core::option::Option::Some(max_size)
    };
    fn encode<IMPL_MICROPB_WRITE: ::micropb::PbWrite>(
        &self,
        encoder: &mut ::micropb::PbEncoder<IMPL_MICROPB_WRITE>,
    ) -> Result<(), IMPL_MICROPB_WRITE::Error> {
        use ::micropb::{FieldEncode, PbMap};
        {
            let val_ref = &self.r#old_mode;
            if *val_ref != 0 {
                encoder.encode_varint32(8u32)?;
                encoder.encode_int32(*val_ref as _)?;
            }
        }
        {
            let val_ref = &self.r#new_mode;
            if *val_ref != 0 {
                encoder.encode_varint32(16u32)?;
                encoder.encode_int32(*val_ref as _)?;
            }
        }
        Ok(())
    }
    fn compute_size(&self) -> usize {
        use ::micropb::{FieldEncode, PbMap};
        let mut size = 0;
        {
            let val_ref = &self.r#old_mode;
            if *val_ref != 0 {
                size += 1usize + ::micropb::size::sizeof_int32(*val_ref as _);
            }
        }
        {
            let val_ref = &self.r#new_mode;
            if *val_ref != 0 {
                size += 1usize + ::micropb::size::sizeof_int32(*val_ref as _);
            }
        }
        size
    }
}
#[derive(Debug, Default, PartialEq, Clone)]
pub struct r#wifi_event_sta_wps_er_pin {
    pub r#pin_code: ::micropb::heapless::Vec<u8, 8>,
}
impl r#wifi_event_sta_wps_er_pin {
    ///Return a reference to `pin_code`
    #[inline]
    pub fn r#pin_code(&self) -> &::micropb::heapless::Vec<u8, 8> {
        &self.r#pin_code
    }
    ///Return a mutable reference to `pin_code`
    #[inline]
    pub fn mut_pin_code(&mut self) -> &mut ::micropb::heapless::Vec<u8, 8> {
        &mut self.r#pin_code
    }
    ///Set the value of `pin_code`
    #[inline]
    pub fn set_pin_code(&mut self, value: ::micropb::heapless::Vec<u8, 8>) -> &mut Self {
        self.r#pin_code = value.into();
        self
    }
    ///Builder method that sets the value of `pin_code`. Useful for initializing the message.
    #[inline]
    pub fn init_pin_code(mut self, value: ::micropb::heapless::Vec<u8, 8>) -> Self {
        self.r#pin_code = value.into();
        self
    }
}
impl ::micropb::MessageDecode for r#wifi_event_sta_wps_er_pin {
    fn decode<IMPL_MICROPB_READ: ::micropb::PbRead>(
        &mut self,
        decoder: &mut ::micropb::PbDecoder<IMPL_MICROPB_READ>,
        len: usize,
    ) -> Result<(), ::micropb::DecodeError<IMPL_MICROPB_READ::Error>> {
        use ::micropb::{FieldDecode, PbBytes, PbMap, PbString, PbVec};
        let before = decoder.bytes_read();
        while decoder.bytes_read() - before < len {
            let tag = decoder.decode_tag()?;
            match tag.field_num() {
                0 => return Err(::micropb::DecodeError::ZeroField),
                1u32 => {
                    let mut_ref = &mut self.r#pin_code;
                    {
                        decoder.decode_bytes(mut_ref, ::micropb::Presence::Implicit)?;
                    };
                }
                _ => {
                    decoder.skip_wire_value(tag.wire_type())?;
                }
            }
        }
        Ok(())
    }
}
impl ::micropb::MessageEncode for r#wifi_event_sta_wps_er_pin {
    const MAX_SIZE: ::core::option::Option<usize> = 'msg: {
        let mut max_size = 0;
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(9usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        ::core::option::Option::Some(max_size)
    };
    fn encode<IMPL_MICROPB_WRITE: ::micropb::PbWrite>(
        &self,
        encoder: &mut ::micropb::PbEncoder<IMPL_MICROPB_WRITE>,
    ) -> Result<(), IMPL_MICROPB_WRITE::Error> {
        use ::micropb::{FieldEncode, PbMap};
        {
            let val_ref = &self.r#pin_code;
            if !val_ref.is_empty() {
                encoder.encode_varint32(10u32)?;
                encoder.encode_bytes(val_ref)?;
            }
        }
        Ok(())
    }
    fn compute_size(&self) -> usize {
        use ::micropb::{FieldEncode, PbMap};
        let mut size = 0;
        {
            let val_ref = &self.r#pin_code;
            if !val_ref.is_empty() {
                size += 1usize + ::micropb::size::sizeof_len_record(val_ref.len());
            }
        }
        size
    }
}
#[derive(Debug, Default, PartialEq, Clone)]
pub struct r#ap_cred {
    pub r#ssid: ::micropb::heapless::Vec<u8, 33>,
    pub r#passphrase: ::micropb::heapless::Vec<u8, 64>,
}
impl r#ap_cred {
    ///Return a reference to `ssid`
    #[inline]
    pub fn r#ssid(&self) -> &::micropb::heapless::Vec<u8, 33> {
        &self.r#ssid
    }
    ///Return a mutable reference to `ssid`
    #[inline]
    pub fn mut_ssid(&mut self) -> &mut ::micropb::heapless::Vec<u8, 33> {
        &mut self.r#ssid
    }
    ///Set the value of `ssid`
    #[inline]
    pub fn set_ssid(&mut self, value: ::micropb::heapless::Vec<u8, 33>) -> &mut Self {
        self.r#ssid = value.into();
        self
    }
    ///Builder method that sets the value of `ssid`. Useful for initializing the message.
    #[inline]
    pub fn init_ssid(mut self, value: ::micropb::heapless::Vec<u8, 33>) -> Self {
        self.r#ssid = value.into();
        self
    }
    ///Return a reference to `passphrase`
    #[inline]
    pub fn r#passphrase(&self) -> &::micropb::heapless::Vec<u8, 64> {
        &self.r#passphrase
    }
    ///Return a mutable reference to `passphrase`
    #[inline]
    pub fn mut_passphrase(&mut self) -> &mut ::micropb::heapless::Vec<u8, 64> {
        &mut self.r#passphrase
    }
    ///Set the value of `passphrase`
    #[inline]
    pub fn set_passphrase(&mut self, value: ::micropb::heapless::Vec<u8, 64>) -> &mut Self {
        self.r#passphrase = value.into();
        self
    }
    ///Builder method that sets the value of `passphrase`. Useful for initializing the message.
    #[inline]
    pub fn init_passphrase(mut self, value: ::micropb::heapless::Vec<u8, 64>) -> Self {
        self.r#passphrase = value.into();
        self
    }
}
impl ::micropb::MessageDecode for r#ap_cred {
    fn decode<IMPL_MICROPB_READ: ::micropb::PbRead>(
        &mut self,
        decoder: &mut ::micropb::PbDecoder<IMPL_MICROPB_READ>,
        len: usize,
    ) -> Result<(), ::micropb::DecodeError<IMPL_MICROPB_READ::Error>> {
        use ::micropb::{FieldDecode, PbBytes, PbMap, PbString, PbVec};
        let before = decoder.bytes_read();
        while decoder.bytes_read() - before < len {
            let tag = decoder.decode_tag()?;
            match tag.field_num() {
                0 => return Err(::micropb::DecodeError::ZeroField),
                1u32 => {
                    let mut_ref = &mut self.r#ssid;
                    {
                        decoder.decode_bytes(mut_ref, ::micropb::Presence::Implicit)?;
                    };
                }
                2u32 => {
                    let mut_ref = &mut self.r#passphrase;
                    {
                        decoder.decode_bytes(mut_ref, ::micropb::Presence::Implicit)?;
                    };
                }
                _ => {
                    decoder.skip_wire_value(tag.wire_type())?;
                }
            }
        }
        Ok(())
    }
}
impl ::micropb::MessageEncode for r#ap_cred {
    const MAX_SIZE: ::core::option::Option<usize> = 'msg: {
        let mut max_size = 0;
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(34usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(65usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        ::core::option::Option::Some(max_size)
    };
    fn encode<IMPL_MICROPB_WRITE: ::micropb::PbWrite>(
        &self,
        encoder: &mut ::micropb::PbEncoder<IMPL_MICROPB_WRITE>,
    ) -> Result<(), IMPL_MICROPB_WRITE::Error> {
        use ::micropb::{FieldEncode, PbMap};
        {
            let val_ref = &self.r#ssid;
            if !val_ref.is_empty() {
                encoder.encode_varint32(10u32)?;
                encoder.encode_bytes(val_ref)?;
            }
        }
        {
            let val_ref = &self.r#passphrase;
            if !val_ref.is_empty() {
                encoder.encode_varint32(18u32)?;
                encoder.encode_bytes(val_ref)?;
            }
        }
        Ok(())
    }
    fn compute_size(&self) -> usize {
        use ::micropb::{FieldEncode, PbMap};
        let mut size = 0;
        {
            let val_ref = &self.r#ssid;
            if !val_ref.is_empty() {
                size += 1usize + ::micropb::size::sizeof_len_record(val_ref.len());
            }
        }
        {
            let val_ref = &self.r#passphrase;
            if !val_ref.is_empty() {
                size += 1usize + ::micropb::size::sizeof_len_record(val_ref.len());
            }
        }
        size
    }
}
#[derive(Debug, Default, PartialEq, Clone)]
pub struct r#wifi_event_sta_wps_er_success {
    pub r#ap_cred_cnt: u32,
    pub r#ap_creds: ::micropb::heapless::Vec<r#ap_cred, 8>,
}
impl r#wifi_event_sta_wps_er_success {
    ///Return a reference to `ap_cred_cnt`
    #[inline]
    pub fn r#ap_cred_cnt(&self) -> &u32 {
        &self.r#ap_cred_cnt
    }
    ///Return a mutable reference to `ap_cred_cnt`
    #[inline]
    pub fn mut_ap_cred_cnt(&mut self) -> &mut u32 {
        &mut self.r#ap_cred_cnt
    }
    ///Set the value of `ap_cred_cnt`
    #[inline]
    pub fn set_ap_cred_cnt(&mut self, value: u32) -> &mut Self {
        self.r#ap_cred_cnt = value.into();
        self
    }
    ///Builder method that sets the value of `ap_cred_cnt`. Useful for initializing the message.
    #[inline]
    pub fn init_ap_cred_cnt(mut self, value: u32) -> Self {
        self.r#ap_cred_cnt = value.into();
        self
    }
}
impl ::micropb::MessageDecode for r#wifi_event_sta_wps_er_success {
    fn decode<IMPL_MICROPB_READ: ::micropb::PbRead>(
        &mut self,
        decoder: &mut ::micropb::PbDecoder<IMPL_MICROPB_READ>,
        len: usize,
    ) -> Result<(), ::micropb::DecodeError<IMPL_MICROPB_READ::Error>> {
        use ::micropb::{FieldDecode, PbBytes, PbMap, PbString, PbVec};
        let before = decoder.bytes_read();
        while decoder.bytes_read() - before < len {
            let tag = decoder.decode_tag()?;
            match tag.field_num() {
                0 => return Err(::micropb::DecodeError::ZeroField),
                1u32 => {
                    let mut_ref = &mut self.r#ap_cred_cnt;
                    {
                        let val = decoder.decode_varint32()?;
                        let val_ref = &val;
                        if *val_ref != 0 {
                            *mut_ref = val as _;
                        }
                    };
                }
                2u32 => {
                    let mut val: r#ap_cred = ::core::default::Default::default();
                    let mut_ref = &mut val;
                    {
                        mut_ref.decode_len_delimited(decoder)?;
                    };
                    if let (Err(_), false) = (
                        self.r#ap_creds.pb_push(val),
                        decoder.ignore_repeated_cap_err,
                    ) {
                        return Err(::micropb::DecodeError::Capacity);
                    }
                }
                _ => {
                    decoder.skip_wire_value(tag.wire_type())?;
                }
            }
        }
        Ok(())
    }
}
impl ::micropb::MessageEncode for r#wifi_event_sta_wps_er_success {
    const MAX_SIZE: ::core::option::Option<usize> = 'msg: {
        let mut max_size = 0;
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(5usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        if let ::core::option::Option::Some(size) = ::micropb::const_map!(
            ::micropb::const_map!(<r#ap_cred as ::micropb::MessageEncode>::MAX_SIZE, |size| {
                ::micropb::size::sizeof_len_record(size)
            }),
            |size| (size + 1usize) * 8usize
        ) {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        ::core::option::Option::Some(max_size)
    };
    fn encode<IMPL_MICROPB_WRITE: ::micropb::PbWrite>(
        &self,
        encoder: &mut ::micropb::PbEncoder<IMPL_MICROPB_WRITE>,
    ) -> Result<(), IMPL_MICROPB_WRITE::Error> {
        use ::micropb::{FieldEncode, PbMap};
        {
            let val_ref = &self.r#ap_cred_cnt;
            if *val_ref != 0 {
                encoder.encode_varint32(8u32)?;
                encoder.encode_varint32(*val_ref as _)?;
            }
        }
        {
            for val_ref in self.r#ap_creds.iter() {
                encoder.encode_varint32(18u32)?;
                val_ref.encode_len_delimited(encoder)?;
            }
        }
        Ok(())
    }
    fn compute_size(&self) -> usize {
        use ::micropb::{FieldEncode, PbMap};
        let mut size = 0;
        {
            let val_ref = &self.r#ap_cred_cnt;
            if *val_ref != 0 {
                size += 1usize + ::micropb::size::sizeof_varint32(*val_ref as _);
            }
        }
        {
            for val_ref in self.r#ap_creds.iter() {
                size += 1usize + ::micropb::size::sizeof_len_record(val_ref.compute_size());
            }
        }
        size
    }
}
#[derive(Debug, Default, PartialEq, Clone)]
pub struct r#wifi_event_ap_probe_req_rx {
    pub r#rssi: i32,
    pub r#mac: u32,
}
impl r#wifi_event_ap_probe_req_rx {
    ///Return a reference to `rssi`
    #[inline]
    pub fn r#rssi(&self) -> &i32 {
        &self.r#rssi
    }
    ///Return a mutable reference to `rssi`
    #[inline]
    pub fn mut_rssi(&mut self) -> &mut i32 {
        &mut self.r#rssi
    }
    ///Set the value of `rssi`
    #[inline]
    pub fn set_rssi(&mut self, value: i32) -> &mut Self {
        self.r#rssi = value.into();
        self
    }
    ///Builder method that sets the value of `rssi`. Useful for initializing the message.
    #[inline]
    pub fn init_rssi(mut self, value: i32) -> Self {
        self.r#rssi = value.into();
        self
    }
    ///Return a reference to `mac`
    #[inline]
    pub fn r#mac(&self) -> &u32 {
        &self.r#mac
    }
    ///Return a mutable reference to `mac`
    #[inline]
    pub fn mut_mac(&mut self) -> &mut u32 {
        &mut self.r#mac
    }
    ///Set the value of `mac`
    #[inline]
    pub fn set_mac(&mut self, value: u32) -> &mut Self {
        self.r#mac = value.into();
        self
    }
    ///Builder method that sets the value of `mac`. Useful for initializing the message.
    #[inline]
    pub fn init_mac(mut self, value: u32) -> Self {
        self.r#mac = value.into();
        self
    }
}
impl ::micropb::MessageDecode for r#wifi_event_ap_probe_req_rx {
    fn decode<IMPL_MICROPB_READ: ::micropb::PbRead>(
        &mut self,
        decoder: &mut ::micropb::PbDecoder<IMPL_MICROPB_READ>,
        len: usize,
    ) -> Result<(), ::micropb::DecodeError<IMPL_MICROPB_READ::Error>> {
        use ::micropb::{FieldDecode, PbBytes, PbMap, PbString, PbVec};
        let before = decoder.bytes_read();
        while decoder.bytes_read() - before < len {
            let tag = decoder.decode_tag()?;
            match tag.field_num() {
                0 => return Err(::micropb::DecodeError::ZeroField),
                1u32 => {
                    let mut_ref = &mut self.r#rssi;
                    {
                        let val = decoder.decode_int32()?;
                        let val_ref = &val;
                        if *val_ref != 0 {
                            *mut_ref = val as _;
                        }
                    };
                }
                2u32 => {
                    let mut_ref = &mut self.r#mac;
                    {
                        let val = decoder.decode_varint32()?;
                        let val_ref = &val;
                        if *val_ref != 0 {
                            *mut_ref = val as _;
                        }
                    };
                }
                _ => {
                    decoder.skip_wire_value(tag.wire_type())?;
                }
            }
        }
        Ok(())
    }
}
impl ::micropb::MessageEncode for r#wifi_event_ap_probe_req_rx {
    const MAX_SIZE: ::core::option::Option<usize> = 'msg: {
        let mut max_size = 0;
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(10usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(5usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        ::core::option::Option::Some(max_size)
    };
    fn encode<IMPL_MICROPB_WRITE: ::micropb::PbWrite>(
        &self,
        encoder: &mut ::micropb::PbEncoder<IMPL_MICROPB_WRITE>,
    ) -> Result<(), IMPL_MICROPB_WRITE::Error> {
        use ::micropb::{FieldEncode, PbMap};
        {
            let val_ref = &self.r#rssi;
            if *val_ref != 0 {
                encoder.encode_varint32(8u32)?;
                encoder.encode_int32(*val_ref as _)?;
            }
        }
        {
            let val_ref = &self.r#mac;
            if *val_ref != 0 {
                encoder.encode_varint32(16u32)?;
                encoder.encode_varint32(*val_ref as _)?;
            }
        }
        Ok(())
    }
    fn compute_size(&self) -> usize {
        use ::micropb::{FieldEncode, PbMap};
        let mut size = 0;
        {
            let val_ref = &self.r#rssi;
            if *val_ref != 0 {
                size += 1usize + ::micropb::size::sizeof_int32(*val_ref as _);
            }
        }
        {
            let val_ref = &self.r#mac;
            if *val_ref != 0 {
                size += 1usize + ::micropb::size::sizeof_varint32(*val_ref as _);
            }
        }
        size
    }
}
#[derive(Debug, Default, PartialEq, Clone)]
pub struct r#wifi_event_bss_rssi_low {
    pub r#rssi: i32,
}
impl r#wifi_event_bss_rssi_low {
    ///Return a reference to `rssi`
    #[inline]
    pub fn r#rssi(&self) -> &i32 {
        &self.r#rssi
    }
    ///Return a mutable reference to `rssi`
    #[inline]
    pub fn mut_rssi(&mut self) -> &mut i32 {
        &mut self.r#rssi
    }
    ///Set the value of `rssi`
    #[inline]
    pub fn set_rssi(&mut self, value: i32) -> &mut Self {
        self.r#rssi = value.into();
        self
    }
    ///Builder method that sets the value of `rssi`. Useful for initializing the message.
    #[inline]
    pub fn init_rssi(mut self, value: i32) -> Self {
        self.r#rssi = value.into();
        self
    }
}
impl ::micropb::MessageDecode for r#wifi_event_bss_rssi_low {
    fn decode<IMPL_MICROPB_READ: ::micropb::PbRead>(
        &mut self,
        decoder: &mut ::micropb::PbDecoder<IMPL_MICROPB_READ>,
        len: usize,
    ) -> Result<(), ::micropb::DecodeError<IMPL_MICROPB_READ::Error>> {
        use ::micropb::{FieldDecode, PbBytes, PbMap, PbString, PbVec};
        let before = decoder.bytes_read();
        while decoder.bytes_read() - before < len {
            let tag = decoder.decode_tag()?;
            match tag.field_num() {
                0 => return Err(::micropb::DecodeError::ZeroField),
                1u32 => {
                    let mut_ref = &mut self.r#rssi;
                    {
                        let val = decoder.decode_int32()?;
                        let val_ref = &val;
                        if *val_ref != 0 {
                            *mut_ref = val as _;
                        }
                    };
                }
                _ => {
                    decoder.skip_wire_value(tag.wire_type())?;
                }
            }
        }
        Ok(())
    }
}
impl ::micropb::MessageEncode for r#wifi_event_bss_rssi_low {
    const MAX_SIZE: ::core::option::Option<usize> = 'msg: {
        let mut max_size = 0;
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(10usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        ::core::option::Option::Some(max_size)
    };
    fn encode<IMPL_MICROPB_WRITE: ::micropb::PbWrite>(
        &self,
        encoder: &mut ::micropb::PbEncoder<IMPL_MICROPB_WRITE>,
    ) -> Result<(), IMPL_MICROPB_WRITE::Error> {
        use ::micropb::{FieldEncode, PbMap};
        {
            let val_ref = &self.r#rssi;
            if *val_ref != 0 {
                encoder.encode_varint32(8u32)?;
                encoder.encode_int32(*val_ref as _)?;
            }
        }
        Ok(())
    }
    fn compute_size(&self) -> usize {
        use ::micropb::{FieldEncode, PbMap};
        let mut size = 0;
        {
            let val_ref = &self.r#rssi;
            if *val_ref != 0 {
                size += 1usize + ::micropb::size::sizeof_int32(*val_ref as _);
            }
        }
        size
    }
}
#[derive(Debug, Default, PartialEq, Clone)]
pub struct r#wifi_ftm_report_entry {
    pub r#dlog_token: u32,
    pub r#rssi: i32,
    pub r#rtt: u32,
    pub r#t1: u64,
    pub r#t2: u64,
    pub r#t3: u64,
    pub r#t4: u64,
}
impl r#wifi_ftm_report_entry {
    ///Return a reference to `dlog_token`
    #[inline]
    pub fn r#dlog_token(&self) -> &u32 {
        &self.r#dlog_token
    }
    ///Return a mutable reference to `dlog_token`
    #[inline]
    pub fn mut_dlog_token(&mut self) -> &mut u32 {
        &mut self.r#dlog_token
    }
    ///Set the value of `dlog_token`
    #[inline]
    pub fn set_dlog_token(&mut self, value: u32) -> &mut Self {
        self.r#dlog_token = value.into();
        self
    }
    ///Builder method that sets the value of `dlog_token`. Useful for initializing the message.
    #[inline]
    pub fn init_dlog_token(mut self, value: u32) -> Self {
        self.r#dlog_token = value.into();
        self
    }
    ///Return a reference to `rssi`
    #[inline]
    pub fn r#rssi(&self) -> &i32 {
        &self.r#rssi
    }
    ///Return a mutable reference to `rssi`
    #[inline]
    pub fn mut_rssi(&mut self) -> &mut i32 {
        &mut self.r#rssi
    }
    ///Set the value of `rssi`
    #[inline]
    pub fn set_rssi(&mut self, value: i32) -> &mut Self {
        self.r#rssi = value.into();
        self
    }
    ///Builder method that sets the value of `rssi`. Useful for initializing the message.
    #[inline]
    pub fn init_rssi(mut self, value: i32) -> Self {
        self.r#rssi = value.into();
        self
    }
    ///Return a reference to `rtt`
    #[inline]
    pub fn r#rtt(&self) -> &u32 {
        &self.r#rtt
    }
    ///Return a mutable reference to `rtt`
    #[inline]
    pub fn mut_rtt(&mut self) -> &mut u32 {
        &mut self.r#rtt
    }
    ///Set the value of `rtt`
    #[inline]
    pub fn set_rtt(&mut self, value: u32) -> &mut Self {
        self.r#rtt = value.into();
        self
    }
    ///Builder method that sets the value of `rtt`. Useful for initializing the message.
    #[inline]
    pub fn init_rtt(mut self, value: u32) -> Self {
        self.r#rtt = value.into();
        self
    }
    ///Return a reference to `t1`
    #[inline]
    pub fn r#t1(&self) -> &u64 {
        &self.r#t1
    }
    ///Return a mutable reference to `t1`
    #[inline]
    pub fn mut_t1(&mut self) -> &mut u64 {
        &mut self.r#t1
    }
    ///Set the value of `t1`
    #[inline]
    pub fn set_t1(&mut self, value: u64) -> &mut Self {
        self.r#t1 = value.into();
        self
    }
    ///Builder method that sets the value of `t1`. Useful for initializing the message.
    #[inline]
    pub fn init_t1(mut self, value: u64) -> Self {
        self.r#t1 = value.into();
        self
    }
    ///Return a reference to `t2`
    #[inline]
    pub fn r#t2(&self) -> &u64 {
        &self.r#t2
    }
    ///Return a mutable reference to `t2`
    #[inline]
    pub fn mut_t2(&mut self) -> &mut u64 {
        &mut self.r#t2
    }
    ///Set the value of `t2`
    #[inline]
    pub fn set_t2(&mut self, value: u64) -> &mut Self {
        self.r#t2 = value.into();
        self
    }
    ///Builder method that sets the value of `t2`. Useful for initializing the message.
    #[inline]
    pub fn init_t2(mut self, value: u64) -> Self {
        self.r#t2 = value.into();
        self
    }
    ///Return a reference to `t3`
    #[inline]
    pub fn r#t3(&self) -> &u64 {
        &self.r#t3
    }
    ///Return a mutable reference to `t3`
    #[inline]
    pub fn mut_t3(&mut self) -> &mut u64 {
        &mut self.r#t3
    }
    ///Set the value of `t3`
    #[inline]
    pub fn set_t3(&mut self, value: u64) -> &mut Self {
        self.r#t3 = value.into();
        self
    }
    ///Builder method that sets the value of `t3`. Useful for initializing the message.
    #[inline]
    pub fn init_t3(mut self, value: u64) -> Self {
        self.r#t3 = value.into();
        self
    }
    ///Return a reference to `t4`
    #[inline]
    pub fn r#t4(&self) -> &u64 {
        &self.r#t4
    }
    ///Return a mutable reference to `t4`
    #[inline]
    pub fn mut_t4(&mut self) -> &mut u64 {
        &mut self.r#t4
    }
    ///Set the value of `t4`
    #[inline]
    pub fn set_t4(&mut self, value: u64) -> &mut Self {
        self.r#t4 = value.into();
        self
    }
    ///Builder method that sets the value of `t4`. Useful for initializing the message.
    #[inline]
    pub fn init_t4(mut self, value: u64) -> Self {
        self.r#t4 = value.into();
        self
    }
}
impl ::micropb::MessageDecode for r#wifi_ftm_report_entry {
    fn decode<IMPL_MICROPB_READ: ::micropb::PbRead>(
        &mut self,
        decoder: &mut ::micropb::PbDecoder<IMPL_MICROPB_READ>,
        len: usize,
    ) -> Result<(), ::micropb::DecodeError<IMPL_MICROPB_READ::Error>> {
        use ::micropb::{FieldDecode, PbBytes, PbMap, PbString, PbVec};
        let before = decoder.bytes_read();
        while decoder.bytes_read() - before < len {
            let tag = decoder.decode_tag()?;
            match tag.field_num() {
                0 => return Err(::micropb::DecodeError::ZeroField),
                1u32 => {
                    let mut_ref = &mut self.r#dlog_token;
                    {
                        let val = decoder.decode_varint32()?;
                        let val_ref = &val;
                        if *val_ref != 0 {
                            *mut_ref = val as _;
                        }
                    };
                }
                2u32 => {
                    let mut_ref = &mut self.r#rssi;
                    {
                        let val = decoder.decode_int32()?;
                        let val_ref = &val;
                        if *val_ref != 0 {
                            *mut_ref = val as _;
                        }
                    };
                }
                3u32 => {
                    let mut_ref = &mut self.r#rtt;
                    {
                        let val = decoder.decode_varint32()?;
                        let val_ref = &val;
                        if *val_ref != 0 {
                            *mut_ref = val as _;
                        }
                    };
                }
                4u32 => {
                    let mut_ref = &mut self.r#t1;
                    {
                        let val = decoder.decode_varint64()?;
                        let val_ref = &val;
                        if *val_ref != 0 {
                            *mut_ref = val as _;
                        }
                    };
                }
                5u32 => {
                    let mut_ref = &mut self.r#t2;
                    {
                        let val = decoder.decode_varint64()?;
                        let val_ref = &val;
                        if *val_ref != 0 {
                            *mut_ref = val as _;
                        }
                    };
                }
                6u32 => {
                    let mut_ref = &mut self.r#t3;
                    {
                        let val = decoder.decode_varint64()?;
                        let val_ref = &val;
                        if *val_ref != 0 {
                            *mut_ref = val as _;
                        }
                    };
                }
                7u32 => {
                    let mut_ref = &mut self.r#t4;
                    {
                        let val = decoder.decode_varint64()?;
                        let val_ref = &val;
                        if *val_ref != 0 {
                            *mut_ref = val as _;
                        }
                    };
                }
                _ => {
                    decoder.skip_wire_value(tag.wire_type())?;
                }
            }
        }
        Ok(())
    }
}
impl ::micropb::MessageEncode for r#wifi_ftm_report_entry {
    const MAX_SIZE: ::core::option::Option<usize> = 'msg: {
        let mut max_size = 0;
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(5usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(10usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(5usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(10usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(10usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(10usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(10usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        ::core::option::Option::Some(max_size)
    };
    fn encode<IMPL_MICROPB_WRITE: ::micropb::PbWrite>(
        &self,
        encoder: &mut ::micropb::PbEncoder<IMPL_MICROPB_WRITE>,
    ) -> Result<(), IMPL_MICROPB_WRITE::Error> {
        use ::micropb::{FieldEncode, PbMap};
        {
            let val_ref = &self.r#dlog_token;
            if *val_ref != 0 {
                encoder.encode_varint32(8u32)?;
                encoder.encode_varint32(*val_ref as _)?;
            }
        }
        {
            let val_ref = &self.r#rssi;
            if *val_ref != 0 {
                encoder.encode_varint32(16u32)?;
                encoder.encode_int32(*val_ref as _)?;
            }
        }
        {
            let val_ref = &self.r#rtt;
            if *val_ref != 0 {
                encoder.encode_varint32(24u32)?;
                encoder.encode_varint32(*val_ref as _)?;
            }
        }
        {
            let val_ref = &self.r#t1;
            if *val_ref != 0 {
                encoder.encode_varint32(32u32)?;
                encoder.encode_varint64(*val_ref as _)?;
            }
        }
        {
            let val_ref = &self.r#t2;
            if *val_ref != 0 {
                encoder.encode_varint32(40u32)?;
                encoder.encode_varint64(*val_ref as _)?;
            }
        }
        {
            let val_ref = &self.r#t3;
            if *val_ref != 0 {
                encoder.encode_varint32(48u32)?;
                encoder.encode_varint64(*val_ref as _)?;
            }
        }
        {
            let val_ref = &self.r#t4;
            if *val_ref != 0 {
                encoder.encode_varint32(56u32)?;
                encoder.encode_varint64(*val_ref as _)?;
            }
        }
        Ok(())
    }
    fn compute_size(&self) -> usize {
        use ::micropb::{FieldEncode, PbMap};
        let mut size = 0;
        {
            let val_ref = &self.r#dlog_token;
            if *val_ref != 0 {
                size += 1usize + ::micropb::size::sizeof_varint32(*val_ref as _);
            }
        }
        {
            let val_ref = &self.r#rssi;
            if *val_ref != 0 {
                size += 1usize + ::micropb::size::sizeof_int32(*val_ref as _);
            }
        }
        {
            let val_ref = &self.r#rtt;
            if *val_ref != 0 {
                size += 1usize + ::micropb::size::sizeof_varint32(*val_ref as _);
            }
        }
        {
            let val_ref = &self.r#t1;
            if *val_ref != 0 {
                size += 1usize + ::micropb::size::sizeof_varint64(*val_ref as _);
            }
        }
        {
            let val_ref = &self.r#t2;
            if *val_ref != 0 {
                size += 1usize + ::micropb::size::sizeof_varint64(*val_ref as _);
            }
        }
        {
            let val_ref = &self.r#t3;
            if *val_ref != 0 {
                size += 1usize + ::micropb::size::sizeof_varint64(*val_ref as _);
            }
        }
        {
            let val_ref = &self.r#t4;
            if *val_ref != 0 {
                size += 1usize + ::micropb::size::sizeof_varint64(*val_ref as _);
            }
        }
        size
    }
}
#[derive(Debug, Default, PartialEq, Clone)]
pub struct r#wifi_event_ftm_report {
    pub r#peer_mac: ::micropb::heapless::Vec<u8, 6>,
    pub r#status: i32,
    pub r#rtt_raw: u32,
    pub r#rtt_est: u32,
    pub r#dist_est: u32,
    pub r#ftm_report_data: ::micropb::heapless::Vec<r#wifi_ftm_report_entry, 8>,
    pub r#ftm_report_num_entries: u32,
}
impl r#wifi_event_ftm_report {
    ///Return a reference to `peer_mac`
    #[inline]
    pub fn r#peer_mac(&self) -> &::micropb::heapless::Vec<u8, 6> {
        &self.r#peer_mac
    }
    ///Return a mutable reference to `peer_mac`
    #[inline]
    pub fn mut_peer_mac(&mut self) -> &mut ::micropb::heapless::Vec<u8, 6> {
        &mut self.r#peer_mac
    }
    ///Set the value of `peer_mac`
    #[inline]
    pub fn set_peer_mac(&mut self, value: ::micropb::heapless::Vec<u8, 6>) -> &mut Self {
        self.r#peer_mac = value.into();
        self
    }
    ///Builder method that sets the value of `peer_mac`. Useful for initializing the message.
    #[inline]
    pub fn init_peer_mac(mut self, value: ::micropb::heapless::Vec<u8, 6>) -> Self {
        self.r#peer_mac = value.into();
        self
    }
    ///Return a reference to `status`
    #[inline]
    pub fn r#status(&self) -> &i32 {
        &self.r#status
    }
    ///Return a mutable reference to `status`
    #[inline]
    pub fn mut_status(&mut self) -> &mut i32 {
        &mut self.r#status
    }
    ///Set the value of `status`
    #[inline]
    pub fn set_status(&mut self, value: i32) -> &mut Self {
        self.r#status = value.into();
        self
    }
    ///Builder method that sets the value of `status`. Useful for initializing the message.
    #[inline]
    pub fn init_status(mut self, value: i32) -> Self {
        self.r#status = value.into();
        self
    }
    ///Return a reference to `rtt_raw`
    #[inline]
    pub fn r#rtt_raw(&self) -> &u32 {
        &self.r#rtt_raw
    }
    ///Return a mutable reference to `rtt_raw`
    #[inline]
    pub fn mut_rtt_raw(&mut self) -> &mut u32 {
        &mut self.r#rtt_raw
    }
    ///Set the value of `rtt_raw`
    #[inline]
    pub fn set_rtt_raw(&mut self, value: u32) -> &mut Self {
        self.r#rtt_raw = value.into();
        self
    }
    ///Builder method that sets the value of `rtt_raw`. Useful for initializing the message.
    #[inline]
    pub fn init_rtt_raw(mut self, value: u32) -> Self {
        self.r#rtt_raw = value.into();
        self
    }
    ///Return a reference to `rtt_est`
    #[inline]
    pub fn r#rtt_est(&self) -> &u32 {
        &self.r#rtt_est
    }
    ///Return a mutable reference to `rtt_est`
    #[inline]
    pub fn mut_rtt_est(&mut self) -> &mut u32 {
        &mut self.r#rtt_est
    }
    ///Set the value of `rtt_est`
    #[inline]
    pub fn set_rtt_est(&mut self, value: u32) -> &mut Self {
        self.r#rtt_est = value.into();
        self
    }
    ///Builder method that sets the value of `rtt_est`. Useful for initializing the message.
    #[inline]
    pub fn init_rtt_est(mut self, value: u32) -> Self {
        self.r#rtt_est = value.into();
        self
    }
    ///Return a reference to `dist_est`
    #[inline]
    pub fn r#dist_est(&self) -> &u32 {
        &self.r#dist_est
    }
    ///Return a mutable reference to `dist_est`
    #[inline]
    pub fn mut_dist_est(&mut self) -> &mut u32 {
        &mut self.r#dist_est
    }
    ///Set the value of `dist_est`
    #[inline]
    pub fn set_dist_est(&mut self, value: u32) -> &mut Self {
        self.r#dist_est = value.into();
        self
    }
    ///Builder method that sets the value of `dist_est`. Useful for initializing the message.
    #[inline]
    pub fn init_dist_est(mut self, value: u32) -> Self {
        self.r#dist_est = value.into();
        self
    }
    ///Return a reference to `ftm_report_num_entries`
    #[inline]
    pub fn r#ftm_report_num_entries(&self) -> &u32 {
        &self.r#ftm_report_num_entries
    }
    ///Return a mutable reference to `ftm_report_num_entries`
    #[inline]
    pub fn mut_ftm_report_num_entries(&mut self) -> &mut u32 {
        &mut self.r#ftm_report_num_entries
    }
    ///Set the value of `ftm_report_num_entries`
    #[inline]
    pub fn set_ftm_report_num_entries(&mut self, value: u32) -> &mut Self {
        self.r#ftm_report_num_entries = value.into();
        self
    }
    ///Builder method that sets the value of `ftm_report_num_entries`. Useful for initializing the message.
    #[inline]
    pub fn init_ftm_report_num_entries(mut self, value: u32) -> Self {
        self.r#ftm_report_num_entries = value.into();
        self
    }
}
impl ::micropb::MessageDecode for r#wifi_event_ftm_report {
    fn decode<IMPL_MICROPB_READ: ::micropb::PbRead>(
        &mut self,
        decoder: &mut ::micropb::PbDecoder<IMPL_MICROPB_READ>,
        len: usize,
    ) -> Result<(), ::micropb::DecodeError<IMPL_MICROPB_READ::Error>> {
        use ::micropb::{FieldDecode, PbBytes, PbMap, PbString, PbVec};
        let before = decoder.bytes_read();
        while decoder.bytes_read() - before < len {
            let tag = decoder.decode_tag()?;
            match tag.field_num() {
                0 => return Err(::micropb::DecodeError::ZeroField),
                1u32 => {
                    let mut_ref = &mut self.r#peer_mac;
                    {
                        decoder.decode_bytes(mut_ref, ::micropb::Presence::Implicit)?;
                    };
                }
                2u32 => {
                    let mut_ref = &mut self.r#status;
                    {
                        let val = decoder.decode_int32()?;
                        let val_ref = &val;
                        if *val_ref != 0 {
                            *mut_ref = val as _;
                        }
                    };
                }
                3u32 => {
                    let mut_ref = &mut self.r#rtt_raw;
                    {
                        let val = decoder.decode_varint32()?;
                        let val_ref = &val;
                        if *val_ref != 0 {
                            *mut_ref = val as _;
                        }
                    };
                }
                4u32 => {
                    let mut_ref = &mut self.r#rtt_est;
                    {
                        let val = decoder.decode_varint32()?;
                        let val_ref = &val;
                        if *val_ref != 0 {
                            *mut_ref = val as _;
                        }
                    };
                }
                5u32 => {
                    let mut_ref = &mut self.r#dist_est;
                    {
                        let val = decoder.decode_varint32()?;
                        let val_ref = &val;
                        if *val_ref != 0 {
                            *mut_ref = val as _;
                        }
                    };
                }
                6u32 => {
                    let mut val: r#wifi_ftm_report_entry = ::core::default::Default::default();
                    let mut_ref = &mut val;
                    {
                        mut_ref.decode_len_delimited(decoder)?;
                    };
                    if let (Err(_), false) = (
                        self.r#ftm_report_data.pb_push(val),
                        decoder.ignore_repeated_cap_err,
                    ) {
                        return Err(::micropb::DecodeError::Capacity);
                    }
                }
                7u32 => {
                    let mut_ref = &mut self.r#ftm_report_num_entries;
                    {
                        let val = decoder.decode_varint32()?;
                        let val_ref = &val;
                        if *val_ref != 0 {
                            *mut_ref = val as _;
                        }
                    };
                }
                _ => {
                    decoder.skip_wire_value(tag.wire_type())?;
                }
            }
        }
        Ok(())
    }
}
impl ::micropb::MessageEncode for r#wifi_event_ftm_report {
    const MAX_SIZE: ::core::option::Option<usize> = 'msg: {
        let mut max_size = 0;
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(7usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(10usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(5usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(5usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(5usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        if let ::core::option::Option::Some(size) = ::micropb::const_map!(
            ::micropb::const_map!(
                <r#wifi_ftm_report_entry as ::micropb::MessageEncode>::MAX_SIZE,
                |size| ::micropb::size::sizeof_len_record(size)
            ),
            |size| (size + 1usize) * 8usize
        ) {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(5usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        ::core::option::Option::Some(max_size)
    };
    fn encode<IMPL_MICROPB_WRITE: ::micropb::PbWrite>(
        &self,
        encoder: &mut ::micropb::PbEncoder<IMPL_MICROPB_WRITE>,
    ) -> Result<(), IMPL_MICROPB_WRITE::Error> {
        use ::micropb::{FieldEncode, PbMap};
        {
            let val_ref = &self.r#peer_mac;
            if !val_ref.is_empty() {
                encoder.encode_varint32(10u32)?;
                encoder.encode_bytes(val_ref)?;
            }
        }
        {
            let val_ref = &self.r#status;
            if *val_ref != 0 {
                encoder.encode_varint32(16u32)?;
                encoder.encode_int32(*val_ref as _)?;
            }
        }
        {
            let val_ref = &self.r#rtt_raw;
            if *val_ref != 0 {
                encoder.encode_varint32(24u32)?;
                encoder.encode_varint32(*val_ref as _)?;
            }
        }
        {
            let val_ref = &self.r#rtt_est;
            if *val_ref != 0 {
                encoder.encode_varint32(32u32)?;
                encoder.encode_varint32(*val_ref as _)?;
            }
        }
        {
            let val_ref = &self.r#dist_est;
            if *val_ref != 0 {
                encoder.encode_varint32(40u32)?;
                encoder.encode_varint32(*val_ref as _)?;
            }
        }
        {
            for val_ref in self.r#ftm_report_data.iter() {
                encoder.encode_varint32(50u32)?;
                val_ref.encode_len_delimited(encoder)?;
            }
        }
        {
            let val_ref = &self.r#ftm_report_num_entries;
            if *val_ref != 0 {
                encoder.encode_varint32(56u32)?;
                encoder.encode_varint32(*val_ref as _)?;
            }
        }
        Ok(())
    }
    fn compute_size(&self) -> usize {
        use ::micropb::{FieldEncode, PbMap};
        let mut size = 0;
        {
            let val_ref = &self.r#peer_mac;
            if !val_ref.is_empty() {
                size += 1usize + ::micropb::size::sizeof_len_record(val_ref.len());
            }
        }
        {
            let val_ref = &self.r#status;
            if *val_ref != 0 {
                size += 1usize + ::micropb::size::sizeof_int32(*val_ref as _);
            }
        }
        {
            let val_ref = &self.r#rtt_raw;
            if *val_ref != 0 {
                size += 1usize + ::micropb::size::sizeof_varint32(*val_ref as _);
            }
        }
        {
            let val_ref = &self.r#rtt_est;
            if *val_ref != 0 {
                size += 1usize + ::micropb::size::sizeof_varint32(*val_ref as _);
            }
        }
        {
            let val_ref = &self.r#dist_est;
            if *val_ref != 0 {
                size += 1usize + ::micropb::size::sizeof_varint32(*val_ref as _);
            }
        }
        {
            for val_ref in self.r#ftm_report_data.iter() {
                size += 1usize + ::micropb::size::sizeof_len_record(val_ref.compute_size());
            }
        }
        {
            let val_ref = &self.r#ftm_report_num_entries;
            if *val_ref != 0 {
                size += 1usize + ::micropb::size::sizeof_varint32(*val_ref as _);
            }
        }
        size
    }
}
#[derive(Debug, Default, PartialEq, Clone)]
pub struct r#wifi_event_action_tx_status {
    pub r#ifx: i32,
    pub r#context: u32,
    pub r#da: ::micropb::heapless::Vec<u8, 6>,
    pub r#status: u32,
}
impl r#wifi_event_action_tx_status {
    ///Return a reference to `ifx`
    #[inline]
    pub fn r#ifx(&self) -> &i32 {
        &self.r#ifx
    }
    ///Return a mutable reference to `ifx`
    #[inline]
    pub fn mut_ifx(&mut self) -> &mut i32 {
        &mut self.r#ifx
    }
    ///Set the value of `ifx`
    #[inline]
    pub fn set_ifx(&mut self, value: i32) -> &mut Self {
        self.r#ifx = value.into();
        self
    }
    ///Builder method that sets the value of `ifx`. Useful for initializing the message.
    #[inline]
    pub fn init_ifx(mut self, value: i32) -> Self {
        self.r#ifx = value.into();
        self
    }
    ///Return a reference to `context`
    #[inline]
    pub fn r#context(&self) -> &u32 {
        &self.r#context
    }
    ///Return a mutable reference to `context`
    #[inline]
    pub fn mut_context(&mut self) -> &mut u32 {
        &mut self.r#context
    }
    ///Set the value of `context`
    #[inline]
    pub fn set_context(&mut self, value: u32) -> &mut Self {
        self.r#context = value.into();
        self
    }
    ///Builder method that sets the value of `context`. Useful for initializing the message.
    #[inline]
    pub fn init_context(mut self, value: u32) -> Self {
        self.r#context = value.into();
        self
    }
    ///Return a reference to `da`
    #[inline]
    pub fn r#da(&self) -> &::micropb::heapless::Vec<u8, 6> {
        &self.r#da
    }
    ///Return a mutable reference to `da`
    #[inline]
    pub fn mut_da(&mut self) -> &mut ::micropb::heapless::Vec<u8, 6> {
        &mut self.r#da
    }
    ///Set the value of `da`
    #[inline]
    pub fn set_da(&mut self, value: ::micropb::heapless::Vec<u8, 6>) -> &mut Self {
        self.r#da = value.into();
        self
    }
    ///Builder method that sets the value of `da`. Useful for initializing the message.
    #[inline]
    pub fn init_da(mut self, value: ::micropb::heapless::Vec<u8, 6>) -> Self {
        self.r#da = value.into();
        self
    }
    ///Return a reference to `status`
    #[inline]
    pub fn r#status(&self) -> &u32 {
        &self.r#status
    }
    ///Return a mutable reference to `status`
    #[inline]
    pub fn mut_status(&mut self) -> &mut u32 {
        &mut self.r#status
    }
    ///Set the value of `status`
    #[inline]
    pub fn set_status(&mut self, value: u32) -> &mut Self {
        self.r#status = value.into();
        self
    }
    ///Builder method that sets the value of `status`. Useful for initializing the message.
    #[inline]
    pub fn init_status(mut self, value: u32) -> Self {
        self.r#status = value.into();
        self
    }
}
impl ::micropb::MessageDecode for r#wifi_event_action_tx_status {
    fn decode<IMPL_MICROPB_READ: ::micropb::PbRead>(
        &mut self,
        decoder: &mut ::micropb::PbDecoder<IMPL_MICROPB_READ>,
        len: usize,
    ) -> Result<(), ::micropb::DecodeError<IMPL_MICROPB_READ::Error>> {
        use ::micropb::{FieldDecode, PbBytes, PbMap, PbString, PbVec};
        let before = decoder.bytes_read();
        while decoder.bytes_read() - before < len {
            let tag = decoder.decode_tag()?;
            match tag.field_num() {
                0 => return Err(::micropb::DecodeError::ZeroField),
                1u32 => {
                    let mut_ref = &mut self.r#ifx;
                    {
                        let val = decoder.decode_int32()?;
                        let val_ref = &val;
                        if *val_ref != 0 {
                            *mut_ref = val as _;
                        }
                    };
                }
                2u32 => {
                    let mut_ref = &mut self.r#context;
                    {
                        let val = decoder.decode_varint32()?;
                        let val_ref = &val;
                        if *val_ref != 0 {
                            *mut_ref = val as _;
                        }
                    };
                }
                3u32 => {
                    let mut_ref = &mut self.r#da;
                    {
                        decoder.decode_bytes(mut_ref, ::micropb::Presence::Implicit)?;
                    };
                }
                4u32 => {
                    let mut_ref = &mut self.r#status;
                    {
                        let val = decoder.decode_varint32()?;
                        let val_ref = &val;
                        if *val_ref != 0 {
                            *mut_ref = val as _;
                        }
                    };
                }
                _ => {
                    decoder.skip_wire_value(tag.wire_type())?;
                }
            }
        }
        Ok(())
    }
}
impl ::micropb::MessageEncode for r#wifi_event_action_tx_status {
    const MAX_SIZE: ::core::option::Option<usize> = 'msg: {
        let mut max_size = 0;
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(10usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(5usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(7usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(5usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        ::core::option::Option::Some(max_size)
    };
    fn encode<IMPL_MICROPB_WRITE: ::micropb::PbWrite>(
        &self,
        encoder: &mut ::micropb::PbEncoder<IMPL_MICROPB_WRITE>,
    ) -> Result<(), IMPL_MICROPB_WRITE::Error> {
        use ::micropb::{FieldEncode, PbMap};
        {
            let val_ref = &self.r#ifx;
            if *val_ref != 0 {
                encoder.encode_varint32(8u32)?;
                encoder.encode_int32(*val_ref as _)?;
            }
        }
        {
            let val_ref = &self.r#context;
            if *val_ref != 0 {
                encoder.encode_varint32(16u32)?;
                encoder.encode_varint32(*val_ref as _)?;
            }
        }
        {
            let val_ref = &self.r#da;
            if !val_ref.is_empty() {
                encoder.encode_varint32(26u32)?;
                encoder.encode_bytes(val_ref)?;
            }
        }
        {
            let val_ref = &self.r#status;
            if *val_ref != 0 {
                encoder.encode_varint32(32u32)?;
                encoder.encode_varint32(*val_ref as _)?;
            }
        }
        Ok(())
    }
    fn compute_size(&self) -> usize {
        use ::micropb::{FieldEncode, PbMap};
        let mut size = 0;
        {
            let val_ref = &self.r#ifx;
            if *val_ref != 0 {
                size += 1usize + ::micropb::size::sizeof_int32(*val_ref as _);
            }
        }
        {
            let val_ref = &self.r#context;
            if *val_ref != 0 {
                size += 1usize + ::micropb::size::sizeof_varint32(*val_ref as _);
            }
        }
        {
            let val_ref = &self.r#da;
            if !val_ref.is_empty() {
                size += 1usize + ::micropb::size::sizeof_len_record(val_ref.len());
            }
        }
        {
            let val_ref = &self.r#status;
            if *val_ref != 0 {
                size += 1usize + ::micropb::size::sizeof_varint32(*val_ref as _);
            }
        }
        size
    }
}
#[derive(Debug, Default, PartialEq, Clone)]
pub struct r#wifi_event_roc_done {
    pub r#context: u32,
}
impl r#wifi_event_roc_done {
    ///Return a reference to `context`
    #[inline]
    pub fn r#context(&self) -> &u32 {
        &self.r#context
    }
    ///Return a mutable reference to `context`
    #[inline]
    pub fn mut_context(&mut self) -> &mut u32 {
        &mut self.r#context
    }
    ///Set the value of `context`
    #[inline]
    pub fn set_context(&mut self, value: u32) -> &mut Self {
        self.r#context = value.into();
        self
    }
    ///Builder method that sets the value of `context`. Useful for initializing the message.
    #[inline]
    pub fn init_context(mut self, value: u32) -> Self {
        self.r#context = value.into();
        self
    }
}
impl ::micropb::MessageDecode for r#wifi_event_roc_done {
    fn decode<IMPL_MICROPB_READ: ::micropb::PbRead>(
        &mut self,
        decoder: &mut ::micropb::PbDecoder<IMPL_MICROPB_READ>,
        len: usize,
    ) -> Result<(), ::micropb::DecodeError<IMPL_MICROPB_READ::Error>> {
        use ::micropb::{FieldDecode, PbBytes, PbMap, PbString, PbVec};
        let before = decoder.bytes_read();
        while decoder.bytes_read() - before < len {
            let tag = decoder.decode_tag()?;
            match tag.field_num() {
                0 => return Err(::micropb::DecodeError::ZeroField),
                1u32 => {
                    let mut_ref = &mut self.r#context;
                    {
                        let val = decoder.decode_varint32()?;
                        let val_ref = &val;
                        if *val_ref != 0 {
                            *mut_ref = val as _;
                        }
                    };
                }
                _ => {
                    decoder.skip_wire_value(tag.wire_type())?;
                }
            }
        }
        Ok(())
    }
}
impl ::micropb::MessageEncode for r#wifi_event_roc_done {
    const MAX_SIZE: ::core::option::Option<usize> = 'msg: {
        let mut max_size = 0;
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(5usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        ::core::option::Option::Some(max_size)
    };
    fn encode<IMPL_MICROPB_WRITE: ::micropb::PbWrite>(
        &self,
        encoder: &mut ::micropb::PbEncoder<IMPL_MICROPB_WRITE>,
    ) -> Result<(), IMPL_MICROPB_WRITE::Error> {
        use ::micropb::{FieldEncode, PbMap};
        {
            let val_ref = &self.r#context;
            if *val_ref != 0 {
                encoder.encode_varint32(8u32)?;
                encoder.encode_varint32(*val_ref as _)?;
            }
        }
        Ok(())
    }
    fn compute_size(&self) -> usize {
        use ::micropb::{FieldEncode, PbMap};
        let mut size = 0;
        {
            let val_ref = &self.r#context;
            if *val_ref != 0 {
                size += 1usize + ::micropb::size::sizeof_varint32(*val_ref as _);
            }
        }
        size
    }
}
#[derive(Debug, Default, PartialEq, Clone)]
pub struct r#wifi_event_ap_wps_rg_pin {
    pub r#pin_code: ::micropb::heapless::Vec<u8, 8>,
}
impl r#wifi_event_ap_wps_rg_pin {
    ///Return a reference to `pin_code`
    #[inline]
    pub fn r#pin_code(&self) -> &::micropb::heapless::Vec<u8, 8> {
        &self.r#pin_code
    }
    ///Return a mutable reference to `pin_code`
    #[inline]
    pub fn mut_pin_code(&mut self) -> &mut ::micropb::heapless::Vec<u8, 8> {
        &mut self.r#pin_code
    }
    ///Set the value of `pin_code`
    #[inline]
    pub fn set_pin_code(&mut self, value: ::micropb::heapless::Vec<u8, 8>) -> &mut Self {
        self.r#pin_code = value.into();
        self
    }
    ///Builder method that sets the value of `pin_code`. Useful for initializing the message.
    #[inline]
    pub fn init_pin_code(mut self, value: ::micropb::heapless::Vec<u8, 8>) -> Self {
        self.r#pin_code = value.into();
        self
    }
}
impl ::micropb::MessageDecode for r#wifi_event_ap_wps_rg_pin {
    fn decode<IMPL_MICROPB_READ: ::micropb::PbRead>(
        &mut self,
        decoder: &mut ::micropb::PbDecoder<IMPL_MICROPB_READ>,
        len: usize,
    ) -> Result<(), ::micropb::DecodeError<IMPL_MICROPB_READ::Error>> {
        use ::micropb::{FieldDecode, PbBytes, PbMap, PbString, PbVec};
        let before = decoder.bytes_read();
        while decoder.bytes_read() - before < len {
            let tag = decoder.decode_tag()?;
            match tag.field_num() {
                0 => return Err(::micropb::DecodeError::ZeroField),
                1u32 => {
                    let mut_ref = &mut self.r#pin_code;
                    {
                        decoder.decode_bytes(mut_ref, ::micropb::Presence::Implicit)?;
                    };
                }
                _ => {
                    decoder.skip_wire_value(tag.wire_type())?;
                }
            }
        }
        Ok(())
    }
}
impl ::micropb::MessageEncode for r#wifi_event_ap_wps_rg_pin {
    const MAX_SIZE: ::core::option::Option<usize> = 'msg: {
        let mut max_size = 0;
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(9usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        ::core::option::Option::Some(max_size)
    };
    fn encode<IMPL_MICROPB_WRITE: ::micropb::PbWrite>(
        &self,
        encoder: &mut ::micropb::PbEncoder<IMPL_MICROPB_WRITE>,
    ) -> Result<(), IMPL_MICROPB_WRITE::Error> {
        use ::micropb::{FieldEncode, PbMap};
        {
            let val_ref = &self.r#pin_code;
            if !val_ref.is_empty() {
                encoder.encode_varint32(10u32)?;
                encoder.encode_bytes(val_ref)?;
            }
        }
        Ok(())
    }
    fn compute_size(&self) -> usize {
        use ::micropb::{FieldEncode, PbMap};
        let mut size = 0;
        {
            let val_ref = &self.r#pin_code;
            if !val_ref.is_empty() {
                size += 1usize + ::micropb::size::sizeof_len_record(val_ref.len());
            }
        }
        size
    }
}
#[derive(Debug, Default, PartialEq, Clone)]
pub struct r#wifi_event_ap_wps_rg_fail_reason {
    pub r#reason: i32,
    pub r#peer_macaddr: ::micropb::heapless::Vec<u8, 6>,
}
impl r#wifi_event_ap_wps_rg_fail_reason {
    ///Return a reference to `reason`
    #[inline]
    pub fn r#reason(&self) -> &i32 {
        &self.r#reason
    }
    ///Return a mutable reference to `reason`
    #[inline]
    pub fn mut_reason(&mut self) -> &mut i32 {
        &mut self.r#reason
    }
    ///Set the value of `reason`
    #[inline]
    pub fn set_reason(&mut self, value: i32) -> &mut Self {
        self.r#reason = value.into();
        self
    }
    ///Builder method that sets the value of `reason`. Useful for initializing the message.
    #[inline]
    pub fn init_reason(mut self, value: i32) -> Self {
        self.r#reason = value.into();
        self
    }
    ///Return a reference to `peer_macaddr`
    #[inline]
    pub fn r#peer_macaddr(&self) -> &::micropb::heapless::Vec<u8, 6> {
        &self.r#peer_macaddr
    }
    ///Return a mutable reference to `peer_macaddr`
    #[inline]
    pub fn mut_peer_macaddr(&mut self) -> &mut ::micropb::heapless::Vec<u8, 6> {
        &mut self.r#peer_macaddr
    }
    ///Set the value of `peer_macaddr`
    #[inline]
    pub fn set_peer_macaddr(&mut self, value: ::micropb::heapless::Vec<u8, 6>) -> &mut Self {
        self.r#peer_macaddr = value.into();
        self
    }
    ///Builder method that sets the value of `peer_macaddr`. Useful for initializing the message.
    #[inline]
    pub fn init_peer_macaddr(mut self, value: ::micropb::heapless::Vec<u8, 6>) -> Self {
        self.r#peer_macaddr = value.into();
        self
    }
}
impl ::micropb::MessageDecode for r#wifi_event_ap_wps_rg_fail_reason {
    fn decode<IMPL_MICROPB_READ: ::micropb::PbRead>(
        &mut self,
        decoder: &mut ::micropb::PbDecoder<IMPL_MICROPB_READ>,
        len: usize,
    ) -> Result<(), ::micropb::DecodeError<IMPL_MICROPB_READ::Error>> {
        use ::micropb::{FieldDecode, PbBytes, PbMap, PbString, PbVec};
        let before = decoder.bytes_read();
        while decoder.bytes_read() - before < len {
            let tag = decoder.decode_tag()?;
            match tag.field_num() {
                0 => return Err(::micropb::DecodeError::ZeroField),
                1u32 => {
                    let mut_ref = &mut self.r#reason;
                    {
                        let val = decoder.decode_int32()?;
                        let val_ref = &val;
                        if *val_ref != 0 {
                            *mut_ref = val as _;
                        }
                    };
                }
                2u32 => {
                    let mut_ref = &mut self.r#peer_macaddr;
                    {
                        decoder.decode_bytes(mut_ref, ::micropb::Presence::Implicit)?;
                    };
                }
                _ => {
                    decoder.skip_wire_value(tag.wire_type())?;
                }
            }
        }
        Ok(())
    }
}
impl ::micropb::MessageEncode for r#wifi_event_ap_wps_rg_fail_reason {
    const MAX_SIZE: ::core::option::Option<usize> = 'msg: {
        let mut max_size = 0;
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(10usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(7usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        ::core::option::Option::Some(max_size)
    };
    fn encode<IMPL_MICROPB_WRITE: ::micropb::PbWrite>(
        &self,
        encoder: &mut ::micropb::PbEncoder<IMPL_MICROPB_WRITE>,
    ) -> Result<(), IMPL_MICROPB_WRITE::Error> {
        use ::micropb::{FieldEncode, PbMap};
        {
            let val_ref = &self.r#reason;
            if *val_ref != 0 {
                encoder.encode_varint32(8u32)?;
                encoder.encode_int32(*val_ref as _)?;
            }
        }
        {
            let val_ref = &self.r#peer_macaddr;
            if !val_ref.is_empty() {
                encoder.encode_varint32(18u32)?;
                encoder.encode_bytes(val_ref)?;
            }
        }
        Ok(())
    }
    fn compute_size(&self) -> usize {
        use ::micropb::{FieldEncode, PbMap};
        let mut size = 0;
        {
            let val_ref = &self.r#reason;
            if *val_ref != 0 {
                size += 1usize + ::micropb::size::sizeof_int32(*val_ref as _);
            }
        }
        {
            let val_ref = &self.r#peer_macaddr;
            if !val_ref.is_empty() {
                size += 1usize + ::micropb::size::sizeof_len_record(val_ref.len());
            }
        }
        size
    }
}
#[derive(Debug, Default, PartialEq, Clone)]
pub struct r#wifi_event_ap_wps_rg_success {
    pub r#peer_macaddr: ::micropb::heapless::Vec<u8, 6>,
}
impl r#wifi_event_ap_wps_rg_success {
    ///Return a reference to `peer_macaddr`
    #[inline]
    pub fn r#peer_macaddr(&self) -> &::micropb::heapless::Vec<u8, 6> {
        &self.r#peer_macaddr
    }
    ///Return a mutable reference to `peer_macaddr`
    #[inline]
    pub fn mut_peer_macaddr(&mut self) -> &mut ::micropb::heapless::Vec<u8, 6> {
        &mut self.r#peer_macaddr
    }
    ///Set the value of `peer_macaddr`
    #[inline]
    pub fn set_peer_macaddr(&mut self, value: ::micropb::heapless::Vec<u8, 6>) -> &mut Self {
        self.r#peer_macaddr = value.into();
        self
    }
    ///Builder method that sets the value of `peer_macaddr`. Useful for initializing the message.
    #[inline]
    pub fn init_peer_macaddr(mut self, value: ::micropb::heapless::Vec<u8, 6>) -> Self {
        self.r#peer_macaddr = value.into();
        self
    }
}
impl ::micropb::MessageDecode for r#wifi_event_ap_wps_rg_success {
    fn decode<IMPL_MICROPB_READ: ::micropb::PbRead>(
        &mut self,
        decoder: &mut ::micropb::PbDecoder<IMPL_MICROPB_READ>,
        len: usize,
    ) -> Result<(), ::micropb::DecodeError<IMPL_MICROPB_READ::Error>> {
        use ::micropb::{FieldDecode, PbBytes, PbMap, PbString, PbVec};
        let before = decoder.bytes_read();
        while decoder.bytes_read() - before < len {
            let tag = decoder.decode_tag()?;
            match tag.field_num() {
                0 => return Err(::micropb::DecodeError::ZeroField),
                1u32 => {
                    let mut_ref = &mut self.r#peer_macaddr;
                    {
                        decoder.decode_bytes(mut_ref, ::micropb::Presence::Implicit)?;
                    };
                }
                _ => {
                    decoder.skip_wire_value(tag.wire_type())?;
                }
            }
        }
        Ok(())
    }
}
impl ::micropb::MessageEncode for r#wifi_event_ap_wps_rg_success {
    const MAX_SIZE: ::core::option::Option<usize> = 'msg: {
        let mut max_size = 0;
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(7usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        ::core::option::Option::Some(max_size)
    };
    fn encode<IMPL_MICROPB_WRITE: ::micropb::PbWrite>(
        &self,
        encoder: &mut ::micropb::PbEncoder<IMPL_MICROPB_WRITE>,
    ) -> Result<(), IMPL_MICROPB_WRITE::Error> {
        use ::micropb::{FieldEncode, PbMap};
        {
            let val_ref = &self.r#peer_macaddr;
            if !val_ref.is_empty() {
                encoder.encode_varint32(10u32)?;
                encoder.encode_bytes(val_ref)?;
            }
        }
        Ok(())
    }
    fn compute_size(&self) -> usize {
        use ::micropb::{FieldEncode, PbMap};
        let mut size = 0;
        {
            let val_ref = &self.r#peer_macaddr;
            if !val_ref.is_empty() {
                size += 1usize + ::micropb::size::sizeof_len_record(val_ref.len());
            }
        }
        size
    }
}
#[derive(Debug, Default, PartialEq, Clone)]
pub struct r#wifi_protocols {
    pub r#ghz_2g: u32,
    pub r#ghz_5g: u32,
}
impl r#wifi_protocols {
    ///Return a reference to `ghz_2g`
    #[inline]
    pub fn r#ghz_2g(&self) -> &u32 {
        &self.r#ghz_2g
    }
    ///Return a mutable reference to `ghz_2g`
    #[inline]
    pub fn mut_ghz_2g(&mut self) -> &mut u32 {
        &mut self.r#ghz_2g
    }
    ///Set the value of `ghz_2g`
    #[inline]
    pub fn set_ghz_2g(&mut self, value: u32) -> &mut Self {
        self.r#ghz_2g = value.into();
        self
    }
    ///Builder method that sets the value of `ghz_2g`. Useful for initializing the message.
    #[inline]
    pub fn init_ghz_2g(mut self, value: u32) -> Self {
        self.r#ghz_2g = value.into();
        self
    }
    ///Return a reference to `ghz_5g`
    #[inline]
    pub fn r#ghz_5g(&self) -> &u32 {
        &self.r#ghz_5g
    }
    ///Return a mutable reference to `ghz_5g`
    #[inline]
    pub fn mut_ghz_5g(&mut self) -> &mut u32 {
        &mut self.r#ghz_5g
    }
    ///Set the value of `ghz_5g`
    #[inline]
    pub fn set_ghz_5g(&mut self, value: u32) -> &mut Self {
        self.r#ghz_5g = value.into();
        self
    }
    ///Builder method that sets the value of `ghz_5g`. Useful for initializing the message.
    #[inline]
    pub fn init_ghz_5g(mut self, value: u32) -> Self {
        self.r#ghz_5g = value.into();
        self
    }
}
impl ::micropb::MessageDecode for r#wifi_protocols {
    fn decode<IMPL_MICROPB_READ: ::micropb::PbRead>(
        &mut self,
        decoder: &mut ::micropb::PbDecoder<IMPL_MICROPB_READ>,
        len: usize,
    ) -> Result<(), ::micropb::DecodeError<IMPL_MICROPB_READ::Error>> {
        use ::micropb::{FieldDecode, PbBytes, PbMap, PbString, PbVec};
        let before = decoder.bytes_read();
        while decoder.bytes_read() - before < len {
            let tag = decoder.decode_tag()?;
            match tag.field_num() {
                0 => return Err(::micropb::DecodeError::ZeroField),
                1u32 => {
                    let mut_ref = &mut self.r#ghz_2g;
                    {
                        let val = decoder.decode_varint32()?;
                        let val_ref = &val;
                        if *val_ref != 0 {
                            *mut_ref = val as _;
                        }
                    };
                }
                2u32 => {
                    let mut_ref = &mut self.r#ghz_5g;
                    {
                        let val = decoder.decode_varint32()?;
                        let val_ref = &val;
                        if *val_ref != 0 {
                            *mut_ref = val as _;
                        }
                    };
                }
                _ => {
                    decoder.skip_wire_value(tag.wire_type())?;
                }
            }
        }
        Ok(())
    }
}
impl ::micropb::MessageEncode for r#wifi_protocols {
    const MAX_SIZE: ::core::option::Option<usize> = 'msg: {
        let mut max_size = 0;
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(5usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(5usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        ::core::option::Option::Some(max_size)
    };
    fn encode<IMPL_MICROPB_WRITE: ::micropb::PbWrite>(
        &self,
        encoder: &mut ::micropb::PbEncoder<IMPL_MICROPB_WRITE>,
    ) -> Result<(), IMPL_MICROPB_WRITE::Error> {
        use ::micropb::{FieldEncode, PbMap};
        {
            let val_ref = &self.r#ghz_2g;
            if *val_ref != 0 {
                encoder.encode_varint32(8u32)?;
                encoder.encode_varint32(*val_ref as _)?;
            }
        }
        {
            let val_ref = &self.r#ghz_5g;
            if *val_ref != 0 {
                encoder.encode_varint32(16u32)?;
                encoder.encode_varint32(*val_ref as _)?;
            }
        }
        Ok(())
    }
    fn compute_size(&self) -> usize {
        use ::micropb::{FieldEncode, PbMap};
        let mut size = 0;
        {
            let val_ref = &self.r#ghz_2g;
            if *val_ref != 0 {
                size += 1usize + ::micropb::size::sizeof_varint32(*val_ref as _);
            }
        }
        {
            let val_ref = &self.r#ghz_5g;
            if *val_ref != 0 {
                size += 1usize + ::micropb::size::sizeof_varint32(*val_ref as _);
            }
        }
        size
    }
}
#[derive(Debug, Default, PartialEq, Clone)]
pub struct r#wifi_bandwidths {
    pub r#ghz_2g: u32,
    pub r#ghz_5g: u32,
}
impl r#wifi_bandwidths {
    ///Return a reference to `ghz_2g`
    #[inline]
    pub fn r#ghz_2g(&self) -> &u32 {
        &self.r#ghz_2g
    }
    ///Return a mutable reference to `ghz_2g`
    #[inline]
    pub fn mut_ghz_2g(&mut self) -> &mut u32 {
        &mut self.r#ghz_2g
    }
    ///Set the value of `ghz_2g`
    #[inline]
    pub fn set_ghz_2g(&mut self, value: u32) -> &mut Self {
        self.r#ghz_2g = value.into();
        self
    }
    ///Builder method that sets the value of `ghz_2g`. Useful for initializing the message.
    #[inline]
    pub fn init_ghz_2g(mut self, value: u32) -> Self {
        self.r#ghz_2g = value.into();
        self
    }
    ///Return a reference to `ghz_5g`
    #[inline]
    pub fn r#ghz_5g(&self) -> &u32 {
        &self.r#ghz_5g
    }
    ///Return a mutable reference to `ghz_5g`
    #[inline]
    pub fn mut_ghz_5g(&mut self) -> &mut u32 {
        &mut self.r#ghz_5g
    }
    ///Set the value of `ghz_5g`
    #[inline]
    pub fn set_ghz_5g(&mut self, value: u32) -> &mut Self {
        self.r#ghz_5g = value.into();
        self
    }
    ///Builder method that sets the value of `ghz_5g`. Useful for initializing the message.
    #[inline]
    pub fn init_ghz_5g(mut self, value: u32) -> Self {
        self.r#ghz_5g = value.into();
        self
    }
}
impl ::micropb::MessageDecode for r#wifi_bandwidths {
    fn decode<IMPL_MICROPB_READ: ::micropb::PbRead>(
        &mut self,
        decoder: &mut ::micropb::PbDecoder<IMPL_MICROPB_READ>,
        len: usize,
    ) -> Result<(), ::micropb::DecodeError<IMPL_MICROPB_READ::Error>> {
        use ::micropb::{FieldDecode, PbBytes, PbMap, PbString, PbVec};
        let before = decoder.bytes_read();
        while decoder.bytes_read() - before < len {
            let tag = decoder.decode_tag()?;
            match tag.field_num() {
                0 => return Err(::micropb::DecodeError::ZeroField),
                1u32 => {
                    let mut_ref = &mut self.r#ghz_2g;
                    {
                        let val = decoder.decode_varint32()?;
                        let val_ref = &val;
                        if *val_ref != 0 {
                            *mut_ref = val as _;
                        }
                    };
                }
                2u32 => {
                    let mut_ref = &mut self.r#ghz_5g;
                    {
                        let val = decoder.decode_varint32()?;
                        let val_ref = &val;
                        if *val_ref != 0 {
                            *mut_ref = val as _;
                        }
                    };
                }
                _ => {
                    decoder.skip_wire_value(tag.wire_type())?;
                }
            }
        }
        Ok(())
    }
}
impl ::micropb::MessageEncode for r#wifi_bandwidths {
    const MAX_SIZE: ::core::option::Option<usize> = 'msg: {
        let mut max_size = 0;
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(5usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(5usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        ::core::option::Option::Some(max_size)
    };
    fn encode<IMPL_MICROPB_WRITE: ::micropb::PbWrite>(
        &self,
        encoder: &mut ::micropb::PbEncoder<IMPL_MICROPB_WRITE>,
    ) -> Result<(), IMPL_MICROPB_WRITE::Error> {
        use ::micropb::{FieldEncode, PbMap};
        {
            let val_ref = &self.r#ghz_2g;
            if *val_ref != 0 {
                encoder.encode_varint32(8u32)?;
                encoder.encode_varint32(*val_ref as _)?;
            }
        }
        {
            let val_ref = &self.r#ghz_5g;
            if *val_ref != 0 {
                encoder.encode_varint32(16u32)?;
                encoder.encode_varint32(*val_ref as _)?;
            }
        }
        Ok(())
    }
    fn compute_size(&self) -> usize {
        use ::micropb::{FieldEncode, PbMap};
        let mut size = 0;
        {
            let val_ref = &self.r#ghz_2g;
            if *val_ref != 0 {
                size += 1usize + ::micropb::size::sizeof_varint32(*val_ref as _);
            }
        }
        {
            let val_ref = &self.r#ghz_5g;
            if *val_ref != 0 {
                size += 1usize + ::micropb::size::sizeof_varint32(*val_ref as _);
            }
        }
        size
    }
}
#[derive(Debug, Default, PartialEq, Clone)]
pub struct ConnectedSTAList {
    pub r#mac: ::micropb::heapless::Vec<u8, 16>,
    pub r#rssi: i32,
}
impl ConnectedSTAList {
    ///Return a reference to `mac`
    #[inline]
    pub fn r#mac(&self) -> &::micropb::heapless::Vec<u8, 16> {
        &self.r#mac
    }
    ///Return a mutable reference to `mac`
    #[inline]
    pub fn mut_mac(&mut self) -> &mut ::micropb::heapless::Vec<u8, 16> {
        &mut self.r#mac
    }
    ///Set the value of `mac`
    #[inline]
    pub fn set_mac(&mut self, value: ::micropb::heapless::Vec<u8, 16>) -> &mut Self {
        self.r#mac = value.into();
        self
    }
    ///Builder method that sets the value of `mac`. Useful for initializing the message.
    #[inline]
    pub fn init_mac(mut self, value: ::micropb::heapless::Vec<u8, 16>) -> Self {
        self.r#mac = value.into();
        self
    }
    ///Return a reference to `rssi`
    #[inline]
    pub fn r#rssi(&self) -> &i32 {
        &self.r#rssi
    }
    ///Return a mutable reference to `rssi`
    #[inline]
    pub fn mut_rssi(&mut self) -> &mut i32 {
        &mut self.r#rssi
    }
    ///Set the value of `rssi`
    #[inline]
    pub fn set_rssi(&mut self, value: i32) -> &mut Self {
        self.r#rssi = value.into();
        self
    }
    ///Builder method that sets the value of `rssi`. Useful for initializing the message.
    #[inline]
    pub fn init_rssi(mut self, value: i32) -> Self {
        self.r#rssi = value.into();
        self
    }
}
impl ::micropb::MessageDecode for ConnectedSTAList {
    fn decode<IMPL_MICROPB_READ: ::micropb::PbRead>(
        &mut self,
        decoder: &mut ::micropb::PbDecoder<IMPL_MICROPB_READ>,
        len: usize,
    ) -> Result<(), ::micropb::DecodeError<IMPL_MICROPB_READ::Error>> {
        use ::micropb::{FieldDecode, PbBytes, PbMap, PbString, PbVec};
        let before = decoder.bytes_read();
        while decoder.bytes_read() - before < len {
            let tag = decoder.decode_tag()?;
            match tag.field_num() {
                0 => return Err(::micropb::DecodeError::ZeroField),
                1u32 => {
                    let mut_ref = &mut self.r#mac;
                    {
                        decoder.decode_bytes(mut_ref, ::micropb::Presence::Implicit)?;
                    };
                }
                2u32 => {
                    let mut_ref = &mut self.r#rssi;
                    {
                        let val = decoder.decode_int32()?;
                        let val_ref = &val;
                        if *val_ref != 0 {
                            *mut_ref = val as _;
                        }
                    };
                }
                _ => {
                    decoder.skip_wire_value(tag.wire_type())?;
                }
            }
        }
        Ok(())
    }
}
impl ::micropb::MessageEncode for ConnectedSTAList {
    const MAX_SIZE: ::core::option::Option<usize> = 'msg: {
        let mut max_size = 0;
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(17usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(10usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        ::core::option::Option::Some(max_size)
    };
    fn encode<IMPL_MICROPB_WRITE: ::micropb::PbWrite>(
        &self,
        encoder: &mut ::micropb::PbEncoder<IMPL_MICROPB_WRITE>,
    ) -> Result<(), IMPL_MICROPB_WRITE::Error> {
        use ::micropb::{FieldEncode, PbMap};
        {
            let val_ref = &self.r#mac;
            if !val_ref.is_empty() {
                encoder.encode_varint32(10u32)?;
                encoder.encode_bytes(val_ref)?;
            }
        }
        {
            let val_ref = &self.r#rssi;
            if *val_ref != 0 {
                encoder.encode_varint32(16u32)?;
                encoder.encode_int32(*val_ref as _)?;
            }
        }
        Ok(())
    }
    fn compute_size(&self) -> usize {
        use ::micropb::{FieldEncode, PbMap};
        let mut size = 0;
        {
            let val_ref = &self.r#mac;
            if !val_ref.is_empty() {
                size += 1usize + ::micropb::size::sizeof_len_record(val_ref.len());
            }
        }
        {
            let val_ref = &self.r#rssi;
            if *val_ref != 0 {
                size += 1usize + ::micropb::size::sizeof_int32(*val_ref as _);
            }
        }
        size
    }
}
#[derive(Debug, Default, PartialEq, Clone)]
pub struct Rpc_Req_GetMacAddress {
    pub r#mode: i32,
}
impl Rpc_Req_GetMacAddress {
    ///Return a reference to `mode`
    #[inline]
    pub fn r#mode(&self) -> &i32 {
        &self.r#mode
    }
    ///Return a mutable reference to `mode`
    #[inline]
    pub fn mut_mode(&mut self) -> &mut i32 {
        &mut self.r#mode
    }
    ///Set the value of `mode`
    #[inline]
    pub fn set_mode(&mut self, value: i32) -> &mut Self {
        self.r#mode = value.into();
        self
    }
    ///Builder method that sets the value of `mode`. Useful for initializing the message.
    #[inline]
    pub fn init_mode(mut self, value: i32) -> Self {
        self.r#mode = value.into();
        self
    }
}
impl ::micropb::MessageDecode for Rpc_Req_GetMacAddress {
    fn decode<IMPL_MICROPB_READ: ::micropb::PbRead>(
        &mut self,
        decoder: &mut ::micropb::PbDecoder<IMPL_MICROPB_READ>,
        len: usize,
    ) -> Result<(), ::micropb::DecodeError<IMPL_MICROPB_READ::Error>> {
        use ::micropb::{FieldDecode, PbBytes, PbMap, PbString, PbVec};
        let before = decoder.bytes_read();
        while decoder.bytes_read() - before < len {
            let tag = decoder.decode_tag()?;
            match tag.field_num() {
                0 => return Err(::micropb::DecodeError::ZeroField),
                1u32 => {
                    let mut_ref = &mut self.r#mode;
                    {
                        let val = decoder.decode_int32()?;
                        let val_ref = &val;
                        if *val_ref != 0 {
                            *mut_ref = val as _;
                        }
                    };
                }
                _ => {
                    decoder.skip_wire_value(tag.wire_type())?;
                }
            }
        }
        Ok(())
    }
}
impl ::micropb::MessageEncode for Rpc_Req_GetMacAddress {
    const MAX_SIZE: ::core::option::Option<usize> = 'msg: {
        let mut max_size = 0;
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(10usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        ::core::option::Option::Some(max_size)
    };
    fn encode<IMPL_MICROPB_WRITE: ::micropb::PbWrite>(
        &self,
        encoder: &mut ::micropb::PbEncoder<IMPL_MICROPB_WRITE>,
    ) -> Result<(), IMPL_MICROPB_WRITE::Error> {
        use ::micropb::{FieldEncode, PbMap};
        {
            let val_ref = &self.r#mode;
            if *val_ref != 0 {
                encoder.encode_varint32(8u32)?;
                encoder.encode_int32(*val_ref as _)?;
            }
        }
        Ok(())
    }
    fn compute_size(&self) -> usize {
        use ::micropb::{FieldEncode, PbMap};
        let mut size = 0;
        {
            let val_ref = &self.r#mode;
            if *val_ref != 0 {
                size += 1usize + ::micropb::size::sizeof_int32(*val_ref as _);
            }
        }
        size
    }
}
#[derive(Debug, Default, PartialEq, Clone)]
pub struct Rpc_Resp_GetMacAddress {
    pub r#mac: ::micropb::heapless::Vec<u8, 6>,
    pub r#resp: i32,
}
impl Rpc_Resp_GetMacAddress {
    ///Return a reference to `mac`
    #[inline]
    pub fn r#mac(&self) -> &::micropb::heapless::Vec<u8, 6> {
        &self.r#mac
    }
    ///Return a mutable reference to `mac`
    #[inline]
    pub fn mut_mac(&mut self) -> &mut ::micropb::heapless::Vec<u8, 6> {
        &mut self.r#mac
    }
    ///Set the value of `mac`
    #[inline]
    pub fn set_mac(&mut self, value: ::micropb::heapless::Vec<u8, 6>) -> &mut Self {
        self.r#mac = value.into();
        self
    }
    ///Builder method that sets the value of `mac`. Useful for initializing the message.
    #[inline]
    pub fn init_mac(mut self, value: ::micropb::heapless::Vec<u8, 6>) -> Self {
        self.r#mac = value.into();
        self
    }
    ///Return a reference to `resp`
    #[inline]
    pub fn r#resp(&self) -> &i32 {
        &self.r#resp
    }
    ///Return a mutable reference to `resp`
    #[inline]
    pub fn mut_resp(&mut self) -> &mut i32 {
        &mut self.r#resp
    }
    ///Set the value of `resp`
    #[inline]
    pub fn set_resp(&mut self, value: i32) -> &mut Self {
        self.r#resp = value.into();
        self
    }
    ///Builder method that sets the value of `resp`. Useful for initializing the message.
    #[inline]
    pub fn init_resp(mut self, value: i32) -> Self {
        self.r#resp = value.into();
        self
    }
}
impl ::micropb::MessageDecode for Rpc_Resp_GetMacAddress {
    fn decode<IMPL_MICROPB_READ: ::micropb::PbRead>(
        &mut self,
        decoder: &mut ::micropb::PbDecoder<IMPL_MICROPB_READ>,
        len: usize,
    ) -> Result<(), ::micropb::DecodeError<IMPL_MICROPB_READ::Error>> {
        use ::micropb::{FieldDecode, PbBytes, PbMap, PbString, PbVec};
        let before = decoder.bytes_read();
        while decoder.bytes_read() - before < len {
            let tag = decoder.decode_tag()?;
            match tag.field_num() {
                0 => return Err(::micropb::DecodeError::ZeroField),
                1u32 => {
                    let mut_ref = &mut self.r#mac;
                    {
                        decoder.decode_bytes(mut_ref, ::micropb::Presence::Implicit)?;
                    };
                }
                2u32 => {
                    let mut_ref = &mut self.r#resp;
                    {
                        let val = decoder.decode_int32()?;
                        let val_ref = &val;
                        if *val_ref != 0 {
                            *mut_ref = val as _;
                        }
                    };
                }
                _ => {
                    decoder.skip_wire_value(tag.wire_type())?;
                }
            }
        }
        Ok(())
    }
}
impl ::micropb::MessageEncode for Rpc_Resp_GetMacAddress {
    const MAX_SIZE: ::core::option::Option<usize> = 'msg: {
        let mut max_size = 0;
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(7usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(10usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        ::core::option::Option::Some(max_size)
    };
    fn encode<IMPL_MICROPB_WRITE: ::micropb::PbWrite>(
        &self,
        encoder: &mut ::micropb::PbEncoder<IMPL_MICROPB_WRITE>,
    ) -> Result<(), IMPL_MICROPB_WRITE::Error> {
        use ::micropb::{FieldEncode, PbMap};
        {
            let val_ref = &self.r#mac;
            if !val_ref.is_empty() {
                encoder.encode_varint32(10u32)?;
                encoder.encode_bytes(val_ref)?;
            }
        }
        {
            let val_ref = &self.r#resp;
            if *val_ref != 0 {
                encoder.encode_varint32(16u32)?;
                encoder.encode_int32(*val_ref as _)?;
            }
        }
        Ok(())
    }
    fn compute_size(&self) -> usize {
        use ::micropb::{FieldEncode, PbMap};
        let mut size = 0;
        {
            let val_ref = &self.r#mac;
            if !val_ref.is_empty() {
                size += 1usize + ::micropb::size::sizeof_len_record(val_ref.len());
            }
        }
        {
            let val_ref = &self.r#resp;
            if *val_ref != 0 {
                size += 1usize + ::micropb::size::sizeof_int32(*val_ref as _);
            }
        }
        size
    }
}
#[derive(Debug, Default, PartialEq, Clone)]
pub struct Rpc_Req_GetMode {}
impl Rpc_Req_GetMode {}
impl ::micropb::MessageDecode for Rpc_Req_GetMode {
    fn decode<IMPL_MICROPB_READ: ::micropb::PbRead>(
        &mut self,
        decoder: &mut ::micropb::PbDecoder<IMPL_MICROPB_READ>,
        len: usize,
    ) -> Result<(), ::micropb::DecodeError<IMPL_MICROPB_READ::Error>> {
        use ::micropb::{FieldDecode, PbBytes, PbMap, PbString, PbVec};
        let before = decoder.bytes_read();
        while decoder.bytes_read() - before < len {
            let tag = decoder.decode_tag()?;
            match tag.field_num() {
                0 => return Err(::micropb::DecodeError::ZeroField),
                _ => {
                    decoder.skip_wire_value(tag.wire_type())?;
                }
            }
        }
        Ok(())
    }
}
impl ::micropb::MessageEncode for Rpc_Req_GetMode {
    const MAX_SIZE: ::core::option::Option<usize> = 'msg: {
        let mut max_size = 0;
        ::core::option::Option::Some(max_size)
    };
    fn encode<IMPL_MICROPB_WRITE: ::micropb::PbWrite>(
        &self,
        encoder: &mut ::micropb::PbEncoder<IMPL_MICROPB_WRITE>,
    ) -> Result<(), IMPL_MICROPB_WRITE::Error> {
        use ::micropb::{FieldEncode, PbMap};
        Ok(())
    }
    fn compute_size(&self) -> usize {
        use ::micropb::{FieldEncode, PbMap};
        let mut size = 0;
        size
    }
}
#[derive(Debug, Default, PartialEq, Clone)]
pub struct Rpc_Resp_GetMode {
    pub r#mode: i32,
    pub r#resp: i32,
}
impl Rpc_Resp_GetMode {
    ///Return a reference to `mode`
    #[inline]
    pub fn r#mode(&self) -> &i32 {
        &self.r#mode
    }
    ///Return a mutable reference to `mode`
    #[inline]
    pub fn mut_mode(&mut self) -> &mut i32 {
        &mut self.r#mode
    }
    ///Set the value of `mode`
    #[inline]
    pub fn set_mode(&mut self, value: i32) -> &mut Self {
        self.r#mode = value.into();
        self
    }
    ///Builder method that sets the value of `mode`. Useful for initializing the message.
    #[inline]
    pub fn init_mode(mut self, value: i32) -> Self {
        self.r#mode = value.into();
        self
    }
    ///Return a reference to `resp`
    #[inline]
    pub fn r#resp(&self) -> &i32 {
        &self.r#resp
    }
    ///Return a mutable reference to `resp`
    #[inline]
    pub fn mut_resp(&mut self) -> &mut i32 {
        &mut self.r#resp
    }
    ///Set the value of `resp`
    #[inline]
    pub fn set_resp(&mut self, value: i32) -> &mut Self {
        self.r#resp = value.into();
        self
    }
    ///Builder method that sets the value of `resp`. Useful for initializing the message.
    #[inline]
    pub fn init_resp(mut self, value: i32) -> Self {
        self.r#resp = value.into();
        self
    }
}
impl ::micropb::MessageDecode for Rpc_Resp_GetMode {
    fn decode<IMPL_MICROPB_READ: ::micropb::PbRead>(
        &mut self,
        decoder: &mut ::micropb::PbDecoder<IMPL_MICROPB_READ>,
        len: usize,
    ) -> Result<(), ::micropb::DecodeError<IMPL_MICROPB_READ::Error>> {
        use ::micropb::{FieldDecode, PbBytes, PbMap, PbString, PbVec};
        let before = decoder.bytes_read();
        while decoder.bytes_read() - before < len {
            let tag = decoder.decode_tag()?;
            match tag.field_num() {
                0 => return Err(::micropb::DecodeError::ZeroField),
                1u32 => {
                    let mut_ref = &mut self.r#mode;
                    {
                        let val = decoder.decode_int32()?;
                        let val_ref = &val;
                        if *val_ref != 0 {
                            *mut_ref = val as _;
                        }
                    };
                }
                2u32 => {
                    let mut_ref = &mut self.r#resp;
                    {
                        let val = decoder.decode_int32()?;
                        let val_ref = &val;
                        if *val_ref != 0 {
                            *mut_ref = val as _;
                        }
                    };
                }
                _ => {
                    decoder.skip_wire_value(tag.wire_type())?;
                }
            }
        }
        Ok(())
    }
}
impl ::micropb::MessageEncode for Rpc_Resp_GetMode {
    const MAX_SIZE: ::core::option::Option<usize> = 'msg: {
        let mut max_size = 0;
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(10usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(10usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        ::core::option::Option::Some(max_size)
    };
    fn encode<IMPL_MICROPB_WRITE: ::micropb::PbWrite>(
        &self,
        encoder: &mut ::micropb::PbEncoder<IMPL_MICROPB_WRITE>,
    ) -> Result<(), IMPL_MICROPB_WRITE::Error> {
        use ::micropb::{FieldEncode, PbMap};
        {
            let val_ref = &self.r#mode;
            if *val_ref != 0 {
                encoder.encode_varint32(8u32)?;
                encoder.encode_int32(*val_ref as _)?;
            }
        }
        {
            let val_ref = &self.r#resp;
            if *val_ref != 0 {
                encoder.encode_varint32(16u32)?;
                encoder.encode_int32(*val_ref as _)?;
            }
        }
        Ok(())
    }
    fn compute_size(&self) -> usize {
        use ::micropb::{FieldEncode, PbMap};
        let mut size = 0;
        {
            let val_ref = &self.r#mode;
            if *val_ref != 0 {
                size += 1usize + ::micropb::size::sizeof_int32(*val_ref as _);
            }
        }
        {
            let val_ref = &self.r#resp;
            if *val_ref != 0 {
                size += 1usize + ::micropb::size::sizeof_int32(*val_ref as _);
            }
        }
        size
    }
}
#[derive(Debug, Default, PartialEq, Clone)]
pub struct Rpc_Req_SetMode {
    pub r#mode: i32,
}
impl Rpc_Req_SetMode {
    ///Return a reference to `mode`
    #[inline]
    pub fn r#mode(&self) -> &i32 {
        &self.r#mode
    }
    ///Return a mutable reference to `mode`
    #[inline]
    pub fn mut_mode(&mut self) -> &mut i32 {
        &mut self.r#mode
    }
    ///Set the value of `mode`
    #[inline]
    pub fn set_mode(&mut self, value: i32) -> &mut Self {
        self.r#mode = value.into();
        self
    }
    ///Builder method that sets the value of `mode`. Useful for initializing the message.
    #[inline]
    pub fn init_mode(mut self, value: i32) -> Self {
        self.r#mode = value.into();
        self
    }
}
impl ::micropb::MessageDecode for Rpc_Req_SetMode {
    fn decode<IMPL_MICROPB_READ: ::micropb::PbRead>(
        &mut self,
        decoder: &mut ::micropb::PbDecoder<IMPL_MICROPB_READ>,
        len: usize,
    ) -> Result<(), ::micropb::DecodeError<IMPL_MICROPB_READ::Error>> {
        use ::micropb::{FieldDecode, PbBytes, PbMap, PbString, PbVec};
        let before = decoder.bytes_read();
        while decoder.bytes_read() - before < len {
            let tag = decoder.decode_tag()?;
            match tag.field_num() {
                0 => return Err(::micropb::DecodeError::ZeroField),
                1u32 => {
                    let mut_ref = &mut self.r#mode;
                    {
                        let val = decoder.decode_int32()?;
                        let val_ref = &val;
                        if *val_ref != 0 {
                            *mut_ref = val as _;
                        }
                    };
                }
                _ => {
                    decoder.skip_wire_value(tag.wire_type())?;
                }
            }
        }
        Ok(())
    }
}
impl ::micropb::MessageEncode for Rpc_Req_SetMode {
    const MAX_SIZE: ::core::option::Option<usize> = 'msg: {
        let mut max_size = 0;
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(10usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        ::core::option::Option::Some(max_size)
    };
    fn encode<IMPL_MICROPB_WRITE: ::micropb::PbWrite>(
        &self,
        encoder: &mut ::micropb::PbEncoder<IMPL_MICROPB_WRITE>,
    ) -> Result<(), IMPL_MICROPB_WRITE::Error> {
        use ::micropb::{FieldEncode, PbMap};
        {
            let val_ref = &self.r#mode;
            if *val_ref != 0 {
                encoder.encode_varint32(8u32)?;
                encoder.encode_int32(*val_ref as _)?;
            }
        }
        Ok(())
    }
    fn compute_size(&self) -> usize {
        use ::micropb::{FieldEncode, PbMap};
        let mut size = 0;
        {
            let val_ref = &self.r#mode;
            if *val_ref != 0 {
                size += 1usize + ::micropb::size::sizeof_int32(*val_ref as _);
            }
        }
        size
    }
}
#[derive(Debug, Default, PartialEq, Clone)]
pub struct Rpc_Resp_SetMode {
    pub r#resp: i32,
}
impl Rpc_Resp_SetMode {
    ///Return a reference to `resp`
    #[inline]
    pub fn r#resp(&self) -> &i32 {
        &self.r#resp
    }
    ///Return a mutable reference to `resp`
    #[inline]
    pub fn mut_resp(&mut self) -> &mut i32 {
        &mut self.r#resp
    }
    ///Set the value of `resp`
    #[inline]
    pub fn set_resp(&mut self, value: i32) -> &mut Self {
        self.r#resp = value.into();
        self
    }
    ///Builder method that sets the value of `resp`. Useful for initializing the message.
    #[inline]
    pub fn init_resp(mut self, value: i32) -> Self {
        self.r#resp = value.into();
        self
    }
}
impl ::micropb::MessageDecode for Rpc_Resp_SetMode {
    fn decode<IMPL_MICROPB_READ: ::micropb::PbRead>(
        &mut self,
        decoder: &mut ::micropb::PbDecoder<IMPL_MICROPB_READ>,
        len: usize,
    ) -> Result<(), ::micropb::DecodeError<IMPL_MICROPB_READ::Error>> {
        use ::micropb::{FieldDecode, PbBytes, PbMap, PbString, PbVec};
        let before = decoder.bytes_read();
        while decoder.bytes_read() - before < len {
            let tag = decoder.decode_tag()?;
            match tag.field_num() {
                0 => return Err(::micropb::DecodeError::ZeroField),
                1u32 => {
                    let mut_ref = &mut self.r#resp;
                    {
                        let val = decoder.decode_int32()?;
                        let val_ref = &val;
                        if *val_ref != 0 {
                            *mut_ref = val as _;
                        }
                    };
                }
                _ => {
                    decoder.skip_wire_value(tag.wire_type())?;
                }
            }
        }
        Ok(())
    }
}
impl ::micropb::MessageEncode for Rpc_Resp_SetMode {
    const MAX_SIZE: ::core::option::Option<usize> = 'msg: {
        let mut max_size = 0;
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(10usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        ::core::option::Option::Some(max_size)
    };
    fn encode<IMPL_MICROPB_WRITE: ::micropb::PbWrite>(
        &self,
        encoder: &mut ::micropb::PbEncoder<IMPL_MICROPB_WRITE>,
    ) -> Result<(), IMPL_MICROPB_WRITE::Error> {
        use ::micropb::{FieldEncode, PbMap};
        {
            let val_ref = &self.r#resp;
            if *val_ref != 0 {
                encoder.encode_varint32(8u32)?;
                encoder.encode_int32(*val_ref as _)?;
            }
        }
        Ok(())
    }
    fn compute_size(&self) -> usize {
        use ::micropb::{FieldEncode, PbMap};
        let mut size = 0;
        {
            let val_ref = &self.r#resp;
            if *val_ref != 0 {
                size += 1usize + ::micropb::size::sizeof_int32(*val_ref as _);
            }
        }
        size
    }
}
#[derive(Debug, Default, PartialEq, Clone)]
pub struct Rpc_Req_GetPs {}
impl Rpc_Req_GetPs {}
impl ::micropb::MessageDecode for Rpc_Req_GetPs {
    fn decode<IMPL_MICROPB_READ: ::micropb::PbRead>(
        &mut self,
        decoder: &mut ::micropb::PbDecoder<IMPL_MICROPB_READ>,
        len: usize,
    ) -> Result<(), ::micropb::DecodeError<IMPL_MICROPB_READ::Error>> {
        use ::micropb::{FieldDecode, PbBytes, PbMap, PbString, PbVec};
        let before = decoder.bytes_read();
        while decoder.bytes_read() - before < len {
            let tag = decoder.decode_tag()?;
            match tag.field_num() {
                0 => return Err(::micropb::DecodeError::ZeroField),
                _ => {
                    decoder.skip_wire_value(tag.wire_type())?;
                }
            }
        }
        Ok(())
    }
}
impl ::micropb::MessageEncode for Rpc_Req_GetPs {
    const MAX_SIZE: ::core::option::Option<usize> = 'msg: {
        let mut max_size = 0;
        ::core::option::Option::Some(max_size)
    };
    fn encode<IMPL_MICROPB_WRITE: ::micropb::PbWrite>(
        &self,
        encoder: &mut ::micropb::PbEncoder<IMPL_MICROPB_WRITE>,
    ) -> Result<(), IMPL_MICROPB_WRITE::Error> {
        use ::micropb::{FieldEncode, PbMap};
        Ok(())
    }
    fn compute_size(&self) -> usize {
        use ::micropb::{FieldEncode, PbMap};
        let mut size = 0;
        size
    }
}
#[derive(Debug, Default, PartialEq, Clone)]
pub struct Rpc_Resp_GetPs {
    pub r#resp: i32,
    pub r#type: i32,
}
impl Rpc_Resp_GetPs {
    ///Return a reference to `resp`
    #[inline]
    pub fn r#resp(&self) -> &i32 {
        &self.r#resp
    }
    ///Return a mutable reference to `resp`
    #[inline]
    pub fn mut_resp(&mut self) -> &mut i32 {
        &mut self.r#resp
    }
    ///Set the value of `resp`
    #[inline]
    pub fn set_resp(&mut self, value: i32) -> &mut Self {
        self.r#resp = value.into();
        self
    }
    ///Builder method that sets the value of `resp`. Useful for initializing the message.
    #[inline]
    pub fn init_resp(mut self, value: i32) -> Self {
        self.r#resp = value.into();
        self
    }
    ///Return a reference to `type`
    #[inline]
    pub fn r#type(&self) -> &i32 {
        &self.r#type
    }
    ///Return a mutable reference to `type`
    #[inline]
    pub fn mut_type(&mut self) -> &mut i32 {
        &mut self.r#type
    }
    ///Set the value of `type`
    #[inline]
    pub fn set_type(&mut self, value: i32) -> &mut Self {
        self.r#type = value.into();
        self
    }
    ///Builder method that sets the value of `type`. Useful for initializing the message.
    #[inline]
    pub fn init_type(mut self, value: i32) -> Self {
        self.r#type = value.into();
        self
    }
}
impl ::micropb::MessageDecode for Rpc_Resp_GetPs {
    fn decode<IMPL_MICROPB_READ: ::micropb::PbRead>(
        &mut self,
        decoder: &mut ::micropb::PbDecoder<IMPL_MICROPB_READ>,
        len: usize,
    ) -> Result<(), ::micropb::DecodeError<IMPL_MICROPB_READ::Error>> {
        use ::micropb::{FieldDecode, PbBytes, PbMap, PbString, PbVec};
        let before = decoder.bytes_read();
        while decoder.bytes_read() - before < len {
            let tag = decoder.decode_tag()?;
            match tag.field_num() {
                0 => return Err(::micropb::DecodeError::ZeroField),
                1u32 => {
                    let mut_ref = &mut self.r#resp;
                    {
                        let val = decoder.decode_int32()?;
                        let val_ref = &val;
                        if *val_ref != 0 {
                            *mut_ref = val as _;
                        }
                    };
                }
                2u32 => {
                    let mut_ref = &mut self.r#type;
                    {
                        let val = decoder.decode_int32()?;
                        let val_ref = &val;
                        if *val_ref != 0 {
                            *mut_ref = val as _;
                        }
                    };
                }
                _ => {
                    decoder.skip_wire_value(tag.wire_type())?;
                }
            }
        }
        Ok(())
    }
}
impl ::micropb::MessageEncode for Rpc_Resp_GetPs {
    const MAX_SIZE: ::core::option::Option<usize> = 'msg: {
        let mut max_size = 0;
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(10usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(10usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        ::core::option::Option::Some(max_size)
    };
    fn encode<IMPL_MICROPB_WRITE: ::micropb::PbWrite>(
        &self,
        encoder: &mut ::micropb::PbEncoder<IMPL_MICROPB_WRITE>,
    ) -> Result<(), IMPL_MICROPB_WRITE::Error> {
        use ::micropb::{FieldEncode, PbMap};
        {
            let val_ref = &self.r#resp;
            if *val_ref != 0 {
                encoder.encode_varint32(8u32)?;
                encoder.encode_int32(*val_ref as _)?;
            }
        }
        {
            let val_ref = &self.r#type;
            if *val_ref != 0 {
                encoder.encode_varint32(16u32)?;
                encoder.encode_int32(*val_ref as _)?;
            }
        }
        Ok(())
    }
    fn compute_size(&self) -> usize {
        use ::micropb::{FieldEncode, PbMap};
        let mut size = 0;
        {
            let val_ref = &self.r#resp;
            if *val_ref != 0 {
                size += 1usize + ::micropb::size::sizeof_int32(*val_ref as _);
            }
        }
        {
            let val_ref = &self.r#type;
            if *val_ref != 0 {
                size += 1usize + ::micropb::size::sizeof_int32(*val_ref as _);
            }
        }
        size
    }
}
#[derive(Debug, Default, PartialEq, Clone)]
pub struct Rpc_Req_SetPs {
    pub r#type: i32,
}
impl Rpc_Req_SetPs {
    ///Return a reference to `type`
    #[inline]
    pub fn r#type(&self) -> &i32 {
        &self.r#type
    }
    ///Return a mutable reference to `type`
    #[inline]
    pub fn mut_type(&mut self) -> &mut i32 {
        &mut self.r#type
    }
    ///Set the value of `type`
    #[inline]
    pub fn set_type(&mut self, value: i32) -> &mut Self {
        self.r#type = value.into();
        self
    }
    ///Builder method that sets the value of `type`. Useful for initializing the message.
    #[inline]
    pub fn init_type(mut self, value: i32) -> Self {
        self.r#type = value.into();
        self
    }
}
impl ::micropb::MessageDecode for Rpc_Req_SetPs {
    fn decode<IMPL_MICROPB_READ: ::micropb::PbRead>(
        &mut self,
        decoder: &mut ::micropb::PbDecoder<IMPL_MICROPB_READ>,
        len: usize,
    ) -> Result<(), ::micropb::DecodeError<IMPL_MICROPB_READ::Error>> {
        use ::micropb::{FieldDecode, PbBytes, PbMap, PbString, PbVec};
        let before = decoder.bytes_read();
        while decoder.bytes_read() - before < len {
            let tag = decoder.decode_tag()?;
            match tag.field_num() {
                0 => return Err(::micropb::DecodeError::ZeroField),
                1u32 => {
                    let mut_ref = &mut self.r#type;
                    {
                        let val = decoder.decode_int32()?;
                        let val_ref = &val;
                        if *val_ref != 0 {
                            *mut_ref = val as _;
                        }
                    };
                }
                _ => {
                    decoder.skip_wire_value(tag.wire_type())?;
                }
            }
        }
        Ok(())
    }
}
impl ::micropb::MessageEncode for Rpc_Req_SetPs {
    const MAX_SIZE: ::core::option::Option<usize> = 'msg: {
        let mut max_size = 0;
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(10usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        ::core::option::Option::Some(max_size)
    };
    fn encode<IMPL_MICROPB_WRITE: ::micropb::PbWrite>(
        &self,
        encoder: &mut ::micropb::PbEncoder<IMPL_MICROPB_WRITE>,
    ) -> Result<(), IMPL_MICROPB_WRITE::Error> {
        use ::micropb::{FieldEncode, PbMap};
        {
            let val_ref = &self.r#type;
            if *val_ref != 0 {
                encoder.encode_varint32(8u32)?;
                encoder.encode_int32(*val_ref as _)?;
            }
        }
        Ok(())
    }
    fn compute_size(&self) -> usize {
        use ::micropb::{FieldEncode, PbMap};
        let mut size = 0;
        {
            let val_ref = &self.r#type;
            if *val_ref != 0 {
                size += 1usize + ::micropb::size::sizeof_int32(*val_ref as _);
            }
        }
        size
    }
}
#[derive(Debug, Default, PartialEq, Clone)]
pub struct Rpc_Resp_SetPs {
    pub r#resp: i32,
}
impl Rpc_Resp_SetPs {
    ///Return a reference to `resp`
    #[inline]
    pub fn r#resp(&self) -> &i32 {
        &self.r#resp
    }
    ///Return a mutable reference to `resp`
    #[inline]
    pub fn mut_resp(&mut self) -> &mut i32 {
        &mut self.r#resp
    }
    ///Set the value of `resp`
    #[inline]
    pub fn set_resp(&mut self, value: i32) -> &mut Self {
        self.r#resp = value.into();
        self
    }
    ///Builder method that sets the value of `resp`. Useful for initializing the message.
    #[inline]
    pub fn init_resp(mut self, value: i32) -> Self {
        self.r#resp = value.into();
        self
    }
}
impl ::micropb::MessageDecode for Rpc_Resp_SetPs {
    fn decode<IMPL_MICROPB_READ: ::micropb::PbRead>(
        &mut self,
        decoder: &mut ::micropb::PbDecoder<IMPL_MICROPB_READ>,
        len: usize,
    ) -> Result<(), ::micropb::DecodeError<IMPL_MICROPB_READ::Error>> {
        use ::micropb::{FieldDecode, PbBytes, PbMap, PbString, PbVec};
        let before = decoder.bytes_read();
        while decoder.bytes_read() - before < len {
            let tag = decoder.decode_tag()?;
            match tag.field_num() {
                0 => return Err(::micropb::DecodeError::ZeroField),
                1u32 => {
                    let mut_ref = &mut self.r#resp;
                    {
                        let val = decoder.decode_int32()?;
                        let val_ref = &val;
                        if *val_ref != 0 {
                            *mut_ref = val as _;
                        }
                    };
                }
                _ => {
                    decoder.skip_wire_value(tag.wire_type())?;
                }
            }
        }
        Ok(())
    }
}
impl ::micropb::MessageEncode for Rpc_Resp_SetPs {
    const MAX_SIZE: ::core::option::Option<usize> = 'msg: {
        let mut max_size = 0;
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(10usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        ::core::option::Option::Some(max_size)
    };
    fn encode<IMPL_MICROPB_WRITE: ::micropb::PbWrite>(
        &self,
        encoder: &mut ::micropb::PbEncoder<IMPL_MICROPB_WRITE>,
    ) -> Result<(), IMPL_MICROPB_WRITE::Error> {
        use ::micropb::{FieldEncode, PbMap};
        {
            let val_ref = &self.r#resp;
            if *val_ref != 0 {
                encoder.encode_varint32(8u32)?;
                encoder.encode_int32(*val_ref as _)?;
            }
        }
        Ok(())
    }
    fn compute_size(&self) -> usize {
        use ::micropb::{FieldEncode, PbMap};
        let mut size = 0;
        {
            let val_ref = &self.r#resp;
            if *val_ref != 0 {
                size += 1usize + ::micropb::size::sizeof_int32(*val_ref as _);
            }
        }
        size
    }
}
#[derive(Debug, Default, PartialEq, Clone)]
pub struct Rpc_Req_SetMacAddress {
    pub r#mac: ::micropb::heapless::Vec<u8, 6>,
    pub r#mode: i32,
}
impl Rpc_Req_SetMacAddress {
    ///Return a reference to `mac`
    #[inline]
    pub fn r#mac(&self) -> &::micropb::heapless::Vec<u8, 6> {
        &self.r#mac
    }
    ///Return a mutable reference to `mac`
    #[inline]
    pub fn mut_mac(&mut self) -> &mut ::micropb::heapless::Vec<u8, 6> {
        &mut self.r#mac
    }
    ///Set the value of `mac`
    #[inline]
    pub fn set_mac(&mut self, value: ::micropb::heapless::Vec<u8, 6>) -> &mut Self {
        self.r#mac = value.into();
        self
    }
    ///Builder method that sets the value of `mac`. Useful for initializing the message.
    #[inline]
    pub fn init_mac(mut self, value: ::micropb::heapless::Vec<u8, 6>) -> Self {
        self.r#mac = value.into();
        self
    }
    ///Return a reference to `mode`
    #[inline]
    pub fn r#mode(&self) -> &i32 {
        &self.r#mode
    }
    ///Return a mutable reference to `mode`
    #[inline]
    pub fn mut_mode(&mut self) -> &mut i32 {
        &mut self.r#mode
    }
    ///Set the value of `mode`
    #[inline]
    pub fn set_mode(&mut self, value: i32) -> &mut Self {
        self.r#mode = value.into();
        self
    }
    ///Builder method that sets the value of `mode`. Useful for initializing the message.
    #[inline]
    pub fn init_mode(mut self, value: i32) -> Self {
        self.r#mode = value.into();
        self
    }
}
impl ::micropb::MessageDecode for Rpc_Req_SetMacAddress {
    fn decode<IMPL_MICROPB_READ: ::micropb::PbRead>(
        &mut self,
        decoder: &mut ::micropb::PbDecoder<IMPL_MICROPB_READ>,
        len: usize,
    ) -> Result<(), ::micropb::DecodeError<IMPL_MICROPB_READ::Error>> {
        use ::micropb::{FieldDecode, PbBytes, PbMap, PbString, PbVec};
        let before = decoder.bytes_read();
        while decoder.bytes_read() - before < len {
            let tag = decoder.decode_tag()?;
            match tag.field_num() {
                0 => return Err(::micropb::DecodeError::ZeroField),
                1u32 => {
                    let mut_ref = &mut self.r#mac;
                    {
                        decoder.decode_bytes(mut_ref, ::micropb::Presence::Implicit)?;
                    };
                }
                2u32 => {
                    let mut_ref = &mut self.r#mode;
                    {
                        let val = decoder.decode_int32()?;
                        let val_ref = &val;
                        if *val_ref != 0 {
                            *mut_ref = val as _;
                        }
                    };
                }
                _ => {
                    decoder.skip_wire_value(tag.wire_type())?;
                }
            }
        }
        Ok(())
    }
}
impl ::micropb::MessageEncode for Rpc_Req_SetMacAddress {
    const MAX_SIZE: ::core::option::Option<usize> = 'msg: {
        let mut max_size = 0;
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(7usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(10usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        ::core::option::Option::Some(max_size)
    };
    fn encode<IMPL_MICROPB_WRITE: ::micropb::PbWrite>(
        &self,
        encoder: &mut ::micropb::PbEncoder<IMPL_MICROPB_WRITE>,
    ) -> Result<(), IMPL_MICROPB_WRITE::Error> {
        use ::micropb::{FieldEncode, PbMap};
        {
            let val_ref = &self.r#mac;
            if !val_ref.is_empty() {
                encoder.encode_varint32(10u32)?;
                encoder.encode_bytes(val_ref)?;
            }
        }
        {
            let val_ref = &self.r#mode;
            if *val_ref != 0 {
                encoder.encode_varint32(16u32)?;
                encoder.encode_int32(*val_ref as _)?;
            }
        }
        Ok(())
    }
    fn compute_size(&self) -> usize {
        use ::micropb::{FieldEncode, PbMap};
        let mut size = 0;
        {
            let val_ref = &self.r#mac;
            if !val_ref.is_empty() {
                size += 1usize + ::micropb::size::sizeof_len_record(val_ref.len());
            }
        }
        {
            let val_ref = &self.r#mode;
            if *val_ref != 0 {
                size += 1usize + ::micropb::size::sizeof_int32(*val_ref as _);
            }
        }
        size
    }
}
#[derive(Debug, Default, PartialEq, Clone)]
pub struct Rpc_Resp_SetMacAddress {
    pub r#resp: i32,
}
impl Rpc_Resp_SetMacAddress {
    ///Return a reference to `resp`
    #[inline]
    pub fn r#resp(&self) -> &i32 {
        &self.r#resp
    }
    ///Return a mutable reference to `resp`
    #[inline]
    pub fn mut_resp(&mut self) -> &mut i32 {
        &mut self.r#resp
    }
    ///Set the value of `resp`
    #[inline]
    pub fn set_resp(&mut self, value: i32) -> &mut Self {
        self.r#resp = value.into();
        self
    }
    ///Builder method that sets the value of `resp`. Useful for initializing the message.
    #[inline]
    pub fn init_resp(mut self, value: i32) -> Self {
        self.r#resp = value.into();
        self
    }
}
impl ::micropb::MessageDecode for Rpc_Resp_SetMacAddress {
    fn decode<IMPL_MICROPB_READ: ::micropb::PbRead>(
        &mut self,
        decoder: &mut ::micropb::PbDecoder<IMPL_MICROPB_READ>,
        len: usize,
    ) -> Result<(), ::micropb::DecodeError<IMPL_MICROPB_READ::Error>> {
        use ::micropb::{FieldDecode, PbBytes, PbMap, PbString, PbVec};
        let before = decoder.bytes_read();
        while decoder.bytes_read() - before < len {
            let tag = decoder.decode_tag()?;
            match tag.field_num() {
                0 => return Err(::micropb::DecodeError::ZeroField),
                1u32 => {
                    let mut_ref = &mut self.r#resp;
                    {
                        let val = decoder.decode_int32()?;
                        let val_ref = &val;
                        if *val_ref != 0 {
                            *mut_ref = val as _;
                        }
                    };
                }
                _ => {
                    decoder.skip_wire_value(tag.wire_type())?;
                }
            }
        }
        Ok(())
    }
}
impl ::micropb::MessageEncode for Rpc_Resp_SetMacAddress {
    const MAX_SIZE: ::core::option::Option<usize> = 'msg: {
        let mut max_size = 0;
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(10usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        ::core::option::Option::Some(max_size)
    };
    fn encode<IMPL_MICROPB_WRITE: ::micropb::PbWrite>(
        &self,
        encoder: &mut ::micropb::PbEncoder<IMPL_MICROPB_WRITE>,
    ) -> Result<(), IMPL_MICROPB_WRITE::Error> {
        use ::micropb::{FieldEncode, PbMap};
        {
            let val_ref = &self.r#resp;
            if *val_ref != 0 {
                encoder.encode_varint32(8u32)?;
                encoder.encode_int32(*val_ref as _)?;
            }
        }
        Ok(())
    }
    fn compute_size(&self) -> usize {
        use ::micropb::{FieldEncode, PbMap};
        let mut size = 0;
        {
            let val_ref = &self.r#resp;
            if *val_ref != 0 {
                size += 1usize + ::micropb::size::sizeof_int32(*val_ref as _);
            }
        }
        size
    }
}
#[derive(Debug, Default, PartialEq, Clone)]
pub struct Rpc_Req_OTABegin {}
impl Rpc_Req_OTABegin {}
impl ::micropb::MessageDecode for Rpc_Req_OTABegin {
    fn decode<IMPL_MICROPB_READ: ::micropb::PbRead>(
        &mut self,
        decoder: &mut ::micropb::PbDecoder<IMPL_MICROPB_READ>,
        len: usize,
    ) -> Result<(), ::micropb::DecodeError<IMPL_MICROPB_READ::Error>> {
        use ::micropb::{FieldDecode, PbBytes, PbMap, PbString, PbVec};
        let before = decoder.bytes_read();
        while decoder.bytes_read() - before < len {
            let tag = decoder.decode_tag()?;
            match tag.field_num() {
                0 => return Err(::micropb::DecodeError::ZeroField),
                _ => {
                    decoder.skip_wire_value(tag.wire_type())?;
                }
            }
        }
        Ok(())
    }
}
impl ::micropb::MessageEncode for Rpc_Req_OTABegin {
    const MAX_SIZE: ::core::option::Option<usize> = 'msg: {
        let mut max_size = 0;
        ::core::option::Option::Some(max_size)
    };
    fn encode<IMPL_MICROPB_WRITE: ::micropb::PbWrite>(
        &self,
        encoder: &mut ::micropb::PbEncoder<IMPL_MICROPB_WRITE>,
    ) -> Result<(), IMPL_MICROPB_WRITE::Error> {
        use ::micropb::{FieldEncode, PbMap};
        Ok(())
    }
    fn compute_size(&self) -> usize {
        use ::micropb::{FieldEncode, PbMap};
        let mut size = 0;
        size
    }
}
#[derive(Debug, Default, PartialEq, Clone)]
pub struct Rpc_Resp_OTABegin {
    pub r#resp: i32,
}
impl Rpc_Resp_OTABegin {
    ///Return a reference to `resp`
    #[inline]
    pub fn r#resp(&self) -> &i32 {
        &self.r#resp
    }
    ///Return a mutable reference to `resp`
    #[inline]
    pub fn mut_resp(&mut self) -> &mut i32 {
        &mut self.r#resp
    }
    ///Set the value of `resp`
    #[inline]
    pub fn set_resp(&mut self, value: i32) -> &mut Self {
        self.r#resp = value.into();
        self
    }
    ///Builder method that sets the value of `resp`. Useful for initializing the message.
    #[inline]
    pub fn init_resp(mut self, value: i32) -> Self {
        self.r#resp = value.into();
        self
    }
}
impl ::micropb::MessageDecode for Rpc_Resp_OTABegin {
    fn decode<IMPL_MICROPB_READ: ::micropb::PbRead>(
        &mut self,
        decoder: &mut ::micropb::PbDecoder<IMPL_MICROPB_READ>,
        len: usize,
    ) -> Result<(), ::micropb::DecodeError<IMPL_MICROPB_READ::Error>> {
        use ::micropb::{FieldDecode, PbBytes, PbMap, PbString, PbVec};
        let before = decoder.bytes_read();
        while decoder.bytes_read() - before < len {
            let tag = decoder.decode_tag()?;
            match tag.field_num() {
                0 => return Err(::micropb::DecodeError::ZeroField),
                1u32 => {
                    let mut_ref = &mut self.r#resp;
                    {
                        let val = decoder.decode_int32()?;
                        let val_ref = &val;
                        if *val_ref != 0 {
                            *mut_ref = val as _;
                        }
                    };
                }
                _ => {
                    decoder.skip_wire_value(tag.wire_type())?;
                }
            }
        }
        Ok(())
    }
}
impl ::micropb::MessageEncode for Rpc_Resp_OTABegin {
    const MAX_SIZE: ::core::option::Option<usize> = 'msg: {
        let mut max_size = 0;
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(10usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        ::core::option::Option::Some(max_size)
    };
    fn encode<IMPL_MICROPB_WRITE: ::micropb::PbWrite>(
        &self,
        encoder: &mut ::micropb::PbEncoder<IMPL_MICROPB_WRITE>,
    ) -> Result<(), IMPL_MICROPB_WRITE::Error> {
        use ::micropb::{FieldEncode, PbMap};
        {
            let val_ref = &self.r#resp;
            if *val_ref != 0 {
                encoder.encode_varint32(8u32)?;
                encoder.encode_int32(*val_ref as _)?;
            }
        }
        Ok(())
    }
    fn compute_size(&self) -> usize {
        use ::micropb::{FieldEncode, PbMap};
        let mut size = 0;
        {
            let val_ref = &self.r#resp;
            if *val_ref != 0 {
                size += 1usize + ::micropb::size::sizeof_int32(*val_ref as _);
            }
        }
        size
    }
}
#[derive(Debug, Default, PartialEq, Clone)]
pub struct Rpc_Req_OTAWrite {
    pub r#ota_data: ::micropb::heapless::Vec<u8, 500>,
}
impl Rpc_Req_OTAWrite {
    ///Return a reference to `ota_data`
    #[inline]
    pub fn r#ota_data(&self) -> &::micropb::heapless::Vec<u8, 500> {
        &self.r#ota_data
    }
    ///Return a mutable reference to `ota_data`
    #[inline]
    pub fn mut_ota_data(&mut self) -> &mut ::micropb::heapless::Vec<u8, 500> {
        &mut self.r#ota_data
    }
    ///Set the value of `ota_data`
    #[inline]
    pub fn set_ota_data(&mut self, value: ::micropb::heapless::Vec<u8, 500>) -> &mut Self {
        self.r#ota_data = value.into();
        self
    }
    ///Builder method that sets the value of `ota_data`. Useful for initializing the message.
    #[inline]
    pub fn init_ota_data(mut self, value: ::micropb::heapless::Vec<u8, 500>) -> Self {
        self.r#ota_data = value.into();
        self
    }
}
impl ::micropb::MessageDecode for Rpc_Req_OTAWrite {
    fn decode<IMPL_MICROPB_READ: ::micropb::PbRead>(
        &mut self,
        decoder: &mut ::micropb::PbDecoder<IMPL_MICROPB_READ>,
        len: usize,
    ) -> Result<(), ::micropb::DecodeError<IMPL_MICROPB_READ::Error>> {
        use ::micropb::{FieldDecode, PbBytes, PbMap, PbString, PbVec};
        let before = decoder.bytes_read();
        while decoder.bytes_read() - before < len {
            let tag = decoder.decode_tag()?;
            match tag.field_num() {
                0 => return Err(::micropb::DecodeError::ZeroField),
                1u32 => {
                    let mut_ref = &mut self.r#ota_data;
                    {
                        decoder.decode_bytes(mut_ref, ::micropb::Presence::Implicit)?;
                    };
                }
                _ => {
                    decoder.skip_wire_value(tag.wire_type())?;
                }
            }
        }
        Ok(())
    }
}
impl ::micropb::MessageEncode for Rpc_Req_OTAWrite {
    const MAX_SIZE: ::core::option::Option<usize> = 'msg: {
        let mut max_size = 0;
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(502usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        ::core::option::Option::Some(max_size)
    };
    fn encode<IMPL_MICROPB_WRITE: ::micropb::PbWrite>(
        &self,
        encoder: &mut ::micropb::PbEncoder<IMPL_MICROPB_WRITE>,
    ) -> Result<(), IMPL_MICROPB_WRITE::Error> {
        use ::micropb::{FieldEncode, PbMap};
        {
            let val_ref = &self.r#ota_data;
            if !val_ref.is_empty() {
                encoder.encode_varint32(10u32)?;
                encoder.encode_bytes(val_ref)?;
            }
        }
        Ok(())
    }
    fn compute_size(&self) -> usize {
        use ::micropb::{FieldEncode, PbMap};
        let mut size = 0;
        {
            let val_ref = &self.r#ota_data;
            if !val_ref.is_empty() {
                size += 1usize + ::micropb::size::sizeof_len_record(val_ref.len());
            }
        }
        size
    }
}
#[derive(Debug, Default, PartialEq, Clone)]
pub struct Rpc_Resp_OTAWrite {
    pub r#resp: i32,
}
impl Rpc_Resp_OTAWrite {
    ///Return a reference to `resp`
    #[inline]
    pub fn r#resp(&self) -> &i32 {
        &self.r#resp
    }
    ///Return a mutable reference to `resp`
    #[inline]
    pub fn mut_resp(&mut self) -> &mut i32 {
        &mut self.r#resp
    }
    ///Set the value of `resp`
    #[inline]
    pub fn set_resp(&mut self, value: i32) -> &mut Self {
        self.r#resp = value.into();
        self
    }
    ///Builder method that sets the value of `resp`. Useful for initializing the message.
    #[inline]
    pub fn init_resp(mut self, value: i32) -> Self {
        self.r#resp = value.into();
        self
    }
}
impl ::micropb::MessageDecode for Rpc_Resp_OTAWrite {
    fn decode<IMPL_MICROPB_READ: ::micropb::PbRead>(
        &mut self,
        decoder: &mut ::micropb::PbDecoder<IMPL_MICROPB_READ>,
        len: usize,
    ) -> Result<(), ::micropb::DecodeError<IMPL_MICROPB_READ::Error>> {
        use ::micropb::{FieldDecode, PbBytes, PbMap, PbString, PbVec};
        let before = decoder.bytes_read();
        while decoder.bytes_read() - before < len {
            let tag = decoder.decode_tag()?;
            match tag.field_num() {
                0 => return Err(::micropb::DecodeError::ZeroField),
                1u32 => {
                    let mut_ref = &mut self.r#resp;
                    {
                        let val = decoder.decode_int32()?;
                        let val_ref = &val;
                        if *val_ref != 0 {
                            *mut_ref = val as _;
                        }
                    };
                }
                _ => {
                    decoder.skip_wire_value(tag.wire_type())?;
                }
            }
        }
        Ok(())
    }
}
impl ::micropb::MessageEncode for Rpc_Resp_OTAWrite {
    const MAX_SIZE: ::core::option::Option<usize> = 'msg: {
        let mut max_size = 0;
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(10usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        ::core::option::Option::Some(max_size)
    };
    fn encode<IMPL_MICROPB_WRITE: ::micropb::PbWrite>(
        &self,
        encoder: &mut ::micropb::PbEncoder<IMPL_MICROPB_WRITE>,
    ) -> Result<(), IMPL_MICROPB_WRITE::Error> {
        use ::micropb::{FieldEncode, PbMap};
        {
            let val_ref = &self.r#resp;
            if *val_ref != 0 {
                encoder.encode_varint32(8u32)?;
                encoder.encode_int32(*val_ref as _)?;
            }
        }
        Ok(())
    }
    fn compute_size(&self) -> usize {
        use ::micropb::{FieldEncode, PbMap};
        let mut size = 0;
        {
            let val_ref = &self.r#resp;
            if *val_ref != 0 {
                size += 1usize + ::micropb::size::sizeof_int32(*val_ref as _);
            }
        }
        size
    }
}
#[derive(Debug, Default, PartialEq, Clone)]
pub struct Rpc_Req_OTAEnd {}
impl Rpc_Req_OTAEnd {}
impl ::micropb::MessageDecode for Rpc_Req_OTAEnd {
    fn decode<IMPL_MICROPB_READ: ::micropb::PbRead>(
        &mut self,
        decoder: &mut ::micropb::PbDecoder<IMPL_MICROPB_READ>,
        len: usize,
    ) -> Result<(), ::micropb::DecodeError<IMPL_MICROPB_READ::Error>> {
        use ::micropb::{FieldDecode, PbBytes, PbMap, PbString, PbVec};
        let before = decoder.bytes_read();
        while decoder.bytes_read() - before < len {
            let tag = decoder.decode_tag()?;
            match tag.field_num() {
                0 => return Err(::micropb::DecodeError::ZeroField),
                _ => {
                    decoder.skip_wire_value(tag.wire_type())?;
                }
            }
        }
        Ok(())
    }
}
impl ::micropb::MessageEncode for Rpc_Req_OTAEnd {
    const MAX_SIZE: ::core::option::Option<usize> = 'msg: {
        let mut max_size = 0;
        ::core::option::Option::Some(max_size)
    };
    fn encode<IMPL_MICROPB_WRITE: ::micropb::PbWrite>(
        &self,
        encoder: &mut ::micropb::PbEncoder<IMPL_MICROPB_WRITE>,
    ) -> Result<(), IMPL_MICROPB_WRITE::Error> {
        use ::micropb::{FieldEncode, PbMap};
        Ok(())
    }
    fn compute_size(&self) -> usize {
        use ::micropb::{FieldEncode, PbMap};
        let mut size = 0;
        size
    }
}
#[derive(Debug, Default, PartialEq, Clone)]
pub struct Rpc_Resp_OTAEnd {
    pub r#resp: i32,
}
impl Rpc_Resp_OTAEnd {
    ///Return a reference to `resp`
    #[inline]
    pub fn r#resp(&self) -> &i32 {
        &self.r#resp
    }
    ///Return a mutable reference to `resp`
    #[inline]
    pub fn mut_resp(&mut self) -> &mut i32 {
        &mut self.r#resp
    }
    ///Set the value of `resp`
    #[inline]
    pub fn set_resp(&mut self, value: i32) -> &mut Self {
        self.r#resp = value.into();
        self
    }
    ///Builder method that sets the value of `resp`. Useful for initializing the message.
    #[inline]
    pub fn init_resp(mut self, value: i32) -> Self {
        self.r#resp = value.into();
        self
    }
}
impl ::micropb::MessageDecode for Rpc_Resp_OTAEnd {
    fn decode<IMPL_MICROPB_READ: ::micropb::PbRead>(
        &mut self,
        decoder: &mut ::micropb::PbDecoder<IMPL_MICROPB_READ>,
        len: usize,
    ) -> Result<(), ::micropb::DecodeError<IMPL_MICROPB_READ::Error>> {
        use ::micropb::{FieldDecode, PbBytes, PbMap, PbString, PbVec};
        let before = decoder.bytes_read();
        while decoder.bytes_read() - before < len {
            let tag = decoder.decode_tag()?;
            match tag.field_num() {
                0 => return Err(::micropb::DecodeError::ZeroField),
                1u32 => {
                    let mut_ref = &mut self.r#resp;
                    {
                        let val = decoder.decode_int32()?;
                        let val_ref = &val;
                        if *val_ref != 0 {
                            *mut_ref = val as _;
                        }
                    };
                }
                _ => {
                    decoder.skip_wire_value(tag.wire_type())?;
                }
            }
        }
        Ok(())
    }
}
impl ::micropb::MessageEncode for Rpc_Resp_OTAEnd {
    const MAX_SIZE: ::core::option::Option<usize> = 'msg: {
        let mut max_size = 0;
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(10usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        ::core::option::Option::Some(max_size)
    };
    fn encode<IMPL_MICROPB_WRITE: ::micropb::PbWrite>(
        &self,
        encoder: &mut ::micropb::PbEncoder<IMPL_MICROPB_WRITE>,
    ) -> Result<(), IMPL_MICROPB_WRITE::Error> {
        use ::micropb::{FieldEncode, PbMap};
        {
            let val_ref = &self.r#resp;
            if *val_ref != 0 {
                encoder.encode_varint32(8u32)?;
                encoder.encode_int32(*val_ref as _)?;
            }
        }
        Ok(())
    }
    fn compute_size(&self) -> usize {
        use ::micropb::{FieldEncode, PbMap};
        let mut size = 0;
        {
            let val_ref = &self.r#resp;
            if *val_ref != 0 {
                size += 1usize + ::micropb::size::sizeof_int32(*val_ref as _);
            }
        }
        size
    }
}
#[derive(Debug, Default, PartialEq, Clone)]
pub struct Rpc_Req_WifiSetMaxTxPower {
    pub r#power: i32,
}
impl Rpc_Req_WifiSetMaxTxPower {
    ///Return a reference to `power`
    #[inline]
    pub fn r#power(&self) -> &i32 {
        &self.r#power
    }
    ///Return a mutable reference to `power`
    #[inline]
    pub fn mut_power(&mut self) -> &mut i32 {
        &mut self.r#power
    }
    ///Set the value of `power`
    #[inline]
    pub fn set_power(&mut self, value: i32) -> &mut Self {
        self.r#power = value.into();
        self
    }
    ///Builder method that sets the value of `power`. Useful for initializing the message.
    #[inline]
    pub fn init_power(mut self, value: i32) -> Self {
        self.r#power = value.into();
        self
    }
}
impl ::micropb::MessageDecode for Rpc_Req_WifiSetMaxTxPower {
    fn decode<IMPL_MICROPB_READ: ::micropb::PbRead>(
        &mut self,
        decoder: &mut ::micropb::PbDecoder<IMPL_MICROPB_READ>,
        len: usize,
    ) -> Result<(), ::micropb::DecodeError<IMPL_MICROPB_READ::Error>> {
        use ::micropb::{FieldDecode, PbBytes, PbMap, PbString, PbVec};
        let before = decoder.bytes_read();
        while decoder.bytes_read() - before < len {
            let tag = decoder.decode_tag()?;
            match tag.field_num() {
                0 => return Err(::micropb::DecodeError::ZeroField),
                1u32 => {
                    let mut_ref = &mut self.r#power;
                    {
                        let val = decoder.decode_int32()?;
                        let val_ref = &val;
                        if *val_ref != 0 {
                            *mut_ref = val as _;
                        }
                    };
                }
                _ => {
                    decoder.skip_wire_value(tag.wire_type())?;
                }
            }
        }
        Ok(())
    }
}
impl ::micropb::MessageEncode for Rpc_Req_WifiSetMaxTxPower {
    const MAX_SIZE: ::core::option::Option<usize> = 'msg: {
        let mut max_size = 0;
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(10usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        ::core::option::Option::Some(max_size)
    };
    fn encode<IMPL_MICROPB_WRITE: ::micropb::PbWrite>(
        &self,
        encoder: &mut ::micropb::PbEncoder<IMPL_MICROPB_WRITE>,
    ) -> Result<(), IMPL_MICROPB_WRITE::Error> {
        use ::micropb::{FieldEncode, PbMap};
        {
            let val_ref = &self.r#power;
            if *val_ref != 0 {
                encoder.encode_varint32(8u32)?;
                encoder.encode_int32(*val_ref as _)?;
            }
        }
        Ok(())
    }
    fn compute_size(&self) -> usize {
        use ::micropb::{FieldEncode, PbMap};
        let mut size = 0;
        {
            let val_ref = &self.r#power;
            if *val_ref != 0 {
                size += 1usize + ::micropb::size::sizeof_int32(*val_ref as _);
            }
        }
        size
    }
}
#[derive(Debug, Default, PartialEq, Clone)]
pub struct Rpc_Resp_WifiSetMaxTxPower {
    pub r#resp: i32,
}
impl Rpc_Resp_WifiSetMaxTxPower {
    ///Return a reference to `resp`
    #[inline]
    pub fn r#resp(&self) -> &i32 {
        &self.r#resp
    }
    ///Return a mutable reference to `resp`
    #[inline]
    pub fn mut_resp(&mut self) -> &mut i32 {
        &mut self.r#resp
    }
    ///Set the value of `resp`
    #[inline]
    pub fn set_resp(&mut self, value: i32) -> &mut Self {
        self.r#resp = value.into();
        self
    }
    ///Builder method that sets the value of `resp`. Useful for initializing the message.
    #[inline]
    pub fn init_resp(mut self, value: i32) -> Self {
        self.r#resp = value.into();
        self
    }
}
impl ::micropb::MessageDecode for Rpc_Resp_WifiSetMaxTxPower {
    fn decode<IMPL_MICROPB_READ: ::micropb::PbRead>(
        &mut self,
        decoder: &mut ::micropb::PbDecoder<IMPL_MICROPB_READ>,
        len: usize,
    ) -> Result<(), ::micropb::DecodeError<IMPL_MICROPB_READ::Error>> {
        use ::micropb::{FieldDecode, PbBytes, PbMap, PbString, PbVec};
        let before = decoder.bytes_read();
        while decoder.bytes_read() - before < len {
            let tag = decoder.decode_tag()?;
            match tag.field_num() {
                0 => return Err(::micropb::DecodeError::ZeroField),
                1u32 => {
                    let mut_ref = &mut self.r#resp;
                    {
                        let val = decoder.decode_int32()?;
                        let val_ref = &val;
                        if *val_ref != 0 {
                            *mut_ref = val as _;
                        }
                    };
                }
                _ => {
                    decoder.skip_wire_value(tag.wire_type())?;
                }
            }
        }
        Ok(())
    }
}
impl ::micropb::MessageEncode for Rpc_Resp_WifiSetMaxTxPower {
    const MAX_SIZE: ::core::option::Option<usize> = 'msg: {
        let mut max_size = 0;
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(10usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        ::core::option::Option::Some(max_size)
    };
    fn encode<IMPL_MICROPB_WRITE: ::micropb::PbWrite>(
        &self,
        encoder: &mut ::micropb::PbEncoder<IMPL_MICROPB_WRITE>,
    ) -> Result<(), IMPL_MICROPB_WRITE::Error> {
        use ::micropb::{FieldEncode, PbMap};
        {
            let val_ref = &self.r#resp;
            if *val_ref != 0 {
                encoder.encode_varint32(8u32)?;
                encoder.encode_int32(*val_ref as _)?;
            }
        }
        Ok(())
    }
    fn compute_size(&self) -> usize {
        use ::micropb::{FieldEncode, PbMap};
        let mut size = 0;
        {
            let val_ref = &self.r#resp;
            if *val_ref != 0 {
                size += 1usize + ::micropb::size::sizeof_int32(*val_ref as _);
            }
        }
        size
    }
}
#[derive(Debug, Default, PartialEq, Clone)]
pub struct Rpc_Req_WifiGetMaxTxPower {}
impl Rpc_Req_WifiGetMaxTxPower {}
impl ::micropb::MessageDecode for Rpc_Req_WifiGetMaxTxPower {
    fn decode<IMPL_MICROPB_READ: ::micropb::PbRead>(
        &mut self,
        decoder: &mut ::micropb::PbDecoder<IMPL_MICROPB_READ>,
        len: usize,
    ) -> Result<(), ::micropb::DecodeError<IMPL_MICROPB_READ::Error>> {
        use ::micropb::{FieldDecode, PbBytes, PbMap, PbString, PbVec};
        let before = decoder.bytes_read();
        while decoder.bytes_read() - before < len {
            let tag = decoder.decode_tag()?;
            match tag.field_num() {
                0 => return Err(::micropb::DecodeError::ZeroField),
                _ => {
                    decoder.skip_wire_value(tag.wire_type())?;
                }
            }
        }
        Ok(())
    }
}
impl ::micropb::MessageEncode for Rpc_Req_WifiGetMaxTxPower {
    const MAX_SIZE: ::core::option::Option<usize> = 'msg: {
        let mut max_size = 0;
        ::core::option::Option::Some(max_size)
    };
    fn encode<IMPL_MICROPB_WRITE: ::micropb::PbWrite>(
        &self,
        encoder: &mut ::micropb::PbEncoder<IMPL_MICROPB_WRITE>,
    ) -> Result<(), IMPL_MICROPB_WRITE::Error> {
        use ::micropb::{FieldEncode, PbMap};
        Ok(())
    }
    fn compute_size(&self) -> usize {
        use ::micropb::{FieldEncode, PbMap};
        let mut size = 0;
        size
    }
}
#[derive(Debug, Default, PartialEq, Clone)]
pub struct Rpc_Resp_WifiGetMaxTxPower {
    pub r#power: i32,
    pub r#resp: i32,
}
impl Rpc_Resp_WifiGetMaxTxPower {
    ///Return a reference to `power`
    #[inline]
    pub fn r#power(&self) -> &i32 {
        &self.r#power
    }
    ///Return a mutable reference to `power`
    #[inline]
    pub fn mut_power(&mut self) -> &mut i32 {
        &mut self.r#power
    }
    ///Set the value of `power`
    #[inline]
    pub fn set_power(&mut self, value: i32) -> &mut Self {
        self.r#power = value.into();
        self
    }
    ///Builder method that sets the value of `power`. Useful for initializing the message.
    #[inline]
    pub fn init_power(mut self, value: i32) -> Self {
        self.r#power = value.into();
        self
    }
    ///Return a reference to `resp`
    #[inline]
    pub fn r#resp(&self) -> &i32 {
        &self.r#resp
    }
    ///Return a mutable reference to `resp`
    #[inline]
    pub fn mut_resp(&mut self) -> &mut i32 {
        &mut self.r#resp
    }
    ///Set the value of `resp`
    #[inline]
    pub fn set_resp(&mut self, value: i32) -> &mut Self {
        self.r#resp = value.into();
        self
    }
    ///Builder method that sets the value of `resp`. Useful for initializing the message.
    #[inline]
    pub fn init_resp(mut self, value: i32) -> Self {
        self.r#resp = value.into();
        self
    }
}
impl ::micropb::MessageDecode for Rpc_Resp_WifiGetMaxTxPower {
    fn decode<IMPL_MICROPB_READ: ::micropb::PbRead>(
        &mut self,
        decoder: &mut ::micropb::PbDecoder<IMPL_MICROPB_READ>,
        len: usize,
    ) -> Result<(), ::micropb::DecodeError<IMPL_MICROPB_READ::Error>> {
        use ::micropb::{FieldDecode, PbBytes, PbMap, PbString, PbVec};
        let before = decoder.bytes_read();
        while decoder.bytes_read() - before < len {
            let tag = decoder.decode_tag()?;
            match tag.field_num() {
                0 => return Err(::micropb::DecodeError::ZeroField),
                1u32 => {
                    let mut_ref = &mut self.r#power;
                    {
                        let val = decoder.decode_int32()?;
                        let val_ref = &val;
                        if *val_ref != 0 {
                            *mut_ref = val as _;
                        }
                    };
                }
                2u32 => {
                    let mut_ref = &mut self.r#resp;
                    {
                        let val = decoder.decode_int32()?;
                        let val_ref = &val;
                        if *val_ref != 0 {
                            *mut_ref = val as _;
                        }
                    };
                }
                _ => {
                    decoder.skip_wire_value(tag.wire_type())?;
                }
            }
        }
        Ok(())
    }
}
impl ::micropb::MessageEncode for Rpc_Resp_WifiGetMaxTxPower {
    const MAX_SIZE: ::core::option::Option<usize> = 'msg: {
        let mut max_size = 0;
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(10usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(10usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        ::core::option::Option::Some(max_size)
    };
    fn encode<IMPL_MICROPB_WRITE: ::micropb::PbWrite>(
        &self,
        encoder: &mut ::micropb::PbEncoder<IMPL_MICROPB_WRITE>,
    ) -> Result<(), IMPL_MICROPB_WRITE::Error> {
        use ::micropb::{FieldEncode, PbMap};
        {
            let val_ref = &self.r#power;
            if *val_ref != 0 {
                encoder.encode_varint32(8u32)?;
                encoder.encode_int32(*val_ref as _)?;
            }
        }
        {
            let val_ref = &self.r#resp;
            if *val_ref != 0 {
                encoder.encode_varint32(16u32)?;
                encoder.encode_int32(*val_ref as _)?;
            }
        }
        Ok(())
    }
    fn compute_size(&self) -> usize {
        use ::micropb::{FieldEncode, PbMap};
        let mut size = 0;
        {
            let val_ref = &self.r#power;
            if *val_ref != 0 {
                size += 1usize + ::micropb::size::sizeof_int32(*val_ref as _);
            }
        }
        {
            let val_ref = &self.r#resp;
            if *val_ref != 0 {
                size += 1usize + ::micropb::size::sizeof_int32(*val_ref as _);
            }
        }
        size
    }
}
#[derive(Debug, Default, PartialEq, Clone)]
pub struct Rpc_Req_ConfigHeartbeat {
    pub r#enable: bool,
    pub r#duration: i32,
}
impl Rpc_Req_ConfigHeartbeat {
    ///Return a reference to `enable`
    #[inline]
    pub fn r#enable(&self) -> &bool {
        &self.r#enable
    }
    ///Return a mutable reference to `enable`
    #[inline]
    pub fn mut_enable(&mut self) -> &mut bool {
        &mut self.r#enable
    }
    ///Set the value of `enable`
    #[inline]
    pub fn set_enable(&mut self, value: bool) -> &mut Self {
        self.r#enable = value.into();
        self
    }
    ///Builder method that sets the value of `enable`. Useful for initializing the message.
    #[inline]
    pub fn init_enable(mut self, value: bool) -> Self {
        self.r#enable = value.into();
        self
    }
    ///Return a reference to `duration`
    #[inline]
    pub fn r#duration(&self) -> &i32 {
        &self.r#duration
    }
    ///Return a mutable reference to `duration`
    #[inline]
    pub fn mut_duration(&mut self) -> &mut i32 {
        &mut self.r#duration
    }
    ///Set the value of `duration`
    #[inline]
    pub fn set_duration(&mut self, value: i32) -> &mut Self {
        self.r#duration = value.into();
        self
    }
    ///Builder method that sets the value of `duration`. Useful for initializing the message.
    #[inline]
    pub fn init_duration(mut self, value: i32) -> Self {
        self.r#duration = value.into();
        self
    }
}
impl ::micropb::MessageDecode for Rpc_Req_ConfigHeartbeat {
    fn decode<IMPL_MICROPB_READ: ::micropb::PbRead>(
        &mut self,
        decoder: &mut ::micropb::PbDecoder<IMPL_MICROPB_READ>,
        len: usize,
    ) -> Result<(), ::micropb::DecodeError<IMPL_MICROPB_READ::Error>> {
        use ::micropb::{FieldDecode, PbBytes, PbMap, PbString, PbVec};
        let before = decoder.bytes_read();
        while decoder.bytes_read() - before < len {
            let tag = decoder.decode_tag()?;
            match tag.field_num() {
                0 => return Err(::micropb::DecodeError::ZeroField),
                1u32 => {
                    let mut_ref = &mut self.r#enable;
                    {
                        let val = decoder.decode_bool()?;
                        let val_ref = &val;
                        if *val_ref {
                            *mut_ref = val as _;
                        }
                    };
                }
                2u32 => {
                    let mut_ref = &mut self.r#duration;
                    {
                        let val = decoder.decode_int32()?;
                        let val_ref = &val;
                        if *val_ref != 0 {
                            *mut_ref = val as _;
                        }
                    };
                }
                _ => {
                    decoder.skip_wire_value(tag.wire_type())?;
                }
            }
        }
        Ok(())
    }
}
impl ::micropb::MessageEncode for Rpc_Req_ConfigHeartbeat {
    const MAX_SIZE: ::core::option::Option<usize> = 'msg: {
        let mut max_size = 0;
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(1usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(10usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        ::core::option::Option::Some(max_size)
    };
    fn encode<IMPL_MICROPB_WRITE: ::micropb::PbWrite>(
        &self,
        encoder: &mut ::micropb::PbEncoder<IMPL_MICROPB_WRITE>,
    ) -> Result<(), IMPL_MICROPB_WRITE::Error> {
        use ::micropb::{FieldEncode, PbMap};
        {
            let val_ref = &self.r#enable;
            if *val_ref {
                encoder.encode_varint32(8u32)?;
                encoder.encode_bool(*val_ref)?;
            }
        }
        {
            let val_ref = &self.r#duration;
            if *val_ref != 0 {
                encoder.encode_varint32(16u32)?;
                encoder.encode_int32(*val_ref as _)?;
            }
        }
        Ok(())
    }
    fn compute_size(&self) -> usize {
        use ::micropb::{FieldEncode, PbMap};
        let mut size = 0;
        {
            let val_ref = &self.r#enable;
            if *val_ref {
                size += 1usize + 1;
            }
        }
        {
            let val_ref = &self.r#duration;
            if *val_ref != 0 {
                size += 1usize + ::micropb::size::sizeof_int32(*val_ref as _);
            }
        }
        size
    }
}
#[derive(Debug, Default, PartialEq, Clone)]
pub struct Rpc_Resp_ConfigHeartbeat {
    pub r#resp: i32,
}
impl Rpc_Resp_ConfigHeartbeat {
    ///Return a reference to `resp`
    #[inline]
    pub fn r#resp(&self) -> &i32 {
        &self.r#resp
    }
    ///Return a mutable reference to `resp`
    #[inline]
    pub fn mut_resp(&mut self) -> &mut i32 {
        &mut self.r#resp
    }
    ///Set the value of `resp`
    #[inline]
    pub fn set_resp(&mut self, value: i32) -> &mut Self {
        self.r#resp = value.into();
        self
    }
    ///Builder method that sets the value of `resp`. Useful for initializing the message.
    #[inline]
    pub fn init_resp(mut self, value: i32) -> Self {
        self.r#resp = value.into();
        self
    }
}
impl ::micropb::MessageDecode for Rpc_Resp_ConfigHeartbeat {
    fn decode<IMPL_MICROPB_READ: ::micropb::PbRead>(
        &mut self,
        decoder: &mut ::micropb::PbDecoder<IMPL_MICROPB_READ>,
        len: usize,
    ) -> Result<(), ::micropb::DecodeError<IMPL_MICROPB_READ::Error>> {
        use ::micropb::{FieldDecode, PbBytes, PbMap, PbString, PbVec};
        let before = decoder.bytes_read();
        while decoder.bytes_read() - before < len {
            let tag = decoder.decode_tag()?;
            match tag.field_num() {
                0 => return Err(::micropb::DecodeError::ZeroField),
                1u32 => {
                    let mut_ref = &mut self.r#resp;
                    {
                        let val = decoder.decode_int32()?;
                        let val_ref = &val;
                        if *val_ref != 0 {
                            *mut_ref = val as _;
                        }
                    };
                }
                _ => {
                    decoder.skip_wire_value(tag.wire_type())?;
                }
            }
        }
        Ok(())
    }
}
impl ::micropb::MessageEncode for Rpc_Resp_ConfigHeartbeat {
    const MAX_SIZE: ::core::option::Option<usize> = 'msg: {
        let mut max_size = 0;
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(10usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        ::core::option::Option::Some(max_size)
    };
    fn encode<IMPL_MICROPB_WRITE: ::micropb::PbWrite>(
        &self,
        encoder: &mut ::micropb::PbEncoder<IMPL_MICROPB_WRITE>,
    ) -> Result<(), IMPL_MICROPB_WRITE::Error> {
        use ::micropb::{FieldEncode, PbMap};
        {
            let val_ref = &self.r#resp;
            if *val_ref != 0 {
                encoder.encode_varint32(8u32)?;
                encoder.encode_int32(*val_ref as _)?;
            }
        }
        Ok(())
    }
    fn compute_size(&self) -> usize {
        use ::micropb::{FieldEncode, PbMap};
        let mut size = 0;
        {
            let val_ref = &self.r#resp;
            if *val_ref != 0 {
                size += 1usize + ::micropb::size::sizeof_int32(*val_ref as _);
            }
        }
        size
    }
}
pub mod Rpc_Req_WifiInit_ {
    #[derive(Debug, Default, PartialEq, Clone)]
    pub struct _Hazzer([u8; 1]);
    impl _Hazzer {
        ///New hazzer with all fields set to off
        #[inline]
        pub const fn _new() -> Self {
            Self([0; 1])
        }
        ///Query presence of `cfg`
        #[inline]
        pub const fn r#cfg(&self) -> bool {
            (self.0[0] & 1) != 0
        }
        ///Set presence of `cfg`
        #[inline]
        pub const fn set_cfg(&mut self) -> &mut Self {
            let elem = &mut self.0[0];
            *elem |= 1;
            self
        }
        ///Clear presence of `cfg`
        #[inline]
        pub const fn clear_cfg(&mut self) -> &mut Self {
            let elem = &mut self.0[0];
            *elem &= !1;
            self
        }
        ///Builder method that sets the presence of `cfg`. Useful for initializing the Hazzer.
        #[inline]
        pub const fn init_cfg(mut self) -> Self {
            self.set_cfg();
            self
        }
    }
}
#[derive(Debug, Default, Clone)]
pub struct Rpc_Req_WifiInit {
    pub r#cfg: r#wifi_init_config,
    pub _has: Rpc_Req_WifiInit_::_Hazzer,
}
impl ::core::cmp::PartialEq for Rpc_Req_WifiInit {
    fn eq(&self, other: &Self) -> bool {
        let mut ret = true;
        ret &= (self.r#cfg() == other.r#cfg());
        ret
    }
}
impl Rpc_Req_WifiInit {
    ///Return a reference to `cfg` as an `Option`
    #[inline]
    pub fn r#cfg(&self) -> ::core::option::Option<&r#wifi_init_config> {
        self._has.r#cfg().then_some(&self.r#cfg)
    }
    ///Set the value and presence of `cfg`
    #[inline]
    pub fn set_cfg(&mut self, value: r#wifi_init_config) -> &mut Self {
        self._has.set_cfg();
        self.r#cfg = value.into();
        self
    }
    ///Return a mutable reference to `cfg` as an `Option`
    #[inline]
    pub fn mut_cfg(&mut self) -> ::core::option::Option<&mut r#wifi_init_config> {
        self._has.r#cfg().then_some(&mut self.r#cfg)
    }
    ///Clear the presence of `cfg`
    #[inline]
    pub fn clear_cfg(&mut self) -> &mut Self {
        self._has.clear_cfg();
        self
    }
    ///Take the value of `cfg` and clear its presence
    #[inline]
    pub fn take_cfg(&mut self) -> ::core::option::Option<r#wifi_init_config> {
        let val = self
            ._has
            .r#cfg()
            .then(|| ::core::mem::take(&mut self.r#cfg));
        self._has.clear_cfg();
        val
    }
    ///Builder method that sets the value of `cfg`. Useful for initializing the message.
    #[inline]
    pub fn init_cfg(mut self, value: r#wifi_init_config) -> Self {
        self.set_cfg(value);
        self
    }
}
impl ::micropb::MessageDecode for Rpc_Req_WifiInit {
    fn decode<IMPL_MICROPB_READ: ::micropb::PbRead>(
        &mut self,
        decoder: &mut ::micropb::PbDecoder<IMPL_MICROPB_READ>,
        len: usize,
    ) -> Result<(), ::micropb::DecodeError<IMPL_MICROPB_READ::Error>> {
        use ::micropb::{FieldDecode, PbBytes, PbMap, PbString, PbVec};
        let before = decoder.bytes_read();
        while decoder.bytes_read() - before < len {
            let tag = decoder.decode_tag()?;
            match tag.field_num() {
                0 => return Err(::micropb::DecodeError::ZeroField),
                1u32 => {
                    let mut_ref = &mut self.r#cfg;
                    {
                        mut_ref.decode_len_delimited(decoder)?;
                    };
                    self._has.set_cfg();
                }
                _ => {
                    decoder.skip_wire_value(tag.wire_type())?;
                }
            }
        }
        Ok(())
    }
}
impl ::micropb::MessageEncode for Rpc_Req_WifiInit {
    const MAX_SIZE: ::core::option::Option<usize> = 'msg: {
        let mut max_size = 0;
        if let ::core::option::Option::Some(size) = ::micropb::const_map!(
            ::micropb::const_map!(
                <r#wifi_init_config as ::micropb::MessageEncode>::MAX_SIZE,
                |size| ::micropb::size::sizeof_len_record(size)
            ),
            |size| size + 1usize
        ) {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        ::core::option::Option::Some(max_size)
    };
    fn encode<IMPL_MICROPB_WRITE: ::micropb::PbWrite>(
        &self,
        encoder: &mut ::micropb::PbEncoder<IMPL_MICROPB_WRITE>,
    ) -> Result<(), IMPL_MICROPB_WRITE::Error> {
        use ::micropb::{FieldEncode, PbMap};
        {
            if let ::core::option::Option::Some(val_ref) = self.r#cfg() {
                encoder.encode_varint32(10u32)?;
                val_ref.encode_len_delimited(encoder)?;
            }
        }
        Ok(())
    }
    fn compute_size(&self) -> usize {
        use ::micropb::{FieldEncode, PbMap};
        let mut size = 0;
        {
            if let ::core::option::Option::Some(val_ref) = self.r#cfg() {
                size += 1usize + ::micropb::size::sizeof_len_record(val_ref.compute_size());
            }
        }
        size
    }
}
#[derive(Debug, Default, PartialEq, Clone)]
pub struct Rpc_Resp_WifiInit {
    pub r#resp: i32,
}
impl Rpc_Resp_WifiInit {
    ///Return a reference to `resp`
    #[inline]
    pub fn r#resp(&self) -> &i32 {
        &self.r#resp
    }
    ///Return a mutable reference to `resp`
    #[inline]
    pub fn mut_resp(&mut self) -> &mut i32 {
        &mut self.r#resp
    }
    ///Set the value of `resp`
    #[inline]
    pub fn set_resp(&mut self, value: i32) -> &mut Self {
        self.r#resp = value.into();
        self
    }
    ///Builder method that sets the value of `resp`. Useful for initializing the message.
    #[inline]
    pub fn init_resp(mut self, value: i32) -> Self {
        self.r#resp = value.into();
        self
    }
}
impl ::micropb::MessageDecode for Rpc_Resp_WifiInit {
    fn decode<IMPL_MICROPB_READ: ::micropb::PbRead>(
        &mut self,
        decoder: &mut ::micropb::PbDecoder<IMPL_MICROPB_READ>,
        len: usize,
    ) -> Result<(), ::micropb::DecodeError<IMPL_MICROPB_READ::Error>> {
        use ::micropb::{FieldDecode, PbBytes, PbMap, PbString, PbVec};
        let before = decoder.bytes_read();
        while decoder.bytes_read() - before < len {
            let tag = decoder.decode_tag()?;
            match tag.field_num() {
                0 => return Err(::micropb::DecodeError::ZeroField),
                1u32 => {
                    let mut_ref = &mut self.r#resp;
                    {
                        let val = decoder.decode_int32()?;
                        let val_ref = &val;
                        if *val_ref != 0 {
                            *mut_ref = val as _;
                        }
                    };
                }
                _ => {
                    decoder.skip_wire_value(tag.wire_type())?;
                }
            }
        }
        Ok(())
    }
}
impl ::micropb::MessageEncode for Rpc_Resp_WifiInit {
    const MAX_SIZE: ::core::option::Option<usize> = 'msg: {
        let mut max_size = 0;
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(10usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        ::core::option::Option::Some(max_size)
    };
    fn encode<IMPL_MICROPB_WRITE: ::micropb::PbWrite>(
        &self,
        encoder: &mut ::micropb::PbEncoder<IMPL_MICROPB_WRITE>,
    ) -> Result<(), IMPL_MICROPB_WRITE::Error> {
        use ::micropb::{FieldEncode, PbMap};
        {
            let val_ref = &self.r#resp;
            if *val_ref != 0 {
                encoder.encode_varint32(8u32)?;
                encoder.encode_int32(*val_ref as _)?;
            }
        }
        Ok(())
    }
    fn compute_size(&self) -> usize {
        use ::micropb::{FieldEncode, PbMap};
        let mut size = 0;
        {
            let val_ref = &self.r#resp;
            if *val_ref != 0 {
                size += 1usize + ::micropb::size::sizeof_int32(*val_ref as _);
            }
        }
        size
    }
}
#[derive(Debug, Default, PartialEq, Clone)]
pub struct Rpc_Req_WifiDeinit {}
impl Rpc_Req_WifiDeinit {}
impl ::micropb::MessageDecode for Rpc_Req_WifiDeinit {
    fn decode<IMPL_MICROPB_READ: ::micropb::PbRead>(
        &mut self,
        decoder: &mut ::micropb::PbDecoder<IMPL_MICROPB_READ>,
        len: usize,
    ) -> Result<(), ::micropb::DecodeError<IMPL_MICROPB_READ::Error>> {
        use ::micropb::{FieldDecode, PbBytes, PbMap, PbString, PbVec};
        let before = decoder.bytes_read();
        while decoder.bytes_read() - before < len {
            let tag = decoder.decode_tag()?;
            match tag.field_num() {
                0 => return Err(::micropb::DecodeError::ZeroField),
                _ => {
                    decoder.skip_wire_value(tag.wire_type())?;
                }
            }
        }
        Ok(())
    }
}
impl ::micropb::MessageEncode for Rpc_Req_WifiDeinit {
    const MAX_SIZE: ::core::option::Option<usize> = 'msg: {
        let mut max_size = 0;
        ::core::option::Option::Some(max_size)
    };
    fn encode<IMPL_MICROPB_WRITE: ::micropb::PbWrite>(
        &self,
        encoder: &mut ::micropb::PbEncoder<IMPL_MICROPB_WRITE>,
    ) -> Result<(), IMPL_MICROPB_WRITE::Error> {
        use ::micropb::{FieldEncode, PbMap};
        Ok(())
    }
    fn compute_size(&self) -> usize {
        use ::micropb::{FieldEncode, PbMap};
        let mut size = 0;
        size
    }
}
#[derive(Debug, Default, PartialEq, Clone)]
pub struct Rpc_Resp_WifiDeinit {
    pub r#resp: i32,
}
impl Rpc_Resp_WifiDeinit {
    ///Return a reference to `resp`
    #[inline]
    pub fn r#resp(&self) -> &i32 {
        &self.r#resp
    }
    ///Return a mutable reference to `resp`
    #[inline]
    pub fn mut_resp(&mut self) -> &mut i32 {
        &mut self.r#resp
    }
    ///Set the value of `resp`
    #[inline]
    pub fn set_resp(&mut self, value: i32) -> &mut Self {
        self.r#resp = value.into();
        self
    }
    ///Builder method that sets the value of `resp`. Useful for initializing the message.
    #[inline]
    pub fn init_resp(mut self, value: i32) -> Self {
        self.r#resp = value.into();
        self
    }
}
impl ::micropb::MessageDecode for Rpc_Resp_WifiDeinit {
    fn decode<IMPL_MICROPB_READ: ::micropb::PbRead>(
        &mut self,
        decoder: &mut ::micropb::PbDecoder<IMPL_MICROPB_READ>,
        len: usize,
    ) -> Result<(), ::micropb::DecodeError<IMPL_MICROPB_READ::Error>> {
        use ::micropb::{FieldDecode, PbBytes, PbMap, PbString, PbVec};
        let before = decoder.bytes_read();
        while decoder.bytes_read() - before < len {
            let tag = decoder.decode_tag()?;
            match tag.field_num() {
                0 => return Err(::micropb::DecodeError::ZeroField),
                1u32 => {
                    let mut_ref = &mut self.r#resp;
                    {
                        let val = decoder.decode_int32()?;
                        let val_ref = &val;
                        if *val_ref != 0 {
                            *mut_ref = val as _;
                        }
                    };
                }
                _ => {
                    decoder.skip_wire_value(tag.wire_type())?;
                }
            }
        }
        Ok(())
    }
}
impl ::micropb::MessageEncode for Rpc_Resp_WifiDeinit {
    const MAX_SIZE: ::core::option::Option<usize> = 'msg: {
        let mut max_size = 0;
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(10usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        ::core::option::Option::Some(max_size)
    };
    fn encode<IMPL_MICROPB_WRITE: ::micropb::PbWrite>(
        &self,
        encoder: &mut ::micropb::PbEncoder<IMPL_MICROPB_WRITE>,
    ) -> Result<(), IMPL_MICROPB_WRITE::Error> {
        use ::micropb::{FieldEncode, PbMap};
        {
            let val_ref = &self.r#resp;
            if *val_ref != 0 {
                encoder.encode_varint32(8u32)?;
                encoder.encode_int32(*val_ref as _)?;
            }
        }
        Ok(())
    }
    fn compute_size(&self) -> usize {
        use ::micropb::{FieldEncode, PbMap};
        let mut size = 0;
        {
            let val_ref = &self.r#resp;
            if *val_ref != 0 {
                size += 1usize + ::micropb::size::sizeof_int32(*val_ref as _);
            }
        }
        size
    }
}
pub mod Rpc_Req_WifiSetConfig_ {
    #[derive(Debug, Default, PartialEq, Clone)]
    pub struct _Hazzer([u8; 1]);
    impl _Hazzer {
        ///New hazzer with all fields set to off
        #[inline]
        pub const fn _new() -> Self {
            Self([0; 1])
        }
        ///Query presence of `cfg`
        #[inline]
        pub const fn r#cfg(&self) -> bool {
            (self.0[0] & 1) != 0
        }
        ///Set presence of `cfg`
        #[inline]
        pub const fn set_cfg(&mut self) -> &mut Self {
            let elem = &mut self.0[0];
            *elem |= 1;
            self
        }
        ///Clear presence of `cfg`
        #[inline]
        pub const fn clear_cfg(&mut self) -> &mut Self {
            let elem = &mut self.0[0];
            *elem &= !1;
            self
        }
        ///Builder method that sets the presence of `cfg`. Useful for initializing the Hazzer.
        #[inline]
        pub const fn init_cfg(mut self) -> Self {
            self.set_cfg();
            self
        }
    }
}
#[derive(Debug, Default, Clone)]
pub struct Rpc_Req_WifiSetConfig {
    pub r#iface: i32,
    pub r#cfg: r#wifi_config,
    pub _has: Rpc_Req_WifiSetConfig_::_Hazzer,
}
impl ::core::cmp::PartialEq for Rpc_Req_WifiSetConfig {
    fn eq(&self, other: &Self) -> bool {
        let mut ret = true;
        ret &= (self.r#iface == other.r#iface);
        ret &= (self.r#cfg() == other.r#cfg());
        ret
    }
}
impl Rpc_Req_WifiSetConfig {
    ///Return a reference to `iface`
    #[inline]
    pub fn r#iface(&self) -> &i32 {
        &self.r#iface
    }
    ///Return a mutable reference to `iface`
    #[inline]
    pub fn mut_iface(&mut self) -> &mut i32 {
        &mut self.r#iface
    }
    ///Set the value of `iface`
    #[inline]
    pub fn set_iface(&mut self, value: i32) -> &mut Self {
        self.r#iface = value.into();
        self
    }
    ///Builder method that sets the value of `iface`. Useful for initializing the message.
    #[inline]
    pub fn init_iface(mut self, value: i32) -> Self {
        self.r#iface = value.into();
        self
    }
    ///Return a reference to `cfg` as an `Option`
    #[inline]
    pub fn r#cfg(&self) -> ::core::option::Option<&r#wifi_config> {
        self._has.r#cfg().then_some(&self.r#cfg)
    }
    ///Set the value and presence of `cfg`
    #[inline]
    pub fn set_cfg(&mut self, value: r#wifi_config) -> &mut Self {
        self._has.set_cfg();
        self.r#cfg = value.into();
        self
    }
    ///Return a mutable reference to `cfg` as an `Option`
    #[inline]
    pub fn mut_cfg(&mut self) -> ::core::option::Option<&mut r#wifi_config> {
        self._has.r#cfg().then_some(&mut self.r#cfg)
    }
    ///Clear the presence of `cfg`
    #[inline]
    pub fn clear_cfg(&mut self) -> &mut Self {
        self._has.clear_cfg();
        self
    }
    ///Take the value of `cfg` and clear its presence
    #[inline]
    pub fn take_cfg(&mut self) -> ::core::option::Option<r#wifi_config> {
        let val = self
            ._has
            .r#cfg()
            .then(|| ::core::mem::take(&mut self.r#cfg));
        self._has.clear_cfg();
        val
    }
    ///Builder method that sets the value of `cfg`. Useful for initializing the message.
    #[inline]
    pub fn init_cfg(mut self, value: r#wifi_config) -> Self {
        self.set_cfg(value);
        self
    }
}
impl ::micropb::MessageDecode for Rpc_Req_WifiSetConfig {
    fn decode<IMPL_MICROPB_READ: ::micropb::PbRead>(
        &mut self,
        decoder: &mut ::micropb::PbDecoder<IMPL_MICROPB_READ>,
        len: usize,
    ) -> Result<(), ::micropb::DecodeError<IMPL_MICROPB_READ::Error>> {
        use ::micropb::{FieldDecode, PbBytes, PbMap, PbString, PbVec};
        let before = decoder.bytes_read();
        while decoder.bytes_read() - before < len {
            let tag = decoder.decode_tag()?;
            match tag.field_num() {
                0 => return Err(::micropb::DecodeError::ZeroField),
                1u32 => {
                    let mut_ref = &mut self.r#iface;
                    {
                        let val = decoder.decode_int32()?;
                        let val_ref = &val;
                        if *val_ref != 0 {
                            *mut_ref = val as _;
                        }
                    };
                }
                2u32 => {
                    let mut_ref = &mut self.r#cfg;
                    {
                        mut_ref.decode_len_delimited(decoder)?;
                    };
                    self._has.set_cfg();
                }
                _ => {
                    decoder.skip_wire_value(tag.wire_type())?;
                }
            }
        }
        Ok(())
    }
}
impl ::micropb::MessageEncode for Rpc_Req_WifiSetConfig {
    const MAX_SIZE: ::core::option::Option<usize> = 'msg: {
        let mut max_size = 0;
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(10usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        if let ::core::option::Option::Some(size) = ::micropb::const_map!(
            ::micropb::const_map!(
                <r#wifi_config as ::micropb::MessageEncode>::MAX_SIZE,
                |size| ::micropb::size::sizeof_len_record(size)
            ),
            |size| size + 1usize
        ) {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        ::core::option::Option::Some(max_size)
    };
    fn encode<IMPL_MICROPB_WRITE: ::micropb::PbWrite>(
        &self,
        encoder: &mut ::micropb::PbEncoder<IMPL_MICROPB_WRITE>,
    ) -> Result<(), IMPL_MICROPB_WRITE::Error> {
        use ::micropb::{FieldEncode, PbMap};
        {
            let val_ref = &self.r#iface;
            if *val_ref != 0 {
                encoder.encode_varint32(8u32)?;
                encoder.encode_int32(*val_ref as _)?;
            }
        }
        {
            if let ::core::option::Option::Some(val_ref) = self.r#cfg() {
                encoder.encode_varint32(18u32)?;
                val_ref.encode_len_delimited(encoder)?;
            }
        }
        Ok(())
    }
    fn compute_size(&self) -> usize {
        use ::micropb::{FieldEncode, PbMap};
        let mut size = 0;
        {
            let val_ref = &self.r#iface;
            if *val_ref != 0 {
                size += 1usize + ::micropb::size::sizeof_int32(*val_ref as _);
            }
        }
        {
            if let ::core::option::Option::Some(val_ref) = self.r#cfg() {
                size += 1usize + ::micropb::size::sizeof_len_record(val_ref.compute_size());
            }
        }
        size
    }
}
#[derive(Debug, Default, PartialEq, Clone)]
pub struct Rpc_Resp_WifiSetConfig {
    pub r#resp: i32,
}
impl Rpc_Resp_WifiSetConfig {
    ///Return a reference to `resp`
    #[inline]
    pub fn r#resp(&self) -> &i32 {
        &self.r#resp
    }
    ///Return a mutable reference to `resp`
    #[inline]
    pub fn mut_resp(&mut self) -> &mut i32 {
        &mut self.r#resp
    }
    ///Set the value of `resp`
    #[inline]
    pub fn set_resp(&mut self, value: i32) -> &mut Self {
        self.r#resp = value.into();
        self
    }
    ///Builder method that sets the value of `resp`. Useful for initializing the message.
    #[inline]
    pub fn init_resp(mut self, value: i32) -> Self {
        self.r#resp = value.into();
        self
    }
}
impl ::micropb::MessageDecode for Rpc_Resp_WifiSetConfig {
    fn decode<IMPL_MICROPB_READ: ::micropb::PbRead>(
        &mut self,
        decoder: &mut ::micropb::PbDecoder<IMPL_MICROPB_READ>,
        len: usize,
    ) -> Result<(), ::micropb::DecodeError<IMPL_MICROPB_READ::Error>> {
        use ::micropb::{FieldDecode, PbBytes, PbMap, PbString, PbVec};
        let before = decoder.bytes_read();
        while decoder.bytes_read() - before < len {
            let tag = decoder.decode_tag()?;
            match tag.field_num() {
                0 => return Err(::micropb::DecodeError::ZeroField),
                1u32 => {
                    let mut_ref = &mut self.r#resp;
                    {
                        let val = decoder.decode_int32()?;
                        let val_ref = &val;
                        if *val_ref != 0 {
                            *mut_ref = val as _;
                        }
                    };
                }
                _ => {
                    decoder.skip_wire_value(tag.wire_type())?;
                }
            }
        }
        Ok(())
    }
}
impl ::micropb::MessageEncode for Rpc_Resp_WifiSetConfig {
    const MAX_SIZE: ::core::option::Option<usize> = 'msg: {
        let mut max_size = 0;
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(10usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        ::core::option::Option::Some(max_size)
    };
    fn encode<IMPL_MICROPB_WRITE: ::micropb::PbWrite>(
        &self,
        encoder: &mut ::micropb::PbEncoder<IMPL_MICROPB_WRITE>,
    ) -> Result<(), IMPL_MICROPB_WRITE::Error> {
        use ::micropb::{FieldEncode, PbMap};
        {
            let val_ref = &self.r#resp;
            if *val_ref != 0 {
                encoder.encode_varint32(8u32)?;
                encoder.encode_int32(*val_ref as _)?;
            }
        }
        Ok(())
    }
    fn compute_size(&self) -> usize {
        use ::micropb::{FieldEncode, PbMap};
        let mut size = 0;
        {
            let val_ref = &self.r#resp;
            if *val_ref != 0 {
                size += 1usize + ::micropb::size::sizeof_int32(*val_ref as _);
            }
        }
        size
    }
}
#[derive(Debug, Default, PartialEq, Clone)]
pub struct Rpc_Req_WifiGetConfig {
    pub r#iface: i32,
}
impl Rpc_Req_WifiGetConfig {
    ///Return a reference to `iface`
    #[inline]
    pub fn r#iface(&self) -> &i32 {
        &self.r#iface
    }
    ///Return a mutable reference to `iface`
    #[inline]
    pub fn mut_iface(&mut self) -> &mut i32 {
        &mut self.r#iface
    }
    ///Set the value of `iface`
    #[inline]
    pub fn set_iface(&mut self, value: i32) -> &mut Self {
        self.r#iface = value.into();
        self
    }
    ///Builder method that sets the value of `iface`. Useful for initializing the message.
    #[inline]
    pub fn init_iface(mut self, value: i32) -> Self {
        self.r#iface = value.into();
        self
    }
}
impl ::micropb::MessageDecode for Rpc_Req_WifiGetConfig {
    fn decode<IMPL_MICROPB_READ: ::micropb::PbRead>(
        &mut self,
        decoder: &mut ::micropb::PbDecoder<IMPL_MICROPB_READ>,
        len: usize,
    ) -> Result<(), ::micropb::DecodeError<IMPL_MICROPB_READ::Error>> {
        use ::micropb::{FieldDecode, PbBytes, PbMap, PbString, PbVec};
        let before = decoder.bytes_read();
        while decoder.bytes_read() - before < len {
            let tag = decoder.decode_tag()?;
            match tag.field_num() {
                0 => return Err(::micropb::DecodeError::ZeroField),
                1u32 => {
                    let mut_ref = &mut self.r#iface;
                    {
                        let val = decoder.decode_int32()?;
                        let val_ref = &val;
                        if *val_ref != 0 {
                            *mut_ref = val as _;
                        }
                    };
                }
                _ => {
                    decoder.skip_wire_value(tag.wire_type())?;
                }
            }
        }
        Ok(())
    }
}
impl ::micropb::MessageEncode for Rpc_Req_WifiGetConfig {
    const MAX_SIZE: ::core::option::Option<usize> = 'msg: {
        let mut max_size = 0;
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(10usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        ::core::option::Option::Some(max_size)
    };
    fn encode<IMPL_MICROPB_WRITE: ::micropb::PbWrite>(
        &self,
        encoder: &mut ::micropb::PbEncoder<IMPL_MICROPB_WRITE>,
    ) -> Result<(), IMPL_MICROPB_WRITE::Error> {
        use ::micropb::{FieldEncode, PbMap};
        {
            let val_ref = &self.r#iface;
            if *val_ref != 0 {
                encoder.encode_varint32(8u32)?;
                encoder.encode_int32(*val_ref as _)?;
            }
        }
        Ok(())
    }
    fn compute_size(&self) -> usize {
        use ::micropb::{FieldEncode, PbMap};
        let mut size = 0;
        {
            let val_ref = &self.r#iface;
            if *val_ref != 0 {
                size += 1usize + ::micropb::size::sizeof_int32(*val_ref as _);
            }
        }
        size
    }
}
pub mod Rpc_Resp_WifiGetConfig_ {
    #[derive(Debug, Default, PartialEq, Clone)]
    pub struct _Hazzer([u8; 1]);
    impl _Hazzer {
        ///New hazzer with all fields set to off
        #[inline]
        pub const fn _new() -> Self {
            Self([0; 1])
        }
        ///Query presence of `cfg`
        #[inline]
        pub const fn r#cfg(&self) -> bool {
            (self.0[0] & 1) != 0
        }
        ///Set presence of `cfg`
        #[inline]
        pub const fn set_cfg(&mut self) -> &mut Self {
            let elem = &mut self.0[0];
            *elem |= 1;
            self
        }
        ///Clear presence of `cfg`
        #[inline]
        pub const fn clear_cfg(&mut self) -> &mut Self {
            let elem = &mut self.0[0];
            *elem &= !1;
            self
        }
        ///Builder method that sets the presence of `cfg`. Useful for initializing the Hazzer.
        #[inline]
        pub const fn init_cfg(mut self) -> Self {
            self.set_cfg();
            self
        }
    }
}
#[derive(Debug, Default, Clone)]
pub struct Rpc_Resp_WifiGetConfig {
    pub r#resp: i32,
    pub r#iface: i32,
    pub r#cfg: r#wifi_config,
    pub _has: Rpc_Resp_WifiGetConfig_::_Hazzer,
}
impl ::core::cmp::PartialEq for Rpc_Resp_WifiGetConfig {
    fn eq(&self, other: &Self) -> bool {
        let mut ret = true;
        ret &= (self.r#resp == other.r#resp);
        ret &= (self.r#iface == other.r#iface);
        ret &= (self.r#cfg() == other.r#cfg());
        ret
    }
}
impl Rpc_Resp_WifiGetConfig {
    ///Return a reference to `resp`
    #[inline]
    pub fn r#resp(&self) -> &i32 {
        &self.r#resp
    }
    ///Return a mutable reference to `resp`
    #[inline]
    pub fn mut_resp(&mut self) -> &mut i32 {
        &mut self.r#resp
    }
    ///Set the value of `resp`
    #[inline]
    pub fn set_resp(&mut self, value: i32) -> &mut Self {
        self.r#resp = value.into();
        self
    }
    ///Builder method that sets the value of `resp`. Useful for initializing the message.
    #[inline]
    pub fn init_resp(mut self, value: i32) -> Self {
        self.r#resp = value.into();
        self
    }
    ///Return a reference to `iface`
    #[inline]
    pub fn r#iface(&self) -> &i32 {
        &self.r#iface
    }
    ///Return a mutable reference to `iface`
    #[inline]
    pub fn mut_iface(&mut self) -> &mut i32 {
        &mut self.r#iface
    }
    ///Set the value of `iface`
    #[inline]
    pub fn set_iface(&mut self, value: i32) -> &mut Self {
        self.r#iface = value.into();
        self
    }
    ///Builder method that sets the value of `iface`. Useful for initializing the message.
    #[inline]
    pub fn init_iface(mut self, value: i32) -> Self {
        self.r#iface = value.into();
        self
    }
    ///Return a reference to `cfg` as an `Option`
    #[inline]
    pub fn r#cfg(&self) -> ::core::option::Option<&r#wifi_config> {
        self._has.r#cfg().then_some(&self.r#cfg)
    }
    ///Set the value and presence of `cfg`
    #[inline]
    pub fn set_cfg(&mut self, value: r#wifi_config) -> &mut Self {
        self._has.set_cfg();
        self.r#cfg = value.into();
        self
    }
    ///Return a mutable reference to `cfg` as an `Option`
    #[inline]
    pub fn mut_cfg(&mut self) -> ::core::option::Option<&mut r#wifi_config> {
        self._has.r#cfg().then_some(&mut self.r#cfg)
    }
    ///Clear the presence of `cfg`
    #[inline]
    pub fn clear_cfg(&mut self) -> &mut Self {
        self._has.clear_cfg();
        self
    }
    ///Take the value of `cfg` and clear its presence
    #[inline]
    pub fn take_cfg(&mut self) -> ::core::option::Option<r#wifi_config> {
        let val = self
            ._has
            .r#cfg()
            .then(|| ::core::mem::take(&mut self.r#cfg));
        self._has.clear_cfg();
        val
    }
    ///Builder method that sets the value of `cfg`. Useful for initializing the message.
    #[inline]
    pub fn init_cfg(mut self, value: r#wifi_config) -> Self {
        self.set_cfg(value);
        self
    }
}
impl ::micropb::MessageDecode for Rpc_Resp_WifiGetConfig {
    fn decode<IMPL_MICROPB_READ: ::micropb::PbRead>(
        &mut self,
        decoder: &mut ::micropb::PbDecoder<IMPL_MICROPB_READ>,
        len: usize,
    ) -> Result<(), ::micropb::DecodeError<IMPL_MICROPB_READ::Error>> {
        use ::micropb::{FieldDecode, PbBytes, PbMap, PbString, PbVec};
        let before = decoder.bytes_read();
        while decoder.bytes_read() - before < len {
            let tag = decoder.decode_tag()?;
            match tag.field_num() {
                0 => return Err(::micropb::DecodeError::ZeroField),
                1u32 => {
                    let mut_ref = &mut self.r#resp;
                    {
                        let val = decoder.decode_int32()?;
                        let val_ref = &val;
                        if *val_ref != 0 {
                            *mut_ref = val as _;
                        }
                    };
                }
                2u32 => {
                    let mut_ref = &mut self.r#iface;
                    {
                        let val = decoder.decode_int32()?;
                        let val_ref = &val;
                        if *val_ref != 0 {
                            *mut_ref = val as _;
                        }
                    };
                }
                3u32 => {
                    let mut_ref = &mut self.r#cfg;
                    {
                        mut_ref.decode_len_delimited(decoder)?;
                    };
                    self._has.set_cfg();
                }
                _ => {
                    decoder.skip_wire_value(tag.wire_type())?;
                }
            }
        }
        Ok(())
    }
}
impl ::micropb::MessageEncode for Rpc_Resp_WifiGetConfig {
    const MAX_SIZE: ::core::option::Option<usize> = 'msg: {
        let mut max_size = 0;
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(10usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(10usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        if let ::core::option::Option::Some(size) = ::micropb::const_map!(
            ::micropb::const_map!(
                <r#wifi_config as ::micropb::MessageEncode>::MAX_SIZE,
                |size| ::micropb::size::sizeof_len_record(size)
            ),
            |size| size + 1usize
        ) {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        ::core::option::Option::Some(max_size)
    };
    fn encode<IMPL_MICROPB_WRITE: ::micropb::PbWrite>(
        &self,
        encoder: &mut ::micropb::PbEncoder<IMPL_MICROPB_WRITE>,
    ) -> Result<(), IMPL_MICROPB_WRITE::Error> {
        use ::micropb::{FieldEncode, PbMap};
        {
            let val_ref = &self.r#resp;
            if *val_ref != 0 {
                encoder.encode_varint32(8u32)?;
                encoder.encode_int32(*val_ref as _)?;
            }
        }
        {
            let val_ref = &self.r#iface;
            if *val_ref != 0 {
                encoder.encode_varint32(16u32)?;
                encoder.encode_int32(*val_ref as _)?;
            }
        }
        {
            if let ::core::option::Option::Some(val_ref) = self.r#cfg() {
                encoder.encode_varint32(26u32)?;
                val_ref.encode_len_delimited(encoder)?;
            }
        }
        Ok(())
    }
    fn compute_size(&self) -> usize {
        use ::micropb::{FieldEncode, PbMap};
        let mut size = 0;
        {
            let val_ref = &self.r#resp;
            if *val_ref != 0 {
                size += 1usize + ::micropb::size::sizeof_int32(*val_ref as _);
            }
        }
        {
            let val_ref = &self.r#iface;
            if *val_ref != 0 {
                size += 1usize + ::micropb::size::sizeof_int32(*val_ref as _);
            }
        }
        {
            if let ::core::option::Option::Some(val_ref) = self.r#cfg() {
                size += 1usize + ::micropb::size::sizeof_len_record(val_ref.compute_size());
            }
        }
        size
    }
}
#[derive(Debug, Default, PartialEq, Clone)]
pub struct Rpc_Req_WifiConnect {}
impl Rpc_Req_WifiConnect {}
impl ::micropb::MessageDecode for Rpc_Req_WifiConnect {
    fn decode<IMPL_MICROPB_READ: ::micropb::PbRead>(
        &mut self,
        decoder: &mut ::micropb::PbDecoder<IMPL_MICROPB_READ>,
        len: usize,
    ) -> Result<(), ::micropb::DecodeError<IMPL_MICROPB_READ::Error>> {
        use ::micropb::{FieldDecode, PbBytes, PbMap, PbString, PbVec};
        let before = decoder.bytes_read();
        while decoder.bytes_read() - before < len {
            let tag = decoder.decode_tag()?;
            match tag.field_num() {
                0 => return Err(::micropb::DecodeError::ZeroField),
                _ => {
                    decoder.skip_wire_value(tag.wire_type())?;
                }
            }
        }
        Ok(())
    }
}
impl ::micropb::MessageEncode for Rpc_Req_WifiConnect {
    const MAX_SIZE: ::core::option::Option<usize> = 'msg: {
        let mut max_size = 0;
        ::core::option::Option::Some(max_size)
    };
    fn encode<IMPL_MICROPB_WRITE: ::micropb::PbWrite>(
        &self,
        encoder: &mut ::micropb::PbEncoder<IMPL_MICROPB_WRITE>,
    ) -> Result<(), IMPL_MICROPB_WRITE::Error> {
        use ::micropb::{FieldEncode, PbMap};
        Ok(())
    }
    fn compute_size(&self) -> usize {
        use ::micropb::{FieldEncode, PbMap};
        let mut size = 0;
        size
    }
}
#[derive(Debug, Default, PartialEq, Clone)]
pub struct Rpc_Resp_WifiConnect {
    pub r#resp: i32,
}
impl Rpc_Resp_WifiConnect {
    ///Return a reference to `resp`
    #[inline]
    pub fn r#resp(&self) -> &i32 {
        &self.r#resp
    }
    ///Return a mutable reference to `resp`
    #[inline]
    pub fn mut_resp(&mut self) -> &mut i32 {
        &mut self.r#resp
    }
    ///Set the value of `resp`
    #[inline]
    pub fn set_resp(&mut self, value: i32) -> &mut Self {
        self.r#resp = value.into();
        self
    }
    ///Builder method that sets the value of `resp`. Useful for initializing the message.
    #[inline]
    pub fn init_resp(mut self, value: i32) -> Self {
        self.r#resp = value.into();
        self
    }
}
impl ::micropb::MessageDecode for Rpc_Resp_WifiConnect {
    fn decode<IMPL_MICROPB_READ: ::micropb::PbRead>(
        &mut self,
        decoder: &mut ::micropb::PbDecoder<IMPL_MICROPB_READ>,
        len: usize,
    ) -> Result<(), ::micropb::DecodeError<IMPL_MICROPB_READ::Error>> {
        use ::micropb::{FieldDecode, PbBytes, PbMap, PbString, PbVec};
        let before = decoder.bytes_read();
        while decoder.bytes_read() - before < len {
            let tag = decoder.decode_tag()?;
            match tag.field_num() {
                0 => return Err(::micropb::DecodeError::ZeroField),
                1u32 => {
                    let mut_ref = &mut self.r#resp;
                    {
                        let val = decoder.decode_int32()?;
                        let val_ref = &val;
                        if *val_ref != 0 {
                            *mut_ref = val as _;
                        }
                    };
                }
                _ => {
                    decoder.skip_wire_value(tag.wire_type())?;
                }
            }
        }
        Ok(())
    }
}
impl ::micropb::MessageEncode for Rpc_Resp_WifiConnect {
    const MAX_SIZE: ::core::option::Option<usize> = 'msg: {
        let mut max_size = 0;
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(10usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        ::core::option::Option::Some(max_size)
    };
    fn encode<IMPL_MICROPB_WRITE: ::micropb::PbWrite>(
        &self,
        encoder: &mut ::micropb::PbEncoder<IMPL_MICROPB_WRITE>,
    ) -> Result<(), IMPL_MICROPB_WRITE::Error> {
        use ::micropb::{FieldEncode, PbMap};
        {
            let val_ref = &self.r#resp;
            if *val_ref != 0 {
                encoder.encode_varint32(8u32)?;
                encoder.encode_int32(*val_ref as _)?;
            }
        }
        Ok(())
    }
    fn compute_size(&self) -> usize {
        use ::micropb::{FieldEncode, PbMap};
        let mut size = 0;
        {
            let val_ref = &self.r#resp;
            if *val_ref != 0 {
                size += 1usize + ::micropb::size::sizeof_int32(*val_ref as _);
            }
        }
        size
    }
}
#[derive(Debug, Default, PartialEq, Clone)]
pub struct Rpc_Req_WifiDisconnect {}
impl Rpc_Req_WifiDisconnect {}
impl ::micropb::MessageDecode for Rpc_Req_WifiDisconnect {
    fn decode<IMPL_MICROPB_READ: ::micropb::PbRead>(
        &mut self,
        decoder: &mut ::micropb::PbDecoder<IMPL_MICROPB_READ>,
        len: usize,
    ) -> Result<(), ::micropb::DecodeError<IMPL_MICROPB_READ::Error>> {
        use ::micropb::{FieldDecode, PbBytes, PbMap, PbString, PbVec};
        let before = decoder.bytes_read();
        while decoder.bytes_read() - before < len {
            let tag = decoder.decode_tag()?;
            match tag.field_num() {
                0 => return Err(::micropb::DecodeError::ZeroField),
                _ => {
                    decoder.skip_wire_value(tag.wire_type())?;
                }
            }
        }
        Ok(())
    }
}
impl ::micropb::MessageEncode for Rpc_Req_WifiDisconnect {
    const MAX_SIZE: ::core::option::Option<usize> = 'msg: {
        let mut max_size = 0;
        ::core::option::Option::Some(max_size)
    };
    fn encode<IMPL_MICROPB_WRITE: ::micropb::PbWrite>(
        &self,
        encoder: &mut ::micropb::PbEncoder<IMPL_MICROPB_WRITE>,
    ) -> Result<(), IMPL_MICROPB_WRITE::Error> {
        use ::micropb::{FieldEncode, PbMap};
        Ok(())
    }
    fn compute_size(&self) -> usize {
        use ::micropb::{FieldEncode, PbMap};
        let mut size = 0;
        size
    }
}
#[derive(Debug, Default, PartialEq, Clone)]
pub struct Rpc_Resp_WifiDisconnect {
    pub r#resp: i32,
}
impl Rpc_Resp_WifiDisconnect {
    ///Return a reference to `resp`
    #[inline]
    pub fn r#resp(&self) -> &i32 {
        &self.r#resp
    }
    ///Return a mutable reference to `resp`
    #[inline]
    pub fn mut_resp(&mut self) -> &mut i32 {
        &mut self.r#resp
    }
    ///Set the value of `resp`
    #[inline]
    pub fn set_resp(&mut self, value: i32) -> &mut Self {
        self.r#resp = value.into();
        self
    }
    ///Builder method that sets the value of `resp`. Useful for initializing the message.
    #[inline]
    pub fn init_resp(mut self, value: i32) -> Self {
        self.r#resp = value.into();
        self
    }
}
impl ::micropb::MessageDecode for Rpc_Resp_WifiDisconnect {
    fn decode<IMPL_MICROPB_READ: ::micropb::PbRead>(
        &mut self,
        decoder: &mut ::micropb::PbDecoder<IMPL_MICROPB_READ>,
        len: usize,
    ) -> Result<(), ::micropb::DecodeError<IMPL_MICROPB_READ::Error>> {
        use ::micropb::{FieldDecode, PbBytes, PbMap, PbString, PbVec};
        let before = decoder.bytes_read();
        while decoder.bytes_read() - before < len {
            let tag = decoder.decode_tag()?;
            match tag.field_num() {
                0 => return Err(::micropb::DecodeError::ZeroField),
                1u32 => {
                    let mut_ref = &mut self.r#resp;
                    {
                        let val = decoder.decode_int32()?;
                        let val_ref = &val;
                        if *val_ref != 0 {
                            *mut_ref = val as _;
                        }
                    };
                }
                _ => {
                    decoder.skip_wire_value(tag.wire_type())?;
                }
            }
        }
        Ok(())
    }
}
impl ::micropb::MessageEncode for Rpc_Resp_WifiDisconnect {
    const MAX_SIZE: ::core::option::Option<usize> = 'msg: {
        let mut max_size = 0;
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(10usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        ::core::option::Option::Some(max_size)
    };
    fn encode<IMPL_MICROPB_WRITE: ::micropb::PbWrite>(
        &self,
        encoder: &mut ::micropb::PbEncoder<IMPL_MICROPB_WRITE>,
    ) -> Result<(), IMPL_MICROPB_WRITE::Error> {
        use ::micropb::{FieldEncode, PbMap};
        {
            let val_ref = &self.r#resp;
            if *val_ref != 0 {
                encoder.encode_varint32(8u32)?;
                encoder.encode_int32(*val_ref as _)?;
            }
        }
        Ok(())
    }
    fn compute_size(&self) -> usize {
        use ::micropb::{FieldEncode, PbMap};
        let mut size = 0;
        {
            let val_ref = &self.r#resp;
            if *val_ref != 0 {
                size += 1usize + ::micropb::size::sizeof_int32(*val_ref as _);
            }
        }
        size
    }
}
#[derive(Debug, Default, PartialEq, Clone)]
pub struct Rpc_Req_WifiStart {}
impl Rpc_Req_WifiStart {}
impl ::micropb::MessageDecode for Rpc_Req_WifiStart {
    fn decode<IMPL_MICROPB_READ: ::micropb::PbRead>(
        &mut self,
        decoder: &mut ::micropb::PbDecoder<IMPL_MICROPB_READ>,
        len: usize,
    ) -> Result<(), ::micropb::DecodeError<IMPL_MICROPB_READ::Error>> {
        use ::micropb::{FieldDecode, PbBytes, PbMap, PbString, PbVec};
        let before = decoder.bytes_read();
        while decoder.bytes_read() - before < len {
            let tag = decoder.decode_tag()?;
            match tag.field_num() {
                0 => return Err(::micropb::DecodeError::ZeroField),
                _ => {
                    decoder.skip_wire_value(tag.wire_type())?;
                }
            }
        }
        Ok(())
    }
}
impl ::micropb::MessageEncode for Rpc_Req_WifiStart {
    const MAX_SIZE: ::core::option::Option<usize> = 'msg: {
        let mut max_size = 0;
        ::core::option::Option::Some(max_size)
    };
    fn encode<IMPL_MICROPB_WRITE: ::micropb::PbWrite>(
        &self,
        encoder: &mut ::micropb::PbEncoder<IMPL_MICROPB_WRITE>,
    ) -> Result<(), IMPL_MICROPB_WRITE::Error> {
        use ::micropb::{FieldEncode, PbMap};
        Ok(())
    }
    fn compute_size(&self) -> usize {
        use ::micropb::{FieldEncode, PbMap};
        let mut size = 0;
        size
    }
}
#[derive(Debug, Default, PartialEq, Clone)]
pub struct Rpc_Resp_WifiStart {
    pub r#resp: i32,
}
impl Rpc_Resp_WifiStart {
    ///Return a reference to `resp`
    #[inline]
    pub fn r#resp(&self) -> &i32 {
        &self.r#resp
    }
    ///Return a mutable reference to `resp`
    #[inline]
    pub fn mut_resp(&mut self) -> &mut i32 {
        &mut self.r#resp
    }
    ///Set the value of `resp`
    #[inline]
    pub fn set_resp(&mut self, value: i32) -> &mut Self {
        self.r#resp = value.into();
        self
    }
    ///Builder method that sets the value of `resp`. Useful for initializing the message.
    #[inline]
    pub fn init_resp(mut self, value: i32) -> Self {
        self.r#resp = value.into();
        self
    }
}
impl ::micropb::MessageDecode for Rpc_Resp_WifiStart {
    fn decode<IMPL_MICROPB_READ: ::micropb::PbRead>(
        &mut self,
        decoder: &mut ::micropb::PbDecoder<IMPL_MICROPB_READ>,
        len: usize,
    ) -> Result<(), ::micropb::DecodeError<IMPL_MICROPB_READ::Error>> {
        use ::micropb::{FieldDecode, PbBytes, PbMap, PbString, PbVec};
        let before = decoder.bytes_read();
        while decoder.bytes_read() - before < len {
            let tag = decoder.decode_tag()?;
            match tag.field_num() {
                0 => return Err(::micropb::DecodeError::ZeroField),
                1u32 => {
                    let mut_ref = &mut self.r#resp;
                    {
                        let val = decoder.decode_int32()?;
                        let val_ref = &val;
                        if *val_ref != 0 {
                            *mut_ref = val as _;
                        }
                    };
                }
                _ => {
                    decoder.skip_wire_value(tag.wire_type())?;
                }
            }
        }
        Ok(())
    }
}
impl ::micropb::MessageEncode for Rpc_Resp_WifiStart {
    const MAX_SIZE: ::core::option::Option<usize> = 'msg: {
        let mut max_size = 0;
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(10usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        ::core::option::Option::Some(max_size)
    };
    fn encode<IMPL_MICROPB_WRITE: ::micropb::PbWrite>(
        &self,
        encoder: &mut ::micropb::PbEncoder<IMPL_MICROPB_WRITE>,
    ) -> Result<(), IMPL_MICROPB_WRITE::Error> {
        use ::micropb::{FieldEncode, PbMap};
        {
            let val_ref = &self.r#resp;
            if *val_ref != 0 {
                encoder.encode_varint32(8u32)?;
                encoder.encode_int32(*val_ref as _)?;
            }
        }
        Ok(())
    }
    fn compute_size(&self) -> usize {
        use ::micropb::{FieldEncode, PbMap};
        let mut size = 0;
        {
            let val_ref = &self.r#resp;
            if *val_ref != 0 {
                size += 1usize + ::micropb::size::sizeof_int32(*val_ref as _);
            }
        }
        size
    }
}
#[derive(Debug, Default, PartialEq, Clone)]
pub struct Rpc_Req_WifiStop {}
impl Rpc_Req_WifiStop {}
impl ::micropb::MessageDecode for Rpc_Req_WifiStop {
    fn decode<IMPL_MICROPB_READ: ::micropb::PbRead>(
        &mut self,
        decoder: &mut ::micropb::PbDecoder<IMPL_MICROPB_READ>,
        len: usize,
    ) -> Result<(), ::micropb::DecodeError<IMPL_MICROPB_READ::Error>> {
        use ::micropb::{FieldDecode, PbBytes, PbMap, PbString, PbVec};
        let before = decoder.bytes_read();
        while decoder.bytes_read() - before < len {
            let tag = decoder.decode_tag()?;
            match tag.field_num() {
                0 => return Err(::micropb::DecodeError::ZeroField),
                _ => {
                    decoder.skip_wire_value(tag.wire_type())?;
                }
            }
        }
        Ok(())
    }
}
impl ::micropb::MessageEncode for Rpc_Req_WifiStop {
    const MAX_SIZE: ::core::option::Option<usize> = 'msg: {
        let mut max_size = 0;
        ::core::option::Option::Some(max_size)
    };
    fn encode<IMPL_MICROPB_WRITE: ::micropb::PbWrite>(
        &self,
        encoder: &mut ::micropb::PbEncoder<IMPL_MICROPB_WRITE>,
    ) -> Result<(), IMPL_MICROPB_WRITE::Error> {
        use ::micropb::{FieldEncode, PbMap};
        Ok(())
    }
    fn compute_size(&self) -> usize {
        use ::micropb::{FieldEncode, PbMap};
        let mut size = 0;
        size
    }
}
#[derive(Debug, Default, PartialEq, Clone)]
pub struct Rpc_Resp_WifiStop {
    pub r#resp: i32,
}
impl Rpc_Resp_WifiStop {
    ///Return a reference to `resp`
    #[inline]
    pub fn r#resp(&self) -> &i32 {
        &self.r#resp
    }
    ///Return a mutable reference to `resp`
    #[inline]
    pub fn mut_resp(&mut self) -> &mut i32 {
        &mut self.r#resp
    }
    ///Set the value of `resp`
    #[inline]
    pub fn set_resp(&mut self, value: i32) -> &mut Self {
        self.r#resp = value.into();
        self
    }
    ///Builder method that sets the value of `resp`. Useful for initializing the message.
    #[inline]
    pub fn init_resp(mut self, value: i32) -> Self {
        self.r#resp = value.into();
        self
    }
}
impl ::micropb::MessageDecode for Rpc_Resp_WifiStop {
    fn decode<IMPL_MICROPB_READ: ::micropb::PbRead>(
        &mut self,
        decoder: &mut ::micropb::PbDecoder<IMPL_MICROPB_READ>,
        len: usize,
    ) -> Result<(), ::micropb::DecodeError<IMPL_MICROPB_READ::Error>> {
        use ::micropb::{FieldDecode, PbBytes, PbMap, PbString, PbVec};
        let before = decoder.bytes_read();
        while decoder.bytes_read() - before < len {
            let tag = decoder.decode_tag()?;
            match tag.field_num() {
                0 => return Err(::micropb::DecodeError::ZeroField),
                1u32 => {
                    let mut_ref = &mut self.r#resp;
                    {
                        let val = decoder.decode_int32()?;
                        let val_ref = &val;
                        if *val_ref != 0 {
                            *mut_ref = val as _;
                        }
                    };
                }
                _ => {
                    decoder.skip_wire_value(tag.wire_type())?;
                }
            }
        }
        Ok(())
    }
}
impl ::micropb::MessageEncode for Rpc_Resp_WifiStop {
    const MAX_SIZE: ::core::option::Option<usize> = 'msg: {
        let mut max_size = 0;
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(10usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        ::core::option::Option::Some(max_size)
    };
    fn encode<IMPL_MICROPB_WRITE: ::micropb::PbWrite>(
        &self,
        encoder: &mut ::micropb::PbEncoder<IMPL_MICROPB_WRITE>,
    ) -> Result<(), IMPL_MICROPB_WRITE::Error> {
        use ::micropb::{FieldEncode, PbMap};
        {
            let val_ref = &self.r#resp;
            if *val_ref != 0 {
                encoder.encode_varint32(8u32)?;
                encoder.encode_int32(*val_ref as _)?;
            }
        }
        Ok(())
    }
    fn compute_size(&self) -> usize {
        use ::micropb::{FieldEncode, PbMap};
        let mut size = 0;
        {
            let val_ref = &self.r#resp;
            if *val_ref != 0 {
                size += 1usize + ::micropb::size::sizeof_int32(*val_ref as _);
            }
        }
        size
    }
}
pub mod Rpc_Req_WifiScanStart_ {
    #[derive(Debug, Default, PartialEq, Clone)]
    pub struct _Hazzer([u8; 1]);
    impl _Hazzer {
        ///New hazzer with all fields set to off
        #[inline]
        pub const fn _new() -> Self {
            Self([0; 1])
        }
        ///Query presence of `config`
        #[inline]
        pub const fn r#config(&self) -> bool {
            (self.0[0] & 1) != 0
        }
        ///Set presence of `config`
        #[inline]
        pub const fn set_config(&mut self) -> &mut Self {
            let elem = &mut self.0[0];
            *elem |= 1;
            self
        }
        ///Clear presence of `config`
        #[inline]
        pub const fn clear_config(&mut self) -> &mut Self {
            let elem = &mut self.0[0];
            *elem &= !1;
            self
        }
        ///Builder method that sets the presence of `config`. Useful for initializing the Hazzer.
        #[inline]
        pub const fn init_config(mut self) -> Self {
            self.set_config();
            self
        }
    }
}
#[derive(Debug, Default, Clone)]
pub struct Rpc_Req_WifiScanStart {
    pub r#config: r#wifi_scan_config,
    pub r#block: bool,
    pub r#config_set: i32,
    pub _has: Rpc_Req_WifiScanStart_::_Hazzer,
}
impl ::core::cmp::PartialEq for Rpc_Req_WifiScanStart {
    fn eq(&self, other: &Self) -> bool {
        let mut ret = true;
        ret &= (self.r#config() == other.r#config());
        ret &= (self.r#block == other.r#block);
        ret &= (self.r#config_set == other.r#config_set);
        ret
    }
}
impl Rpc_Req_WifiScanStart {
    ///Return a reference to `config` as an `Option`
    #[inline]
    pub fn r#config(&self) -> ::core::option::Option<&r#wifi_scan_config> {
        self._has.r#config().then_some(&self.r#config)
    }
    ///Set the value and presence of `config`
    #[inline]
    pub fn set_config(&mut self, value: r#wifi_scan_config) -> &mut Self {
        self._has.set_config();
        self.r#config = value.into();
        self
    }
    ///Return a mutable reference to `config` as an `Option`
    #[inline]
    pub fn mut_config(&mut self) -> ::core::option::Option<&mut r#wifi_scan_config> {
        self._has.r#config().then_some(&mut self.r#config)
    }
    ///Clear the presence of `config`
    #[inline]
    pub fn clear_config(&mut self) -> &mut Self {
        self._has.clear_config();
        self
    }
    ///Take the value of `config` and clear its presence
    #[inline]
    pub fn take_config(&mut self) -> ::core::option::Option<r#wifi_scan_config> {
        let val = self
            ._has
            .r#config()
            .then(|| ::core::mem::take(&mut self.r#config));
        self._has.clear_config();
        val
    }
    ///Builder method that sets the value of `config`. Useful for initializing the message.
    #[inline]
    pub fn init_config(mut self, value: r#wifi_scan_config) -> Self {
        self.set_config(value);
        self
    }
    ///Return a reference to `block`
    #[inline]
    pub fn r#block(&self) -> &bool {
        &self.r#block
    }
    ///Return a mutable reference to `block`
    #[inline]
    pub fn mut_block(&mut self) -> &mut bool {
        &mut self.r#block
    }
    ///Set the value of `block`
    #[inline]
    pub fn set_block(&mut self, value: bool) -> &mut Self {
        self.r#block = value.into();
        self
    }
    ///Builder method that sets the value of `block`. Useful for initializing the message.
    #[inline]
    pub fn init_block(mut self, value: bool) -> Self {
        self.r#block = value.into();
        self
    }
    ///Return a reference to `config_set`
    #[inline]
    pub fn r#config_set(&self) -> &i32 {
        &self.r#config_set
    }
    ///Return a mutable reference to `config_set`
    #[inline]
    pub fn mut_config_set(&mut self) -> &mut i32 {
        &mut self.r#config_set
    }
    ///Set the value of `config_set`
    #[inline]
    pub fn set_config_set(&mut self, value: i32) -> &mut Self {
        self.r#config_set = value.into();
        self
    }
    ///Builder method that sets the value of `config_set`. Useful for initializing the message.
    #[inline]
    pub fn init_config_set(mut self, value: i32) -> Self {
        self.r#config_set = value.into();
        self
    }
}
impl ::micropb::MessageDecode for Rpc_Req_WifiScanStart {
    fn decode<IMPL_MICROPB_READ: ::micropb::PbRead>(
        &mut self,
        decoder: &mut ::micropb::PbDecoder<IMPL_MICROPB_READ>,
        len: usize,
    ) -> Result<(), ::micropb::DecodeError<IMPL_MICROPB_READ::Error>> {
        use ::micropb::{FieldDecode, PbBytes, PbMap, PbString, PbVec};
        let before = decoder.bytes_read();
        while decoder.bytes_read() - before < len {
            let tag = decoder.decode_tag()?;
            match tag.field_num() {
                0 => return Err(::micropb::DecodeError::ZeroField),
                1u32 => {
                    let mut_ref = &mut self.r#config;
                    {
                        mut_ref.decode_len_delimited(decoder)?;
                    };
                    self._has.set_config();
                }
                2u32 => {
                    let mut_ref = &mut self.r#block;
                    {
                        let val = decoder.decode_bool()?;
                        let val_ref = &val;
                        if *val_ref {
                            *mut_ref = val as _;
                        }
                    };
                }
                3u32 => {
                    let mut_ref = &mut self.r#config_set;
                    {
                        let val = decoder.decode_int32()?;
                        let val_ref = &val;
                        if *val_ref != 0 {
                            *mut_ref = val as _;
                        }
                    };
                }
                _ => {
                    decoder.skip_wire_value(tag.wire_type())?;
                }
            }
        }
        Ok(())
    }
}
impl ::micropb::MessageEncode for Rpc_Req_WifiScanStart {
    const MAX_SIZE: ::core::option::Option<usize> = 'msg: {
        let mut max_size = 0;
        if let ::core::option::Option::Some(size) = ::micropb::const_map!(
            ::micropb::const_map!(
                <r#wifi_scan_config as ::micropb::MessageEncode>::MAX_SIZE,
                |size| ::micropb::size::sizeof_len_record(size)
            ),
            |size| size + 1usize
        ) {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(1usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(10usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        ::core::option::Option::Some(max_size)
    };
    fn encode<IMPL_MICROPB_WRITE: ::micropb::PbWrite>(
        &self,
        encoder: &mut ::micropb::PbEncoder<IMPL_MICROPB_WRITE>,
    ) -> Result<(), IMPL_MICROPB_WRITE::Error> {
        use ::micropb::{FieldEncode, PbMap};
        {
            if let ::core::option::Option::Some(val_ref) = self.r#config() {
                encoder.encode_varint32(10u32)?;
                val_ref.encode_len_delimited(encoder)?;
            }
        }
        {
            let val_ref = &self.r#block;
            if *val_ref {
                encoder.encode_varint32(16u32)?;
                encoder.encode_bool(*val_ref)?;
            }
        }
        {
            let val_ref = &self.r#config_set;
            if *val_ref != 0 {
                encoder.encode_varint32(24u32)?;
                encoder.encode_int32(*val_ref as _)?;
            }
        }
        Ok(())
    }
    fn compute_size(&self) -> usize {
        use ::micropb::{FieldEncode, PbMap};
        let mut size = 0;
        {
            if let ::core::option::Option::Some(val_ref) = self.r#config() {
                size += 1usize + ::micropb::size::sizeof_len_record(val_ref.compute_size());
            }
        }
        {
            let val_ref = &self.r#block;
            if *val_ref {
                size += 1usize + 1;
            }
        }
        {
            let val_ref = &self.r#config_set;
            if *val_ref != 0 {
                size += 1usize + ::micropb::size::sizeof_int32(*val_ref as _);
            }
        }
        size
    }
}
#[derive(Debug, Default, PartialEq, Clone)]
pub struct Rpc_Resp_WifiScanStart {
    pub r#resp: i32,
}
impl Rpc_Resp_WifiScanStart {
    ///Return a reference to `resp`
    #[inline]
    pub fn r#resp(&self) -> &i32 {
        &self.r#resp
    }
    ///Return a mutable reference to `resp`
    #[inline]
    pub fn mut_resp(&mut self) -> &mut i32 {
        &mut self.r#resp
    }
    ///Set the value of `resp`
    #[inline]
    pub fn set_resp(&mut self, value: i32) -> &mut Self {
        self.r#resp = value.into();
        self
    }
    ///Builder method that sets the value of `resp`. Useful for initializing the message.
    #[inline]
    pub fn init_resp(mut self, value: i32) -> Self {
        self.r#resp = value.into();
        self
    }
}
impl ::micropb::MessageDecode for Rpc_Resp_WifiScanStart {
    fn decode<IMPL_MICROPB_READ: ::micropb::PbRead>(
        &mut self,
        decoder: &mut ::micropb::PbDecoder<IMPL_MICROPB_READ>,
        len: usize,
    ) -> Result<(), ::micropb::DecodeError<IMPL_MICROPB_READ::Error>> {
        use ::micropb::{FieldDecode, PbBytes, PbMap, PbString, PbVec};
        let before = decoder.bytes_read();
        while decoder.bytes_read() - before < len {
            let tag = decoder.decode_tag()?;
            match tag.field_num() {
                0 => return Err(::micropb::DecodeError::ZeroField),
                1u32 => {
                    let mut_ref = &mut self.r#resp;
                    {
                        let val = decoder.decode_int32()?;
                        let val_ref = &val;
                        if *val_ref != 0 {
                            *mut_ref = val as _;
                        }
                    };
                }
                _ => {
                    decoder.skip_wire_value(tag.wire_type())?;
                }
            }
        }
        Ok(())
    }
}
impl ::micropb::MessageEncode for Rpc_Resp_WifiScanStart {
    const MAX_SIZE: ::core::option::Option<usize> = 'msg: {
        let mut max_size = 0;
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(10usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        ::core::option::Option::Some(max_size)
    };
    fn encode<IMPL_MICROPB_WRITE: ::micropb::PbWrite>(
        &self,
        encoder: &mut ::micropb::PbEncoder<IMPL_MICROPB_WRITE>,
    ) -> Result<(), IMPL_MICROPB_WRITE::Error> {
        use ::micropb::{FieldEncode, PbMap};
        {
            let val_ref = &self.r#resp;
            if *val_ref != 0 {
                encoder.encode_varint32(8u32)?;
                encoder.encode_int32(*val_ref as _)?;
            }
        }
        Ok(())
    }
    fn compute_size(&self) -> usize {
        use ::micropb::{FieldEncode, PbMap};
        let mut size = 0;
        {
            let val_ref = &self.r#resp;
            if *val_ref != 0 {
                size += 1usize + ::micropb::size::sizeof_int32(*val_ref as _);
            }
        }
        size
    }
}
#[derive(Debug, Default, PartialEq, Clone)]
pub struct Rpc_Req_WifiScanStop {}
impl Rpc_Req_WifiScanStop {}
impl ::micropb::MessageDecode for Rpc_Req_WifiScanStop {
    fn decode<IMPL_MICROPB_READ: ::micropb::PbRead>(
        &mut self,
        decoder: &mut ::micropb::PbDecoder<IMPL_MICROPB_READ>,
        len: usize,
    ) -> Result<(), ::micropb::DecodeError<IMPL_MICROPB_READ::Error>> {
        use ::micropb::{FieldDecode, PbBytes, PbMap, PbString, PbVec};
        let before = decoder.bytes_read();
        while decoder.bytes_read() - before < len {
            let tag = decoder.decode_tag()?;
            match tag.field_num() {
                0 => return Err(::micropb::DecodeError::ZeroField),
                _ => {
                    decoder.skip_wire_value(tag.wire_type())?;
                }
            }
        }
        Ok(())
    }
}
impl ::micropb::MessageEncode for Rpc_Req_WifiScanStop {
    const MAX_SIZE: ::core::option::Option<usize> = 'msg: {
        let mut max_size = 0;
        ::core::option::Option::Some(max_size)
    };
    fn encode<IMPL_MICROPB_WRITE: ::micropb::PbWrite>(
        &self,
        encoder: &mut ::micropb::PbEncoder<IMPL_MICROPB_WRITE>,
    ) -> Result<(), IMPL_MICROPB_WRITE::Error> {
        use ::micropb::{FieldEncode, PbMap};
        Ok(())
    }
    fn compute_size(&self) -> usize {
        use ::micropb::{FieldEncode, PbMap};
        let mut size = 0;
        size
    }
}
#[derive(Debug, Default, PartialEq, Clone)]
pub struct Rpc_Resp_WifiScanStop {
    pub r#resp: i32,
}
impl Rpc_Resp_WifiScanStop {
    ///Return a reference to `resp`
    #[inline]
    pub fn r#resp(&self) -> &i32 {
        &self.r#resp
    }
    ///Return a mutable reference to `resp`
    #[inline]
    pub fn mut_resp(&mut self) -> &mut i32 {
        &mut self.r#resp
    }
    ///Set the value of `resp`
    #[inline]
    pub fn set_resp(&mut self, value: i32) -> &mut Self {
        self.r#resp = value.into();
        self
    }
    ///Builder method that sets the value of `resp`. Useful for initializing the message.
    #[inline]
    pub fn init_resp(mut self, value: i32) -> Self {
        self.r#resp = value.into();
        self
    }
}
impl ::micropb::MessageDecode for Rpc_Resp_WifiScanStop {
    fn decode<IMPL_MICROPB_READ: ::micropb::PbRead>(
        &mut self,
        decoder: &mut ::micropb::PbDecoder<IMPL_MICROPB_READ>,
        len: usize,
    ) -> Result<(), ::micropb::DecodeError<IMPL_MICROPB_READ::Error>> {
        use ::micropb::{FieldDecode, PbBytes, PbMap, PbString, PbVec};
        let before = decoder.bytes_read();
        while decoder.bytes_read() - before < len {
            let tag = decoder.decode_tag()?;
            match tag.field_num() {
                0 => return Err(::micropb::DecodeError::ZeroField),
                1u32 => {
                    let mut_ref = &mut self.r#resp;
                    {
                        let val = decoder.decode_int32()?;
                        let val_ref = &val;
                        if *val_ref != 0 {
                            *mut_ref = val as _;
                        }
                    };
                }
                _ => {
                    decoder.skip_wire_value(tag.wire_type())?;
                }
            }
        }
        Ok(())
    }
}
impl ::micropb::MessageEncode for Rpc_Resp_WifiScanStop {
    const MAX_SIZE: ::core::option::Option<usize> = 'msg: {
        let mut max_size = 0;
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(10usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        ::core::option::Option::Some(max_size)
    };
    fn encode<IMPL_MICROPB_WRITE: ::micropb::PbWrite>(
        &self,
        encoder: &mut ::micropb::PbEncoder<IMPL_MICROPB_WRITE>,
    ) -> Result<(), IMPL_MICROPB_WRITE::Error> {
        use ::micropb::{FieldEncode, PbMap};
        {
            let val_ref = &self.r#resp;
            if *val_ref != 0 {
                encoder.encode_varint32(8u32)?;
                encoder.encode_int32(*val_ref as _)?;
            }
        }
        Ok(())
    }
    fn compute_size(&self) -> usize {
        use ::micropb::{FieldEncode, PbMap};
        let mut size = 0;
        {
            let val_ref = &self.r#resp;
            if *val_ref != 0 {
                size += 1usize + ::micropb::size::sizeof_int32(*val_ref as _);
            }
        }
        size
    }
}
#[derive(Debug, Default, PartialEq, Clone)]
pub struct Rpc_Req_WifiScanGetApNum {}
impl Rpc_Req_WifiScanGetApNum {}
impl ::micropb::MessageDecode for Rpc_Req_WifiScanGetApNum {
    fn decode<IMPL_MICROPB_READ: ::micropb::PbRead>(
        &mut self,
        decoder: &mut ::micropb::PbDecoder<IMPL_MICROPB_READ>,
        len: usize,
    ) -> Result<(), ::micropb::DecodeError<IMPL_MICROPB_READ::Error>> {
        use ::micropb::{FieldDecode, PbBytes, PbMap, PbString, PbVec};
        let before = decoder.bytes_read();
        while decoder.bytes_read() - before < len {
            let tag = decoder.decode_tag()?;
            match tag.field_num() {
                0 => return Err(::micropb::DecodeError::ZeroField),
                _ => {
                    decoder.skip_wire_value(tag.wire_type())?;
                }
            }
        }
        Ok(())
    }
}
impl ::micropb::MessageEncode for Rpc_Req_WifiScanGetApNum {
    const MAX_SIZE: ::core::option::Option<usize> = 'msg: {
        let mut max_size = 0;
        ::core::option::Option::Some(max_size)
    };
    fn encode<IMPL_MICROPB_WRITE: ::micropb::PbWrite>(
        &self,
        encoder: &mut ::micropb::PbEncoder<IMPL_MICROPB_WRITE>,
    ) -> Result<(), IMPL_MICROPB_WRITE::Error> {
        use ::micropb::{FieldEncode, PbMap};
        Ok(())
    }
    fn compute_size(&self) -> usize {
        use ::micropb::{FieldEncode, PbMap};
        let mut size = 0;
        size
    }
}
#[derive(Debug, Default, PartialEq, Clone)]
pub struct Rpc_Resp_WifiScanGetApNum {
    pub r#resp: i32,
    pub r#number: i32,
}
impl Rpc_Resp_WifiScanGetApNum {
    ///Return a reference to `resp`
    #[inline]
    pub fn r#resp(&self) -> &i32 {
        &self.r#resp
    }
    ///Return a mutable reference to `resp`
    #[inline]
    pub fn mut_resp(&mut self) -> &mut i32 {
        &mut self.r#resp
    }
    ///Set the value of `resp`
    #[inline]
    pub fn set_resp(&mut self, value: i32) -> &mut Self {
        self.r#resp = value.into();
        self
    }
    ///Builder method that sets the value of `resp`. Useful for initializing the message.
    #[inline]
    pub fn init_resp(mut self, value: i32) -> Self {
        self.r#resp = value.into();
        self
    }
    ///Return a reference to `number`
    #[inline]
    pub fn r#number(&self) -> &i32 {
        &self.r#number
    }
    ///Return a mutable reference to `number`
    #[inline]
    pub fn mut_number(&mut self) -> &mut i32 {
        &mut self.r#number
    }
    ///Set the value of `number`
    #[inline]
    pub fn set_number(&mut self, value: i32) -> &mut Self {
        self.r#number = value.into();
        self
    }
    ///Builder method that sets the value of `number`. Useful for initializing the message.
    #[inline]
    pub fn init_number(mut self, value: i32) -> Self {
        self.r#number = value.into();
        self
    }
}
impl ::micropb::MessageDecode for Rpc_Resp_WifiScanGetApNum {
    fn decode<IMPL_MICROPB_READ: ::micropb::PbRead>(
        &mut self,
        decoder: &mut ::micropb::PbDecoder<IMPL_MICROPB_READ>,
        len: usize,
    ) -> Result<(), ::micropb::DecodeError<IMPL_MICROPB_READ::Error>> {
        use ::micropb::{FieldDecode, PbBytes, PbMap, PbString, PbVec};
        let before = decoder.bytes_read();
        while decoder.bytes_read() - before < len {
            let tag = decoder.decode_tag()?;
            match tag.field_num() {
                0 => return Err(::micropb::DecodeError::ZeroField),
                1u32 => {
                    let mut_ref = &mut self.r#resp;
                    {
                        let val = decoder.decode_int32()?;
                        let val_ref = &val;
                        if *val_ref != 0 {
                            *mut_ref = val as _;
                        }
                    };
                }
                2u32 => {
                    let mut_ref = &mut self.r#number;
                    {
                        let val = decoder.decode_int32()?;
                        let val_ref = &val;
                        if *val_ref != 0 {
                            *mut_ref = val as _;
                        }
                    };
                }
                _ => {
                    decoder.skip_wire_value(tag.wire_type())?;
                }
            }
        }
        Ok(())
    }
}
impl ::micropb::MessageEncode for Rpc_Resp_WifiScanGetApNum {
    const MAX_SIZE: ::core::option::Option<usize> = 'msg: {
        let mut max_size = 0;
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(10usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(10usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        ::core::option::Option::Some(max_size)
    };
    fn encode<IMPL_MICROPB_WRITE: ::micropb::PbWrite>(
        &self,
        encoder: &mut ::micropb::PbEncoder<IMPL_MICROPB_WRITE>,
    ) -> Result<(), IMPL_MICROPB_WRITE::Error> {
        use ::micropb::{FieldEncode, PbMap};
        {
            let val_ref = &self.r#resp;
            if *val_ref != 0 {
                encoder.encode_varint32(8u32)?;
                encoder.encode_int32(*val_ref as _)?;
            }
        }
        {
            let val_ref = &self.r#number;
            if *val_ref != 0 {
                encoder.encode_varint32(16u32)?;
                encoder.encode_int32(*val_ref as _)?;
            }
        }
        Ok(())
    }
    fn compute_size(&self) -> usize {
        use ::micropb::{FieldEncode, PbMap};
        let mut size = 0;
        {
            let val_ref = &self.r#resp;
            if *val_ref != 0 {
                size += 1usize + ::micropb::size::sizeof_int32(*val_ref as _);
            }
        }
        {
            let val_ref = &self.r#number;
            if *val_ref != 0 {
                size += 1usize + ::micropb::size::sizeof_int32(*val_ref as _);
            }
        }
        size
    }
}
#[derive(Debug, Default, PartialEq, Clone)]
pub struct Rpc_Req_WifiScanGetApRecords {
    pub r#number: i32,
}
impl Rpc_Req_WifiScanGetApRecords {
    ///Return a reference to `number`
    #[inline]
    pub fn r#number(&self) -> &i32 {
        &self.r#number
    }
    ///Return a mutable reference to `number`
    #[inline]
    pub fn mut_number(&mut self) -> &mut i32 {
        &mut self.r#number
    }
    ///Set the value of `number`
    #[inline]
    pub fn set_number(&mut self, value: i32) -> &mut Self {
        self.r#number = value.into();
        self
    }
    ///Builder method that sets the value of `number`. Useful for initializing the message.
    #[inline]
    pub fn init_number(mut self, value: i32) -> Self {
        self.r#number = value.into();
        self
    }
}
impl ::micropb::MessageDecode for Rpc_Req_WifiScanGetApRecords {
    fn decode<IMPL_MICROPB_READ: ::micropb::PbRead>(
        &mut self,
        decoder: &mut ::micropb::PbDecoder<IMPL_MICROPB_READ>,
        len: usize,
    ) -> Result<(), ::micropb::DecodeError<IMPL_MICROPB_READ::Error>> {
        use ::micropb::{FieldDecode, PbBytes, PbMap, PbString, PbVec};
        let before = decoder.bytes_read();
        while decoder.bytes_read() - before < len {
            let tag = decoder.decode_tag()?;
            match tag.field_num() {
                0 => return Err(::micropb::DecodeError::ZeroField),
                1u32 => {
                    let mut_ref = &mut self.r#number;
                    {
                        let val = decoder.decode_int32()?;
                        let val_ref = &val;
                        if *val_ref != 0 {
                            *mut_ref = val as _;
                        }
                    };
                }
                _ => {
                    decoder.skip_wire_value(tag.wire_type())?;
                }
            }
        }
        Ok(())
    }
}
impl ::micropb::MessageEncode for Rpc_Req_WifiScanGetApRecords {
    const MAX_SIZE: ::core::option::Option<usize> = 'msg: {
        let mut max_size = 0;
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(10usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        ::core::option::Option::Some(max_size)
    };
    fn encode<IMPL_MICROPB_WRITE: ::micropb::PbWrite>(
        &self,
        encoder: &mut ::micropb::PbEncoder<IMPL_MICROPB_WRITE>,
    ) -> Result<(), IMPL_MICROPB_WRITE::Error> {
        use ::micropb::{FieldEncode, PbMap};
        {
            let val_ref = &self.r#number;
            if *val_ref != 0 {
                encoder.encode_varint32(8u32)?;
                encoder.encode_int32(*val_ref as _)?;
            }
        }
        Ok(())
    }
    fn compute_size(&self) -> usize {
        use ::micropb::{FieldEncode, PbMap};
        let mut size = 0;
        {
            let val_ref = &self.r#number;
            if *val_ref != 0 {
                size += 1usize + ::micropb::size::sizeof_int32(*val_ref as _);
            }
        }
        size
    }
}
#[derive(Debug, Default, PartialEq, Clone)]
pub struct Rpc_Resp_WifiScanGetApRecords {
    pub r#resp: i32,
    pub r#number: i32,
    pub r#ap_records: ::micropb::heapless::Vec<r#wifi_ap_record, 30>,
}
impl Rpc_Resp_WifiScanGetApRecords {
    ///Return a reference to `resp`
    #[inline]
    pub fn r#resp(&self) -> &i32 {
        &self.r#resp
    }
    ///Return a mutable reference to `resp`
    #[inline]
    pub fn mut_resp(&mut self) -> &mut i32 {
        &mut self.r#resp
    }
    ///Set the value of `resp`
    #[inline]
    pub fn set_resp(&mut self, value: i32) -> &mut Self {
        self.r#resp = value.into();
        self
    }
    ///Builder method that sets the value of `resp`. Useful for initializing the message.
    #[inline]
    pub fn init_resp(mut self, value: i32) -> Self {
        self.r#resp = value.into();
        self
    }
    ///Return a reference to `number`
    #[inline]
    pub fn r#number(&self) -> &i32 {
        &self.r#number
    }
    ///Return a mutable reference to `number`
    #[inline]
    pub fn mut_number(&mut self) -> &mut i32 {
        &mut self.r#number
    }
    ///Set the value of `number`
    #[inline]
    pub fn set_number(&mut self, value: i32) -> &mut Self {
        self.r#number = value.into();
        self
    }
    ///Builder method that sets the value of `number`. Useful for initializing the message.
    #[inline]
    pub fn init_number(mut self, value: i32) -> Self {
        self.r#number = value.into();
        self
    }
}
impl ::micropb::MessageDecode for Rpc_Resp_WifiScanGetApRecords {
    fn decode<IMPL_MICROPB_READ: ::micropb::PbRead>(
        &mut self,
        decoder: &mut ::micropb::PbDecoder<IMPL_MICROPB_READ>,
        len: usize,
    ) -> Result<(), ::micropb::DecodeError<IMPL_MICROPB_READ::Error>> {
        use ::micropb::{FieldDecode, PbBytes, PbMap, PbString, PbVec};
        let before = decoder.bytes_read();
        while decoder.bytes_read() - before < len {
            let tag = decoder.decode_tag()?;
            match tag.field_num() {
                0 => return Err(::micropb::DecodeError::ZeroField),
                1u32 => {
                    let mut_ref = &mut self.r#resp;
                    {
                        let val = decoder.decode_int32()?;
                        let val_ref = &val;
                        if *val_ref != 0 {
                            *mut_ref = val as _;
                        }
                    };
                }
                2u32 => {
                    let mut_ref = &mut self.r#number;
                    {
                        let val = decoder.decode_int32()?;
                        let val_ref = &val;
                        if *val_ref != 0 {
                            *mut_ref = val as _;
                        }
                    };
                }
                3u32 => {
                    let mut val: r#wifi_ap_record = ::core::default::Default::default();
                    let mut_ref = &mut val;
                    {
                        mut_ref.decode_len_delimited(decoder)?;
                    };
                    if let (Err(_), false) = (
                        self.r#ap_records.pb_push(val),
                        decoder.ignore_repeated_cap_err,
                    ) {
                        return Err(::micropb::DecodeError::Capacity);
                    }
                }
                _ => {
                    decoder.skip_wire_value(tag.wire_type())?;
                }
            }
        }
        Ok(())
    }
}
impl ::micropb::MessageEncode for Rpc_Resp_WifiScanGetApRecords {
    const MAX_SIZE: ::core::option::Option<usize> = 'msg: {
        let mut max_size = 0;
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(10usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(10usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        if let ::core::option::Option::Some(size) = ::micropb::const_map!(
            ::micropb::const_map!(
                <r#wifi_ap_record as ::micropb::MessageEncode>::MAX_SIZE,
                |size| ::micropb::size::sizeof_len_record(size)
            ),
            |size| (size + 1usize) * 30usize
        ) {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        ::core::option::Option::Some(max_size)
    };
    fn encode<IMPL_MICROPB_WRITE: ::micropb::PbWrite>(
        &self,
        encoder: &mut ::micropb::PbEncoder<IMPL_MICROPB_WRITE>,
    ) -> Result<(), IMPL_MICROPB_WRITE::Error> {
        use ::micropb::{FieldEncode, PbMap};
        {
            let val_ref = &self.r#resp;
            if *val_ref != 0 {
                encoder.encode_varint32(8u32)?;
                encoder.encode_int32(*val_ref as _)?;
            }
        }
        {
            let val_ref = &self.r#number;
            if *val_ref != 0 {
                encoder.encode_varint32(16u32)?;
                encoder.encode_int32(*val_ref as _)?;
            }
        }
        {
            for val_ref in self.r#ap_records.iter() {
                encoder.encode_varint32(26u32)?;
                val_ref.encode_len_delimited(encoder)?;
            }
        }
        Ok(())
    }
    fn compute_size(&self) -> usize {
        use ::micropb::{FieldEncode, PbMap};
        let mut size = 0;
        {
            let val_ref = &self.r#resp;
            if *val_ref != 0 {
                size += 1usize + ::micropb::size::sizeof_int32(*val_ref as _);
            }
        }
        {
            let val_ref = &self.r#number;
            if *val_ref != 0 {
                size += 1usize + ::micropb::size::sizeof_int32(*val_ref as _);
            }
        }
        {
            for val_ref in self.r#ap_records.iter() {
                size += 1usize + ::micropb::size::sizeof_len_record(val_ref.compute_size());
            }
        }
        size
    }
}
#[derive(Debug, Default, PartialEq, Clone)]
pub struct Rpc_Req_WifiScanGetApRecord {}
impl Rpc_Req_WifiScanGetApRecord {}
impl ::micropb::MessageDecode for Rpc_Req_WifiScanGetApRecord {
    fn decode<IMPL_MICROPB_READ: ::micropb::PbRead>(
        &mut self,
        decoder: &mut ::micropb::PbDecoder<IMPL_MICROPB_READ>,
        len: usize,
    ) -> Result<(), ::micropb::DecodeError<IMPL_MICROPB_READ::Error>> {
        use ::micropb::{FieldDecode, PbBytes, PbMap, PbString, PbVec};
        let before = decoder.bytes_read();
        while decoder.bytes_read() - before < len {
            let tag = decoder.decode_tag()?;
            match tag.field_num() {
                0 => return Err(::micropb::DecodeError::ZeroField),
                _ => {
                    decoder.skip_wire_value(tag.wire_type())?;
                }
            }
        }
        Ok(())
    }
}
impl ::micropb::MessageEncode for Rpc_Req_WifiScanGetApRecord {
    const MAX_SIZE: ::core::option::Option<usize> = 'msg: {
        let mut max_size = 0;
        ::core::option::Option::Some(max_size)
    };
    fn encode<IMPL_MICROPB_WRITE: ::micropb::PbWrite>(
        &self,
        encoder: &mut ::micropb::PbEncoder<IMPL_MICROPB_WRITE>,
    ) -> Result<(), IMPL_MICROPB_WRITE::Error> {
        use ::micropb::{FieldEncode, PbMap};
        Ok(())
    }
    fn compute_size(&self) -> usize {
        use ::micropb::{FieldEncode, PbMap};
        let mut size = 0;
        size
    }
}
pub mod Rpc_Resp_WifiScanGetApRecord_ {
    #[derive(Debug, Default, PartialEq, Clone)]
    pub struct _Hazzer([u8; 1]);
    impl _Hazzer {
        ///New hazzer with all fields set to off
        #[inline]
        pub const fn _new() -> Self {
            Self([0; 1])
        }
        ///Query presence of `ap_record`
        #[inline]
        pub const fn r#ap_record(&self) -> bool {
            (self.0[0] & 1) != 0
        }
        ///Set presence of `ap_record`
        #[inline]
        pub const fn set_ap_record(&mut self) -> &mut Self {
            let elem = &mut self.0[0];
            *elem |= 1;
            self
        }
        ///Clear presence of `ap_record`
        #[inline]
        pub const fn clear_ap_record(&mut self) -> &mut Self {
            let elem = &mut self.0[0];
            *elem &= !1;
            self
        }
        ///Builder method that sets the presence of `ap_record`. Useful for initializing the Hazzer.
        #[inline]
        pub const fn init_ap_record(mut self) -> Self {
            self.set_ap_record();
            self
        }
    }
}
#[derive(Debug, Default, Clone)]
pub struct Rpc_Resp_WifiScanGetApRecord {
    pub r#resp: i32,
    pub r#ap_record: r#wifi_ap_record,
    pub _has: Rpc_Resp_WifiScanGetApRecord_::_Hazzer,
}
impl ::core::cmp::PartialEq for Rpc_Resp_WifiScanGetApRecord {
    fn eq(&self, other: &Self) -> bool {
        let mut ret = true;
        ret &= (self.r#resp == other.r#resp);
        ret &= (self.r#ap_record() == other.r#ap_record());
        ret
    }
}
impl Rpc_Resp_WifiScanGetApRecord {
    ///Return a reference to `resp`
    #[inline]
    pub fn r#resp(&self) -> &i32 {
        &self.r#resp
    }
    ///Return a mutable reference to `resp`
    #[inline]
    pub fn mut_resp(&mut self) -> &mut i32 {
        &mut self.r#resp
    }
    ///Set the value of `resp`
    #[inline]
    pub fn set_resp(&mut self, value: i32) -> &mut Self {
        self.r#resp = value.into();
        self
    }
    ///Builder method that sets the value of `resp`. Useful for initializing the message.
    #[inline]
    pub fn init_resp(mut self, value: i32) -> Self {
        self.r#resp = value.into();
        self
    }
    ///Return a reference to `ap_record` as an `Option`
    #[inline]
    pub fn r#ap_record(&self) -> ::core::option::Option<&r#wifi_ap_record> {
        self._has.r#ap_record().then_some(&self.r#ap_record)
    }
    ///Set the value and presence of `ap_record`
    #[inline]
    pub fn set_ap_record(&mut self, value: r#wifi_ap_record) -> &mut Self {
        self._has.set_ap_record();
        self.r#ap_record = value.into();
        self
    }
    ///Return a mutable reference to `ap_record` as an `Option`
    #[inline]
    pub fn mut_ap_record(&mut self) -> ::core::option::Option<&mut r#wifi_ap_record> {
        self._has.r#ap_record().then_some(&mut self.r#ap_record)
    }
    ///Clear the presence of `ap_record`
    #[inline]
    pub fn clear_ap_record(&mut self) -> &mut Self {
        self._has.clear_ap_record();
        self
    }
    ///Take the value of `ap_record` and clear its presence
    #[inline]
    pub fn take_ap_record(&mut self) -> ::core::option::Option<r#wifi_ap_record> {
        let val = self
            ._has
            .r#ap_record()
            .then(|| ::core::mem::take(&mut self.r#ap_record));
        self._has.clear_ap_record();
        val
    }
    ///Builder method that sets the value of `ap_record`. Useful for initializing the message.
    #[inline]
    pub fn init_ap_record(mut self, value: r#wifi_ap_record) -> Self {
        self.set_ap_record(value);
        self
    }
}
impl ::micropb::MessageDecode for Rpc_Resp_WifiScanGetApRecord {
    fn decode<IMPL_MICROPB_READ: ::micropb::PbRead>(
        &mut self,
        decoder: &mut ::micropb::PbDecoder<IMPL_MICROPB_READ>,
        len: usize,
    ) -> Result<(), ::micropb::DecodeError<IMPL_MICROPB_READ::Error>> {
        use ::micropb::{FieldDecode, PbBytes, PbMap, PbString, PbVec};
        let before = decoder.bytes_read();
        while decoder.bytes_read() - before < len {
            let tag = decoder.decode_tag()?;
            match tag.field_num() {
                0 => return Err(::micropb::DecodeError::ZeroField),
                1u32 => {
                    let mut_ref = &mut self.r#resp;
                    {
                        let val = decoder.decode_int32()?;
                        let val_ref = &val;
                        if *val_ref != 0 {
                            *mut_ref = val as _;
                        }
                    };
                }
                2u32 => {
                    let mut_ref = &mut self.r#ap_record;
                    {
                        mut_ref.decode_len_delimited(decoder)?;
                    };
                    self._has.set_ap_record();
                }
                _ => {
                    decoder.skip_wire_value(tag.wire_type())?;
                }
            }
        }
        Ok(())
    }
}
impl ::micropb::MessageEncode for Rpc_Resp_WifiScanGetApRecord {
    const MAX_SIZE: ::core::option::Option<usize> = 'msg: {
        let mut max_size = 0;
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(10usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        if let ::core::option::Option::Some(size) = ::micropb::const_map!(
            ::micropb::const_map!(
                <r#wifi_ap_record as ::micropb::MessageEncode>::MAX_SIZE,
                |size| ::micropb::size::sizeof_len_record(size)
            ),
            |size| size + 1usize
        ) {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        ::core::option::Option::Some(max_size)
    };
    fn encode<IMPL_MICROPB_WRITE: ::micropb::PbWrite>(
        &self,
        encoder: &mut ::micropb::PbEncoder<IMPL_MICROPB_WRITE>,
    ) -> Result<(), IMPL_MICROPB_WRITE::Error> {
        use ::micropb::{FieldEncode, PbMap};
        {
            let val_ref = &self.r#resp;
            if *val_ref != 0 {
                encoder.encode_varint32(8u32)?;
                encoder.encode_int32(*val_ref as _)?;
            }
        }
        {
            if let ::core::option::Option::Some(val_ref) = self.r#ap_record() {
                encoder.encode_varint32(18u32)?;
                val_ref.encode_len_delimited(encoder)?;
            }
        }
        Ok(())
    }
    fn compute_size(&self) -> usize {
        use ::micropb::{FieldEncode, PbMap};
        let mut size = 0;
        {
            let val_ref = &self.r#resp;
            if *val_ref != 0 {
                size += 1usize + ::micropb::size::sizeof_int32(*val_ref as _);
            }
        }
        {
            if let ::core::option::Option::Some(val_ref) = self.r#ap_record() {
                size += 1usize + ::micropb::size::sizeof_len_record(val_ref.compute_size());
            }
        }
        size
    }
}
#[derive(Debug, Default, PartialEq, Clone)]
pub struct Rpc_Req_WifiClearApList {}
impl Rpc_Req_WifiClearApList {}
impl ::micropb::MessageDecode for Rpc_Req_WifiClearApList {
    fn decode<IMPL_MICROPB_READ: ::micropb::PbRead>(
        &mut self,
        decoder: &mut ::micropb::PbDecoder<IMPL_MICROPB_READ>,
        len: usize,
    ) -> Result<(), ::micropb::DecodeError<IMPL_MICROPB_READ::Error>> {
        use ::micropb::{FieldDecode, PbBytes, PbMap, PbString, PbVec};
        let before = decoder.bytes_read();
        while decoder.bytes_read() - before < len {
            let tag = decoder.decode_tag()?;
            match tag.field_num() {
                0 => return Err(::micropb::DecodeError::ZeroField),
                _ => {
                    decoder.skip_wire_value(tag.wire_type())?;
                }
            }
        }
        Ok(())
    }
}
impl ::micropb::MessageEncode for Rpc_Req_WifiClearApList {
    const MAX_SIZE: ::core::option::Option<usize> = 'msg: {
        let mut max_size = 0;
        ::core::option::Option::Some(max_size)
    };
    fn encode<IMPL_MICROPB_WRITE: ::micropb::PbWrite>(
        &self,
        encoder: &mut ::micropb::PbEncoder<IMPL_MICROPB_WRITE>,
    ) -> Result<(), IMPL_MICROPB_WRITE::Error> {
        use ::micropb::{FieldEncode, PbMap};
        Ok(())
    }
    fn compute_size(&self) -> usize {
        use ::micropb::{FieldEncode, PbMap};
        let mut size = 0;
        size
    }
}
#[derive(Debug, Default, PartialEq, Clone)]
pub struct Rpc_Resp_WifiClearApList {
    pub r#resp: i32,
}
impl Rpc_Resp_WifiClearApList {
    ///Return a reference to `resp`
    #[inline]
    pub fn r#resp(&self) -> &i32 {
        &self.r#resp
    }
    ///Return a mutable reference to `resp`
    #[inline]
    pub fn mut_resp(&mut self) -> &mut i32 {
        &mut self.r#resp
    }
    ///Set the value of `resp`
    #[inline]
    pub fn set_resp(&mut self, value: i32) -> &mut Self {
        self.r#resp = value.into();
        self
    }
    ///Builder method that sets the value of `resp`. Useful for initializing the message.
    #[inline]
    pub fn init_resp(mut self, value: i32) -> Self {
        self.r#resp = value.into();
        self
    }
}
impl ::micropb::MessageDecode for Rpc_Resp_WifiClearApList {
    fn decode<IMPL_MICROPB_READ: ::micropb::PbRead>(
        &mut self,
        decoder: &mut ::micropb::PbDecoder<IMPL_MICROPB_READ>,
        len: usize,
    ) -> Result<(), ::micropb::DecodeError<IMPL_MICROPB_READ::Error>> {
        use ::micropb::{FieldDecode, PbBytes, PbMap, PbString, PbVec};
        let before = decoder.bytes_read();
        while decoder.bytes_read() - before < len {
            let tag = decoder.decode_tag()?;
            match tag.field_num() {
                0 => return Err(::micropb::DecodeError::ZeroField),
                1u32 => {
                    let mut_ref = &mut self.r#resp;
                    {
                        let val = decoder.decode_int32()?;
                        let val_ref = &val;
                        if *val_ref != 0 {
                            *mut_ref = val as _;
                        }
                    };
                }
                _ => {
                    decoder.skip_wire_value(tag.wire_type())?;
                }
            }
        }
        Ok(())
    }
}
impl ::micropb::MessageEncode for Rpc_Resp_WifiClearApList {
    const MAX_SIZE: ::core::option::Option<usize> = 'msg: {
        let mut max_size = 0;
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(10usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        ::core::option::Option::Some(max_size)
    };
    fn encode<IMPL_MICROPB_WRITE: ::micropb::PbWrite>(
        &self,
        encoder: &mut ::micropb::PbEncoder<IMPL_MICROPB_WRITE>,
    ) -> Result<(), IMPL_MICROPB_WRITE::Error> {
        use ::micropb::{FieldEncode, PbMap};
        {
            let val_ref = &self.r#resp;
            if *val_ref != 0 {
                encoder.encode_varint32(8u32)?;
                encoder.encode_int32(*val_ref as _)?;
            }
        }
        Ok(())
    }
    fn compute_size(&self) -> usize {
        use ::micropb::{FieldEncode, PbMap};
        let mut size = 0;
        {
            let val_ref = &self.r#resp;
            if *val_ref != 0 {
                size += 1usize + ::micropb::size::sizeof_int32(*val_ref as _);
            }
        }
        size
    }
}
#[derive(Debug, Default, PartialEq, Clone)]
pub struct Rpc_Req_WifiRestore {}
impl Rpc_Req_WifiRestore {}
impl ::micropb::MessageDecode for Rpc_Req_WifiRestore {
    fn decode<IMPL_MICROPB_READ: ::micropb::PbRead>(
        &mut self,
        decoder: &mut ::micropb::PbDecoder<IMPL_MICROPB_READ>,
        len: usize,
    ) -> Result<(), ::micropb::DecodeError<IMPL_MICROPB_READ::Error>> {
        use ::micropb::{FieldDecode, PbBytes, PbMap, PbString, PbVec};
        let before = decoder.bytes_read();
        while decoder.bytes_read() - before < len {
            let tag = decoder.decode_tag()?;
            match tag.field_num() {
                0 => return Err(::micropb::DecodeError::ZeroField),
                _ => {
                    decoder.skip_wire_value(tag.wire_type())?;
                }
            }
        }
        Ok(())
    }
}
impl ::micropb::MessageEncode for Rpc_Req_WifiRestore {
    const MAX_SIZE: ::core::option::Option<usize> = 'msg: {
        let mut max_size = 0;
        ::core::option::Option::Some(max_size)
    };
    fn encode<IMPL_MICROPB_WRITE: ::micropb::PbWrite>(
        &self,
        encoder: &mut ::micropb::PbEncoder<IMPL_MICROPB_WRITE>,
    ) -> Result<(), IMPL_MICROPB_WRITE::Error> {
        use ::micropb::{FieldEncode, PbMap};
        Ok(())
    }
    fn compute_size(&self) -> usize {
        use ::micropb::{FieldEncode, PbMap};
        let mut size = 0;
        size
    }
}
#[derive(Debug, Default, PartialEq, Clone)]
pub struct Rpc_Resp_WifiRestore {
    pub r#resp: i32,
}
impl Rpc_Resp_WifiRestore {
    ///Return a reference to `resp`
    #[inline]
    pub fn r#resp(&self) -> &i32 {
        &self.r#resp
    }
    ///Return a mutable reference to `resp`
    #[inline]
    pub fn mut_resp(&mut self) -> &mut i32 {
        &mut self.r#resp
    }
    ///Set the value of `resp`
    #[inline]
    pub fn set_resp(&mut self, value: i32) -> &mut Self {
        self.r#resp = value.into();
        self
    }
    ///Builder method that sets the value of `resp`. Useful for initializing the message.
    #[inline]
    pub fn init_resp(mut self, value: i32) -> Self {
        self.r#resp = value.into();
        self
    }
}
impl ::micropb::MessageDecode for Rpc_Resp_WifiRestore {
    fn decode<IMPL_MICROPB_READ: ::micropb::PbRead>(
        &mut self,
        decoder: &mut ::micropb::PbDecoder<IMPL_MICROPB_READ>,
        len: usize,
    ) -> Result<(), ::micropb::DecodeError<IMPL_MICROPB_READ::Error>> {
        use ::micropb::{FieldDecode, PbBytes, PbMap, PbString, PbVec};
        let before = decoder.bytes_read();
        while decoder.bytes_read() - before < len {
            let tag = decoder.decode_tag()?;
            match tag.field_num() {
                0 => return Err(::micropb::DecodeError::ZeroField),
                1u32 => {
                    let mut_ref = &mut self.r#resp;
                    {
                        let val = decoder.decode_int32()?;
                        let val_ref = &val;
                        if *val_ref != 0 {
                            *mut_ref = val as _;
                        }
                    };
                }
                _ => {
                    decoder.skip_wire_value(tag.wire_type())?;
                }
            }
        }
        Ok(())
    }
}
impl ::micropb::MessageEncode for Rpc_Resp_WifiRestore {
    const MAX_SIZE: ::core::option::Option<usize> = 'msg: {
        let mut max_size = 0;
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(10usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        ::core::option::Option::Some(max_size)
    };
    fn encode<IMPL_MICROPB_WRITE: ::micropb::PbWrite>(
        &self,
        encoder: &mut ::micropb::PbEncoder<IMPL_MICROPB_WRITE>,
    ) -> Result<(), IMPL_MICROPB_WRITE::Error> {
        use ::micropb::{FieldEncode, PbMap};
        {
            let val_ref = &self.r#resp;
            if *val_ref != 0 {
                encoder.encode_varint32(8u32)?;
                encoder.encode_int32(*val_ref as _)?;
            }
        }
        Ok(())
    }
    fn compute_size(&self) -> usize {
        use ::micropb::{FieldEncode, PbMap};
        let mut size = 0;
        {
            let val_ref = &self.r#resp;
            if *val_ref != 0 {
                size += 1usize + ::micropb::size::sizeof_int32(*val_ref as _);
            }
        }
        size
    }
}
#[derive(Debug, Default, PartialEq, Clone)]
pub struct Rpc_Req_WifiClearFastConnect {}
impl Rpc_Req_WifiClearFastConnect {}
impl ::micropb::MessageDecode for Rpc_Req_WifiClearFastConnect {
    fn decode<IMPL_MICROPB_READ: ::micropb::PbRead>(
        &mut self,
        decoder: &mut ::micropb::PbDecoder<IMPL_MICROPB_READ>,
        len: usize,
    ) -> Result<(), ::micropb::DecodeError<IMPL_MICROPB_READ::Error>> {
        use ::micropb::{FieldDecode, PbBytes, PbMap, PbString, PbVec};
        let before = decoder.bytes_read();
        while decoder.bytes_read() - before < len {
            let tag = decoder.decode_tag()?;
            match tag.field_num() {
                0 => return Err(::micropb::DecodeError::ZeroField),
                _ => {
                    decoder.skip_wire_value(tag.wire_type())?;
                }
            }
        }
        Ok(())
    }
}
impl ::micropb::MessageEncode for Rpc_Req_WifiClearFastConnect {
    const MAX_SIZE: ::core::option::Option<usize> = 'msg: {
        let mut max_size = 0;
        ::core::option::Option::Some(max_size)
    };
    fn encode<IMPL_MICROPB_WRITE: ::micropb::PbWrite>(
        &self,
        encoder: &mut ::micropb::PbEncoder<IMPL_MICROPB_WRITE>,
    ) -> Result<(), IMPL_MICROPB_WRITE::Error> {
        use ::micropb::{FieldEncode, PbMap};
        Ok(())
    }
    fn compute_size(&self) -> usize {
        use ::micropb::{FieldEncode, PbMap};
        let mut size = 0;
        size
    }
}
#[derive(Debug, Default, PartialEq, Clone)]
pub struct Rpc_Resp_WifiClearFastConnect {
    pub r#resp: i32,
}
impl Rpc_Resp_WifiClearFastConnect {
    ///Return a reference to `resp`
    #[inline]
    pub fn r#resp(&self) -> &i32 {
        &self.r#resp
    }
    ///Return a mutable reference to `resp`
    #[inline]
    pub fn mut_resp(&mut self) -> &mut i32 {
        &mut self.r#resp
    }
    ///Set the value of `resp`
    #[inline]
    pub fn set_resp(&mut self, value: i32) -> &mut Self {
        self.r#resp = value.into();
        self
    }
    ///Builder method that sets the value of `resp`. Useful for initializing the message.
    #[inline]
    pub fn init_resp(mut self, value: i32) -> Self {
        self.r#resp = value.into();
        self
    }
}
impl ::micropb::MessageDecode for Rpc_Resp_WifiClearFastConnect {
    fn decode<IMPL_MICROPB_READ: ::micropb::PbRead>(
        &mut self,
        decoder: &mut ::micropb::PbDecoder<IMPL_MICROPB_READ>,
        len: usize,
    ) -> Result<(), ::micropb::DecodeError<IMPL_MICROPB_READ::Error>> {
        use ::micropb::{FieldDecode, PbBytes, PbMap, PbString, PbVec};
        let before = decoder.bytes_read();
        while decoder.bytes_read() - before < len {
            let tag = decoder.decode_tag()?;
            match tag.field_num() {
                0 => return Err(::micropb::DecodeError::ZeroField),
                1u32 => {
                    let mut_ref = &mut self.r#resp;
                    {
                        let val = decoder.decode_int32()?;
                        let val_ref = &val;
                        if *val_ref != 0 {
                            *mut_ref = val as _;
                        }
                    };
                }
                _ => {
                    decoder.skip_wire_value(tag.wire_type())?;
                }
            }
        }
        Ok(())
    }
}
impl ::micropb::MessageEncode for Rpc_Resp_WifiClearFastConnect {
    const MAX_SIZE: ::core::option::Option<usize> = 'msg: {
        let mut max_size = 0;
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(10usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        ::core::option::Option::Some(max_size)
    };
    fn encode<IMPL_MICROPB_WRITE: ::micropb::PbWrite>(
        &self,
        encoder: &mut ::micropb::PbEncoder<IMPL_MICROPB_WRITE>,
    ) -> Result<(), IMPL_MICROPB_WRITE::Error> {
        use ::micropb::{FieldEncode, PbMap};
        {
            let val_ref = &self.r#resp;
            if *val_ref != 0 {
                encoder.encode_varint32(8u32)?;
                encoder.encode_int32(*val_ref as _)?;
            }
        }
        Ok(())
    }
    fn compute_size(&self) -> usize {
        use ::micropb::{FieldEncode, PbMap};
        let mut size = 0;
        {
            let val_ref = &self.r#resp;
            if *val_ref != 0 {
                size += 1usize + ::micropb::size::sizeof_int32(*val_ref as _);
            }
        }
        size
    }
}
#[derive(Debug, Default, PartialEq, Clone)]
pub struct Rpc_Req_WifiDeauthSta {
    pub r#aid: i32,
}
impl Rpc_Req_WifiDeauthSta {
    ///Return a reference to `aid`
    #[inline]
    pub fn r#aid(&self) -> &i32 {
        &self.r#aid
    }
    ///Return a mutable reference to `aid`
    #[inline]
    pub fn mut_aid(&mut self) -> &mut i32 {
        &mut self.r#aid
    }
    ///Set the value of `aid`
    #[inline]
    pub fn set_aid(&mut self, value: i32) -> &mut Self {
        self.r#aid = value.into();
        self
    }
    ///Builder method that sets the value of `aid`. Useful for initializing the message.
    #[inline]
    pub fn init_aid(mut self, value: i32) -> Self {
        self.r#aid = value.into();
        self
    }
}
impl ::micropb::MessageDecode for Rpc_Req_WifiDeauthSta {
    fn decode<IMPL_MICROPB_READ: ::micropb::PbRead>(
        &mut self,
        decoder: &mut ::micropb::PbDecoder<IMPL_MICROPB_READ>,
        len: usize,
    ) -> Result<(), ::micropb::DecodeError<IMPL_MICROPB_READ::Error>> {
        use ::micropb::{FieldDecode, PbBytes, PbMap, PbString, PbVec};
        let before = decoder.bytes_read();
        while decoder.bytes_read() - before < len {
            let tag = decoder.decode_tag()?;
            match tag.field_num() {
                0 => return Err(::micropb::DecodeError::ZeroField),
                1u32 => {
                    let mut_ref = &mut self.r#aid;
                    {
                        let val = decoder.decode_int32()?;
                        let val_ref = &val;
                        if *val_ref != 0 {
                            *mut_ref = val as _;
                        }
                    };
                }
                _ => {
                    decoder.skip_wire_value(tag.wire_type())?;
                }
            }
        }
        Ok(())
    }
}
impl ::micropb::MessageEncode for Rpc_Req_WifiDeauthSta {
    const MAX_SIZE: ::core::option::Option<usize> = 'msg: {
        let mut max_size = 0;
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(10usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        ::core::option::Option::Some(max_size)
    };
    fn encode<IMPL_MICROPB_WRITE: ::micropb::PbWrite>(
        &self,
        encoder: &mut ::micropb::PbEncoder<IMPL_MICROPB_WRITE>,
    ) -> Result<(), IMPL_MICROPB_WRITE::Error> {
        use ::micropb::{FieldEncode, PbMap};
        {
            let val_ref = &self.r#aid;
            if *val_ref != 0 {
                encoder.encode_varint32(8u32)?;
                encoder.encode_int32(*val_ref as _)?;
            }
        }
        Ok(())
    }
    fn compute_size(&self) -> usize {
        use ::micropb::{FieldEncode, PbMap};
        let mut size = 0;
        {
            let val_ref = &self.r#aid;
            if *val_ref != 0 {
                size += 1usize + ::micropb::size::sizeof_int32(*val_ref as _);
            }
        }
        size
    }
}
#[derive(Debug, Default, PartialEq, Clone)]
pub struct Rpc_Resp_WifiDeauthSta {
    pub r#resp: i32,
    pub r#aid: i32,
}
impl Rpc_Resp_WifiDeauthSta {
    ///Return a reference to `resp`
    #[inline]
    pub fn r#resp(&self) -> &i32 {
        &self.r#resp
    }
    ///Return a mutable reference to `resp`
    #[inline]
    pub fn mut_resp(&mut self) -> &mut i32 {
        &mut self.r#resp
    }
    ///Set the value of `resp`
    #[inline]
    pub fn set_resp(&mut self, value: i32) -> &mut Self {
        self.r#resp = value.into();
        self
    }
    ///Builder method that sets the value of `resp`. Useful for initializing the message.
    #[inline]
    pub fn init_resp(mut self, value: i32) -> Self {
        self.r#resp = value.into();
        self
    }
    ///Return a reference to `aid`
    #[inline]
    pub fn r#aid(&self) -> &i32 {
        &self.r#aid
    }
    ///Return a mutable reference to `aid`
    #[inline]
    pub fn mut_aid(&mut self) -> &mut i32 {
        &mut self.r#aid
    }
    ///Set the value of `aid`
    #[inline]
    pub fn set_aid(&mut self, value: i32) -> &mut Self {
        self.r#aid = value.into();
        self
    }
    ///Builder method that sets the value of `aid`. Useful for initializing the message.
    #[inline]
    pub fn init_aid(mut self, value: i32) -> Self {
        self.r#aid = value.into();
        self
    }
}
impl ::micropb::MessageDecode for Rpc_Resp_WifiDeauthSta {
    fn decode<IMPL_MICROPB_READ: ::micropb::PbRead>(
        &mut self,
        decoder: &mut ::micropb::PbDecoder<IMPL_MICROPB_READ>,
        len: usize,
    ) -> Result<(), ::micropb::DecodeError<IMPL_MICROPB_READ::Error>> {
        use ::micropb::{FieldDecode, PbBytes, PbMap, PbString, PbVec};
        let before = decoder.bytes_read();
        while decoder.bytes_read() - before < len {
            let tag = decoder.decode_tag()?;
            match tag.field_num() {
                0 => return Err(::micropb::DecodeError::ZeroField),
                1u32 => {
                    let mut_ref = &mut self.r#resp;
                    {
                        let val = decoder.decode_int32()?;
                        let val_ref = &val;
                        if *val_ref != 0 {
                            *mut_ref = val as _;
                        }
                    };
                }
                2u32 => {
                    let mut_ref = &mut self.r#aid;
                    {
                        let val = decoder.decode_int32()?;
                        let val_ref = &val;
                        if *val_ref != 0 {
                            *mut_ref = val as _;
                        }
                    };
                }
                _ => {
                    decoder.skip_wire_value(tag.wire_type())?;
                }
            }
        }
        Ok(())
    }
}
impl ::micropb::MessageEncode for Rpc_Resp_WifiDeauthSta {
    const MAX_SIZE: ::core::option::Option<usize> = 'msg: {
        let mut max_size = 0;
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(10usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(10usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        ::core::option::Option::Some(max_size)
    };
    fn encode<IMPL_MICROPB_WRITE: ::micropb::PbWrite>(
        &self,
        encoder: &mut ::micropb::PbEncoder<IMPL_MICROPB_WRITE>,
    ) -> Result<(), IMPL_MICROPB_WRITE::Error> {
        use ::micropb::{FieldEncode, PbMap};
        {
            let val_ref = &self.r#resp;
            if *val_ref != 0 {
                encoder.encode_varint32(8u32)?;
                encoder.encode_int32(*val_ref as _)?;
            }
        }
        {
            let val_ref = &self.r#aid;
            if *val_ref != 0 {
                encoder.encode_varint32(16u32)?;
                encoder.encode_int32(*val_ref as _)?;
            }
        }
        Ok(())
    }
    fn compute_size(&self) -> usize {
        use ::micropb::{FieldEncode, PbMap};
        let mut size = 0;
        {
            let val_ref = &self.r#resp;
            if *val_ref != 0 {
                size += 1usize + ::micropb::size::sizeof_int32(*val_ref as _);
            }
        }
        {
            let val_ref = &self.r#aid;
            if *val_ref != 0 {
                size += 1usize + ::micropb::size::sizeof_int32(*val_ref as _);
            }
        }
        size
    }
}
#[derive(Debug, Default, PartialEq, Clone)]
pub struct Rpc_Req_WifiStaGetApInfo {}
impl Rpc_Req_WifiStaGetApInfo {}
impl ::micropb::MessageDecode for Rpc_Req_WifiStaGetApInfo {
    fn decode<IMPL_MICROPB_READ: ::micropb::PbRead>(
        &mut self,
        decoder: &mut ::micropb::PbDecoder<IMPL_MICROPB_READ>,
        len: usize,
    ) -> Result<(), ::micropb::DecodeError<IMPL_MICROPB_READ::Error>> {
        use ::micropb::{FieldDecode, PbBytes, PbMap, PbString, PbVec};
        let before = decoder.bytes_read();
        while decoder.bytes_read() - before < len {
            let tag = decoder.decode_tag()?;
            match tag.field_num() {
                0 => return Err(::micropb::DecodeError::ZeroField),
                _ => {
                    decoder.skip_wire_value(tag.wire_type())?;
                }
            }
        }
        Ok(())
    }
}
impl ::micropb::MessageEncode for Rpc_Req_WifiStaGetApInfo {
    const MAX_SIZE: ::core::option::Option<usize> = 'msg: {
        let mut max_size = 0;
        ::core::option::Option::Some(max_size)
    };
    fn encode<IMPL_MICROPB_WRITE: ::micropb::PbWrite>(
        &self,
        encoder: &mut ::micropb::PbEncoder<IMPL_MICROPB_WRITE>,
    ) -> Result<(), IMPL_MICROPB_WRITE::Error> {
        use ::micropb::{FieldEncode, PbMap};
        Ok(())
    }
    fn compute_size(&self) -> usize {
        use ::micropb::{FieldEncode, PbMap};
        let mut size = 0;
        size
    }
}
pub mod Rpc_Resp_WifiStaGetApInfo_ {
    #[derive(Debug, Default, PartialEq, Clone)]
    pub struct _Hazzer([u8; 1]);
    impl _Hazzer {
        ///New hazzer with all fields set to off
        #[inline]
        pub const fn _new() -> Self {
            Self([0; 1])
        }
        ///Query presence of `ap_record`
        #[inline]
        pub const fn r#ap_record(&self) -> bool {
            (self.0[0] & 1) != 0
        }
        ///Set presence of `ap_record`
        #[inline]
        pub const fn set_ap_record(&mut self) -> &mut Self {
            let elem = &mut self.0[0];
            *elem |= 1;
            self
        }
        ///Clear presence of `ap_record`
        #[inline]
        pub const fn clear_ap_record(&mut self) -> &mut Self {
            let elem = &mut self.0[0];
            *elem &= !1;
            self
        }
        ///Builder method that sets the presence of `ap_record`. Useful for initializing the Hazzer.
        #[inline]
        pub const fn init_ap_record(mut self) -> Self {
            self.set_ap_record();
            self
        }
    }
}
#[derive(Debug, Default, Clone)]
pub struct Rpc_Resp_WifiStaGetApInfo {
    pub r#resp: i32,
    pub r#ap_record: r#wifi_ap_record,
    pub _has: Rpc_Resp_WifiStaGetApInfo_::_Hazzer,
}
impl ::core::cmp::PartialEq for Rpc_Resp_WifiStaGetApInfo {
    fn eq(&self, other: &Self) -> bool {
        let mut ret = true;
        ret &= (self.r#resp == other.r#resp);
        ret &= (self.r#ap_record() == other.r#ap_record());
        ret
    }
}
impl Rpc_Resp_WifiStaGetApInfo {
    ///Return a reference to `resp`
    #[inline]
    pub fn r#resp(&self) -> &i32 {
        &self.r#resp
    }
    ///Return a mutable reference to `resp`
    #[inline]
    pub fn mut_resp(&mut self) -> &mut i32 {
        &mut self.r#resp
    }
    ///Set the value of `resp`
    #[inline]
    pub fn set_resp(&mut self, value: i32) -> &mut Self {
        self.r#resp = value.into();
        self
    }
    ///Builder method that sets the value of `resp`. Useful for initializing the message.
    #[inline]
    pub fn init_resp(mut self, value: i32) -> Self {
        self.r#resp = value.into();
        self
    }
    ///Return a reference to `ap_record` as an `Option`
    #[inline]
    pub fn r#ap_record(&self) -> ::core::option::Option<&r#wifi_ap_record> {
        self._has.r#ap_record().then_some(&self.r#ap_record)
    }
    ///Set the value and presence of `ap_record`
    #[inline]
    pub fn set_ap_record(&mut self, value: r#wifi_ap_record) -> &mut Self {
        self._has.set_ap_record();
        self.r#ap_record = value.into();
        self
    }
    ///Return a mutable reference to `ap_record` as an `Option`
    #[inline]
    pub fn mut_ap_record(&mut self) -> ::core::option::Option<&mut r#wifi_ap_record> {
        self._has.r#ap_record().then_some(&mut self.r#ap_record)
    }
    ///Clear the presence of `ap_record`
    #[inline]
    pub fn clear_ap_record(&mut self) -> &mut Self {
        self._has.clear_ap_record();
        self
    }
    ///Take the value of `ap_record` and clear its presence
    #[inline]
    pub fn take_ap_record(&mut self) -> ::core::option::Option<r#wifi_ap_record> {
        let val = self
            ._has
            .r#ap_record()
            .then(|| ::core::mem::take(&mut self.r#ap_record));
        self._has.clear_ap_record();
        val
    }
    ///Builder method that sets the value of `ap_record`. Useful for initializing the message.
    #[inline]
    pub fn init_ap_record(mut self, value: r#wifi_ap_record) -> Self {
        self.set_ap_record(value);
        self
    }
}
impl ::micropb::MessageDecode for Rpc_Resp_WifiStaGetApInfo {
    fn decode<IMPL_MICROPB_READ: ::micropb::PbRead>(
        &mut self,
        decoder: &mut ::micropb::PbDecoder<IMPL_MICROPB_READ>,
        len: usize,
    ) -> Result<(), ::micropb::DecodeError<IMPL_MICROPB_READ::Error>> {
        use ::micropb::{FieldDecode, PbBytes, PbMap, PbString, PbVec};
        let before = decoder.bytes_read();
        while decoder.bytes_read() - before < len {
            let tag = decoder.decode_tag()?;
            match tag.field_num() {
                0 => return Err(::micropb::DecodeError::ZeroField),
                1u32 => {
                    let mut_ref = &mut self.r#resp;
                    {
                        let val = decoder.decode_int32()?;
                        let val_ref = &val;
                        if *val_ref != 0 {
                            *mut_ref = val as _;
                        }
                    };
                }
                2u32 => {
                    let mut_ref = &mut self.r#ap_record;
                    {
                        mut_ref.decode_len_delimited(decoder)?;
                    };
                    self._has.set_ap_record();
                }
                _ => {
                    decoder.skip_wire_value(tag.wire_type())?;
                }
            }
        }
        Ok(())
    }
}
impl ::micropb::MessageEncode for Rpc_Resp_WifiStaGetApInfo {
    const MAX_SIZE: ::core::option::Option<usize> = 'msg: {
        let mut max_size = 0;
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(10usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        if let ::core::option::Option::Some(size) = ::micropb::const_map!(
            ::micropb::const_map!(
                <r#wifi_ap_record as ::micropb::MessageEncode>::MAX_SIZE,
                |size| ::micropb::size::sizeof_len_record(size)
            ),
            |size| size + 1usize
        ) {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        ::core::option::Option::Some(max_size)
    };
    fn encode<IMPL_MICROPB_WRITE: ::micropb::PbWrite>(
        &self,
        encoder: &mut ::micropb::PbEncoder<IMPL_MICROPB_WRITE>,
    ) -> Result<(), IMPL_MICROPB_WRITE::Error> {
        use ::micropb::{FieldEncode, PbMap};
        {
            let val_ref = &self.r#resp;
            if *val_ref != 0 {
                encoder.encode_varint32(8u32)?;
                encoder.encode_int32(*val_ref as _)?;
            }
        }
        {
            if let ::core::option::Option::Some(val_ref) = self.r#ap_record() {
                encoder.encode_varint32(18u32)?;
                val_ref.encode_len_delimited(encoder)?;
            }
        }
        Ok(())
    }
    fn compute_size(&self) -> usize {
        use ::micropb::{FieldEncode, PbMap};
        let mut size = 0;
        {
            let val_ref = &self.r#resp;
            if *val_ref != 0 {
                size += 1usize + ::micropb::size::sizeof_int32(*val_ref as _);
            }
        }
        {
            if let ::core::option::Option::Some(val_ref) = self.r#ap_record() {
                size += 1usize + ::micropb::size::sizeof_len_record(val_ref.compute_size());
            }
        }
        size
    }
}
#[derive(Debug, Default, PartialEq, Clone)]
pub struct Rpc_Req_WifiSetProtocol {
    pub r#ifx: i32,
    pub r#protocol_bitmap: i32,
}
impl Rpc_Req_WifiSetProtocol {
    ///Return a reference to `ifx`
    #[inline]
    pub fn r#ifx(&self) -> &i32 {
        &self.r#ifx
    }
    ///Return a mutable reference to `ifx`
    #[inline]
    pub fn mut_ifx(&mut self) -> &mut i32 {
        &mut self.r#ifx
    }
    ///Set the value of `ifx`
    #[inline]
    pub fn set_ifx(&mut self, value: i32) -> &mut Self {
        self.r#ifx = value.into();
        self
    }
    ///Builder method that sets the value of `ifx`. Useful for initializing the message.
    #[inline]
    pub fn init_ifx(mut self, value: i32) -> Self {
        self.r#ifx = value.into();
        self
    }
    ///Return a reference to `protocol_bitmap`
    #[inline]
    pub fn r#protocol_bitmap(&self) -> &i32 {
        &self.r#protocol_bitmap
    }
    ///Return a mutable reference to `protocol_bitmap`
    #[inline]
    pub fn mut_protocol_bitmap(&mut self) -> &mut i32 {
        &mut self.r#protocol_bitmap
    }
    ///Set the value of `protocol_bitmap`
    #[inline]
    pub fn set_protocol_bitmap(&mut self, value: i32) -> &mut Self {
        self.r#protocol_bitmap = value.into();
        self
    }
    ///Builder method that sets the value of `protocol_bitmap`. Useful for initializing the message.
    #[inline]
    pub fn init_protocol_bitmap(mut self, value: i32) -> Self {
        self.r#protocol_bitmap = value.into();
        self
    }
}
impl ::micropb::MessageDecode for Rpc_Req_WifiSetProtocol {
    fn decode<IMPL_MICROPB_READ: ::micropb::PbRead>(
        &mut self,
        decoder: &mut ::micropb::PbDecoder<IMPL_MICROPB_READ>,
        len: usize,
    ) -> Result<(), ::micropb::DecodeError<IMPL_MICROPB_READ::Error>> {
        use ::micropb::{FieldDecode, PbBytes, PbMap, PbString, PbVec};
        let before = decoder.bytes_read();
        while decoder.bytes_read() - before < len {
            let tag = decoder.decode_tag()?;
            match tag.field_num() {
                0 => return Err(::micropb::DecodeError::ZeroField),
                1u32 => {
                    let mut_ref = &mut self.r#ifx;
                    {
                        let val = decoder.decode_int32()?;
                        let val_ref = &val;
                        if *val_ref != 0 {
                            *mut_ref = val as _;
                        }
                    };
                }
                2u32 => {
                    let mut_ref = &mut self.r#protocol_bitmap;
                    {
                        let val = decoder.decode_int32()?;
                        let val_ref = &val;
                        if *val_ref != 0 {
                            *mut_ref = val as _;
                        }
                    };
                }
                _ => {
                    decoder.skip_wire_value(tag.wire_type())?;
                }
            }
        }
        Ok(())
    }
}
impl ::micropb::MessageEncode for Rpc_Req_WifiSetProtocol {
    const MAX_SIZE: ::core::option::Option<usize> = 'msg: {
        let mut max_size = 0;
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(10usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(10usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        ::core::option::Option::Some(max_size)
    };
    fn encode<IMPL_MICROPB_WRITE: ::micropb::PbWrite>(
        &self,
        encoder: &mut ::micropb::PbEncoder<IMPL_MICROPB_WRITE>,
    ) -> Result<(), IMPL_MICROPB_WRITE::Error> {
        use ::micropb::{FieldEncode, PbMap};
        {
            let val_ref = &self.r#ifx;
            if *val_ref != 0 {
                encoder.encode_varint32(8u32)?;
                encoder.encode_int32(*val_ref as _)?;
            }
        }
        {
            let val_ref = &self.r#protocol_bitmap;
            if *val_ref != 0 {
                encoder.encode_varint32(16u32)?;
                encoder.encode_int32(*val_ref as _)?;
            }
        }
        Ok(())
    }
    fn compute_size(&self) -> usize {
        use ::micropb::{FieldEncode, PbMap};
        let mut size = 0;
        {
            let val_ref = &self.r#ifx;
            if *val_ref != 0 {
                size += 1usize + ::micropb::size::sizeof_int32(*val_ref as _);
            }
        }
        {
            let val_ref = &self.r#protocol_bitmap;
            if *val_ref != 0 {
                size += 1usize + ::micropb::size::sizeof_int32(*val_ref as _);
            }
        }
        size
    }
}
#[derive(Debug, Default, PartialEq, Clone)]
pub struct Rpc_Resp_WifiSetProtocol {
    pub r#resp: i32,
}
impl Rpc_Resp_WifiSetProtocol {
    ///Return a reference to `resp`
    #[inline]
    pub fn r#resp(&self) -> &i32 {
        &self.r#resp
    }
    ///Return a mutable reference to `resp`
    #[inline]
    pub fn mut_resp(&mut self) -> &mut i32 {
        &mut self.r#resp
    }
    ///Set the value of `resp`
    #[inline]
    pub fn set_resp(&mut self, value: i32) -> &mut Self {
        self.r#resp = value.into();
        self
    }
    ///Builder method that sets the value of `resp`. Useful for initializing the message.
    #[inline]
    pub fn init_resp(mut self, value: i32) -> Self {
        self.r#resp = value.into();
        self
    }
}
impl ::micropb::MessageDecode for Rpc_Resp_WifiSetProtocol {
    fn decode<IMPL_MICROPB_READ: ::micropb::PbRead>(
        &mut self,
        decoder: &mut ::micropb::PbDecoder<IMPL_MICROPB_READ>,
        len: usize,
    ) -> Result<(), ::micropb::DecodeError<IMPL_MICROPB_READ::Error>> {
        use ::micropb::{FieldDecode, PbBytes, PbMap, PbString, PbVec};
        let before = decoder.bytes_read();
        while decoder.bytes_read() - before < len {
            let tag = decoder.decode_tag()?;
            match tag.field_num() {
                0 => return Err(::micropb::DecodeError::ZeroField),
                1u32 => {
                    let mut_ref = &mut self.r#resp;
                    {
                        let val = decoder.decode_int32()?;
                        let val_ref = &val;
                        if *val_ref != 0 {
                            *mut_ref = val as _;
                        }
                    };
                }
                _ => {
                    decoder.skip_wire_value(tag.wire_type())?;
                }
            }
        }
        Ok(())
    }
}
impl ::micropb::MessageEncode for Rpc_Resp_WifiSetProtocol {
    const MAX_SIZE: ::core::option::Option<usize> = 'msg: {
        let mut max_size = 0;
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(10usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        ::core::option::Option::Some(max_size)
    };
    fn encode<IMPL_MICROPB_WRITE: ::micropb::PbWrite>(
        &self,
        encoder: &mut ::micropb::PbEncoder<IMPL_MICROPB_WRITE>,
    ) -> Result<(), IMPL_MICROPB_WRITE::Error> {
        use ::micropb::{FieldEncode, PbMap};
        {
            let val_ref = &self.r#resp;
            if *val_ref != 0 {
                encoder.encode_varint32(8u32)?;
                encoder.encode_int32(*val_ref as _)?;
            }
        }
        Ok(())
    }
    fn compute_size(&self) -> usize {
        use ::micropb::{FieldEncode, PbMap};
        let mut size = 0;
        {
            let val_ref = &self.r#resp;
            if *val_ref != 0 {
                size += 1usize + ::micropb::size::sizeof_int32(*val_ref as _);
            }
        }
        size
    }
}
#[derive(Debug, Default, PartialEq, Clone)]
pub struct Rpc_Req_WifiGetProtocol {
    pub r#ifx: i32,
}
impl Rpc_Req_WifiGetProtocol {
    ///Return a reference to `ifx`
    #[inline]
    pub fn r#ifx(&self) -> &i32 {
        &self.r#ifx
    }
    ///Return a mutable reference to `ifx`
    #[inline]
    pub fn mut_ifx(&mut self) -> &mut i32 {
        &mut self.r#ifx
    }
    ///Set the value of `ifx`
    #[inline]
    pub fn set_ifx(&mut self, value: i32) -> &mut Self {
        self.r#ifx = value.into();
        self
    }
    ///Builder method that sets the value of `ifx`. Useful for initializing the message.
    #[inline]
    pub fn init_ifx(mut self, value: i32) -> Self {
        self.r#ifx = value.into();
        self
    }
}
impl ::micropb::MessageDecode for Rpc_Req_WifiGetProtocol {
    fn decode<IMPL_MICROPB_READ: ::micropb::PbRead>(
        &mut self,
        decoder: &mut ::micropb::PbDecoder<IMPL_MICROPB_READ>,
        len: usize,
    ) -> Result<(), ::micropb::DecodeError<IMPL_MICROPB_READ::Error>> {
        use ::micropb::{FieldDecode, PbBytes, PbMap, PbString, PbVec};
        let before = decoder.bytes_read();
        while decoder.bytes_read() - before < len {
            let tag = decoder.decode_tag()?;
            match tag.field_num() {
                0 => return Err(::micropb::DecodeError::ZeroField),
                1u32 => {
                    let mut_ref = &mut self.r#ifx;
                    {
                        let val = decoder.decode_int32()?;
                        let val_ref = &val;
                        if *val_ref != 0 {
                            *mut_ref = val as _;
                        }
                    };
                }
                _ => {
                    decoder.skip_wire_value(tag.wire_type())?;
                }
            }
        }
        Ok(())
    }
}
impl ::micropb::MessageEncode for Rpc_Req_WifiGetProtocol {
    const MAX_SIZE: ::core::option::Option<usize> = 'msg: {
        let mut max_size = 0;
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(10usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        ::core::option::Option::Some(max_size)
    };
    fn encode<IMPL_MICROPB_WRITE: ::micropb::PbWrite>(
        &self,
        encoder: &mut ::micropb::PbEncoder<IMPL_MICROPB_WRITE>,
    ) -> Result<(), IMPL_MICROPB_WRITE::Error> {
        use ::micropb::{FieldEncode, PbMap};
        {
            let val_ref = &self.r#ifx;
            if *val_ref != 0 {
                encoder.encode_varint32(8u32)?;
                encoder.encode_int32(*val_ref as _)?;
            }
        }
        Ok(())
    }
    fn compute_size(&self) -> usize {
        use ::micropb::{FieldEncode, PbMap};
        let mut size = 0;
        {
            let val_ref = &self.r#ifx;
            if *val_ref != 0 {
                size += 1usize + ::micropb::size::sizeof_int32(*val_ref as _);
            }
        }
        size
    }
}
#[derive(Debug, Default, PartialEq, Clone)]
pub struct Rpc_Resp_WifiGetProtocol {
    pub r#resp: i32,
    pub r#protocol_bitmap: i32,
}
impl Rpc_Resp_WifiGetProtocol {
    ///Return a reference to `resp`
    #[inline]
    pub fn r#resp(&self) -> &i32 {
        &self.r#resp
    }
    ///Return a mutable reference to `resp`
    #[inline]
    pub fn mut_resp(&mut self) -> &mut i32 {
        &mut self.r#resp
    }
    ///Set the value of `resp`
    #[inline]
    pub fn set_resp(&mut self, value: i32) -> &mut Self {
        self.r#resp = value.into();
        self
    }
    ///Builder method that sets the value of `resp`. Useful for initializing the message.
    #[inline]
    pub fn init_resp(mut self, value: i32) -> Self {
        self.r#resp = value.into();
        self
    }
    ///Return a reference to `protocol_bitmap`
    #[inline]
    pub fn r#protocol_bitmap(&self) -> &i32 {
        &self.r#protocol_bitmap
    }
    ///Return a mutable reference to `protocol_bitmap`
    #[inline]
    pub fn mut_protocol_bitmap(&mut self) -> &mut i32 {
        &mut self.r#protocol_bitmap
    }
    ///Set the value of `protocol_bitmap`
    #[inline]
    pub fn set_protocol_bitmap(&mut self, value: i32) -> &mut Self {
        self.r#protocol_bitmap = value.into();
        self
    }
    ///Builder method that sets the value of `protocol_bitmap`. Useful for initializing the message.
    #[inline]
    pub fn init_protocol_bitmap(mut self, value: i32) -> Self {
        self.r#protocol_bitmap = value.into();
        self
    }
}
impl ::micropb::MessageDecode for Rpc_Resp_WifiGetProtocol {
    fn decode<IMPL_MICROPB_READ: ::micropb::PbRead>(
        &mut self,
        decoder: &mut ::micropb::PbDecoder<IMPL_MICROPB_READ>,
        len: usize,
    ) -> Result<(), ::micropb::DecodeError<IMPL_MICROPB_READ::Error>> {
        use ::micropb::{FieldDecode, PbBytes, PbMap, PbString, PbVec};
        let before = decoder.bytes_read();
        while decoder.bytes_read() - before < len {
            let tag = decoder.decode_tag()?;
            match tag.field_num() {
                0 => return Err(::micropb::DecodeError::ZeroField),
                1u32 => {
                    let mut_ref = &mut self.r#resp;
                    {
                        let val = decoder.decode_int32()?;
                        let val_ref = &val;
                        if *val_ref != 0 {
                            *mut_ref = val as _;
                        }
                    };
                }
                2u32 => {
                    let mut_ref = &mut self.r#protocol_bitmap;
                    {
                        let val = decoder.decode_int32()?;
                        let val_ref = &val;
                        if *val_ref != 0 {
                            *mut_ref = val as _;
                        }
                    };
                }
                _ => {
                    decoder.skip_wire_value(tag.wire_type())?;
                }
            }
        }
        Ok(())
    }
}
impl ::micropb::MessageEncode for Rpc_Resp_WifiGetProtocol {
    const MAX_SIZE: ::core::option::Option<usize> = 'msg: {
        let mut max_size = 0;
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(10usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(10usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        ::core::option::Option::Some(max_size)
    };
    fn encode<IMPL_MICROPB_WRITE: ::micropb::PbWrite>(
        &self,
        encoder: &mut ::micropb::PbEncoder<IMPL_MICROPB_WRITE>,
    ) -> Result<(), IMPL_MICROPB_WRITE::Error> {
        use ::micropb::{FieldEncode, PbMap};
        {
            let val_ref = &self.r#resp;
            if *val_ref != 0 {
                encoder.encode_varint32(8u32)?;
                encoder.encode_int32(*val_ref as _)?;
            }
        }
        {
            let val_ref = &self.r#protocol_bitmap;
            if *val_ref != 0 {
                encoder.encode_varint32(16u32)?;
                encoder.encode_int32(*val_ref as _)?;
            }
        }
        Ok(())
    }
    fn compute_size(&self) -> usize {
        use ::micropb::{FieldEncode, PbMap};
        let mut size = 0;
        {
            let val_ref = &self.r#resp;
            if *val_ref != 0 {
                size += 1usize + ::micropb::size::sizeof_int32(*val_ref as _);
            }
        }
        {
            let val_ref = &self.r#protocol_bitmap;
            if *val_ref != 0 {
                size += 1usize + ::micropb::size::sizeof_int32(*val_ref as _);
            }
        }
        size
    }
}
#[derive(Debug, Default, PartialEq, Clone)]
pub struct Rpc_Req_WifiSetBandwidth {
    pub r#ifx: i32,
    pub r#bw: i32,
}
impl Rpc_Req_WifiSetBandwidth {
    ///Return a reference to `ifx`
    #[inline]
    pub fn r#ifx(&self) -> &i32 {
        &self.r#ifx
    }
    ///Return a mutable reference to `ifx`
    #[inline]
    pub fn mut_ifx(&mut self) -> &mut i32 {
        &mut self.r#ifx
    }
    ///Set the value of `ifx`
    #[inline]
    pub fn set_ifx(&mut self, value: i32) -> &mut Self {
        self.r#ifx = value.into();
        self
    }
    ///Builder method that sets the value of `ifx`. Useful for initializing the message.
    #[inline]
    pub fn init_ifx(mut self, value: i32) -> Self {
        self.r#ifx = value.into();
        self
    }
    ///Return a reference to `bw`
    #[inline]
    pub fn r#bw(&self) -> &i32 {
        &self.r#bw
    }
    ///Return a mutable reference to `bw`
    #[inline]
    pub fn mut_bw(&mut self) -> &mut i32 {
        &mut self.r#bw
    }
    ///Set the value of `bw`
    #[inline]
    pub fn set_bw(&mut self, value: i32) -> &mut Self {
        self.r#bw = value.into();
        self
    }
    ///Builder method that sets the value of `bw`. Useful for initializing the message.
    #[inline]
    pub fn init_bw(mut self, value: i32) -> Self {
        self.r#bw = value.into();
        self
    }
}
impl ::micropb::MessageDecode for Rpc_Req_WifiSetBandwidth {
    fn decode<IMPL_MICROPB_READ: ::micropb::PbRead>(
        &mut self,
        decoder: &mut ::micropb::PbDecoder<IMPL_MICROPB_READ>,
        len: usize,
    ) -> Result<(), ::micropb::DecodeError<IMPL_MICROPB_READ::Error>> {
        use ::micropb::{FieldDecode, PbBytes, PbMap, PbString, PbVec};
        let before = decoder.bytes_read();
        while decoder.bytes_read() - before < len {
            let tag = decoder.decode_tag()?;
            match tag.field_num() {
                0 => return Err(::micropb::DecodeError::ZeroField),
                1u32 => {
                    let mut_ref = &mut self.r#ifx;
                    {
                        let val = decoder.decode_int32()?;
                        let val_ref = &val;
                        if *val_ref != 0 {
                            *mut_ref = val as _;
                        }
                    };
                }
                2u32 => {
                    let mut_ref = &mut self.r#bw;
                    {
                        let val = decoder.decode_int32()?;
                        let val_ref = &val;
                        if *val_ref != 0 {
                            *mut_ref = val as _;
                        }
                    };
                }
                _ => {
                    decoder.skip_wire_value(tag.wire_type())?;
                }
            }
        }
        Ok(())
    }
}
impl ::micropb::MessageEncode for Rpc_Req_WifiSetBandwidth {
    const MAX_SIZE: ::core::option::Option<usize> = 'msg: {
        let mut max_size = 0;
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(10usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(10usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        ::core::option::Option::Some(max_size)
    };
    fn encode<IMPL_MICROPB_WRITE: ::micropb::PbWrite>(
        &self,
        encoder: &mut ::micropb::PbEncoder<IMPL_MICROPB_WRITE>,
    ) -> Result<(), IMPL_MICROPB_WRITE::Error> {
        use ::micropb::{FieldEncode, PbMap};
        {
            let val_ref = &self.r#ifx;
            if *val_ref != 0 {
                encoder.encode_varint32(8u32)?;
                encoder.encode_int32(*val_ref as _)?;
            }
        }
        {
            let val_ref = &self.r#bw;
            if *val_ref != 0 {
                encoder.encode_varint32(16u32)?;
                encoder.encode_int32(*val_ref as _)?;
            }
        }
        Ok(())
    }
    fn compute_size(&self) -> usize {
        use ::micropb::{FieldEncode, PbMap};
        let mut size = 0;
        {
            let val_ref = &self.r#ifx;
            if *val_ref != 0 {
                size += 1usize + ::micropb::size::sizeof_int32(*val_ref as _);
            }
        }
        {
            let val_ref = &self.r#bw;
            if *val_ref != 0 {
                size += 1usize + ::micropb::size::sizeof_int32(*val_ref as _);
            }
        }
        size
    }
}
#[derive(Debug, Default, PartialEq, Clone)]
pub struct Rpc_Resp_WifiSetBandwidth {
    pub r#resp: i32,
}
impl Rpc_Resp_WifiSetBandwidth {
    ///Return a reference to `resp`
    #[inline]
    pub fn r#resp(&self) -> &i32 {
        &self.r#resp
    }
    ///Return a mutable reference to `resp`
    #[inline]
    pub fn mut_resp(&mut self) -> &mut i32 {
        &mut self.r#resp
    }
    ///Set the value of `resp`
    #[inline]
    pub fn set_resp(&mut self, value: i32) -> &mut Self {
        self.r#resp = value.into();
        self
    }
    ///Builder method that sets the value of `resp`. Useful for initializing the message.
    #[inline]
    pub fn init_resp(mut self, value: i32) -> Self {
        self.r#resp = value.into();
        self
    }
}
impl ::micropb::MessageDecode for Rpc_Resp_WifiSetBandwidth {
    fn decode<IMPL_MICROPB_READ: ::micropb::PbRead>(
        &mut self,
        decoder: &mut ::micropb::PbDecoder<IMPL_MICROPB_READ>,
        len: usize,
    ) -> Result<(), ::micropb::DecodeError<IMPL_MICROPB_READ::Error>> {
        use ::micropb::{FieldDecode, PbBytes, PbMap, PbString, PbVec};
        let before = decoder.bytes_read();
        while decoder.bytes_read() - before < len {
            let tag = decoder.decode_tag()?;
            match tag.field_num() {
                0 => return Err(::micropb::DecodeError::ZeroField),
                1u32 => {
                    let mut_ref = &mut self.r#resp;
                    {
                        let val = decoder.decode_int32()?;
                        let val_ref = &val;
                        if *val_ref != 0 {
                            *mut_ref = val as _;
                        }
                    };
                }
                _ => {
                    decoder.skip_wire_value(tag.wire_type())?;
                }
            }
        }
        Ok(())
    }
}
impl ::micropb::MessageEncode for Rpc_Resp_WifiSetBandwidth {
    const MAX_SIZE: ::core::option::Option<usize> = 'msg: {
        let mut max_size = 0;
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(10usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        ::core::option::Option::Some(max_size)
    };
    fn encode<IMPL_MICROPB_WRITE: ::micropb::PbWrite>(
        &self,
        encoder: &mut ::micropb::PbEncoder<IMPL_MICROPB_WRITE>,
    ) -> Result<(), IMPL_MICROPB_WRITE::Error> {
        use ::micropb::{FieldEncode, PbMap};
        {
            let val_ref = &self.r#resp;
            if *val_ref != 0 {
                encoder.encode_varint32(8u32)?;
                encoder.encode_int32(*val_ref as _)?;
            }
        }
        Ok(())
    }
    fn compute_size(&self) -> usize {
        use ::micropb::{FieldEncode, PbMap};
        let mut size = 0;
        {
            let val_ref = &self.r#resp;
            if *val_ref != 0 {
                size += 1usize + ::micropb::size::sizeof_int32(*val_ref as _);
            }
        }
        size
    }
}
#[derive(Debug, Default, PartialEq, Clone)]
pub struct Rpc_Req_WifiGetBandwidth {
    pub r#ifx: i32,
}
impl Rpc_Req_WifiGetBandwidth {
    ///Return a reference to `ifx`
    #[inline]
    pub fn r#ifx(&self) -> &i32 {
        &self.r#ifx
    }
    ///Return a mutable reference to `ifx`
    #[inline]
    pub fn mut_ifx(&mut self) -> &mut i32 {
        &mut self.r#ifx
    }
    ///Set the value of `ifx`
    #[inline]
    pub fn set_ifx(&mut self, value: i32) -> &mut Self {
        self.r#ifx = value.into();
        self
    }
    ///Builder method that sets the value of `ifx`. Useful for initializing the message.
    #[inline]
    pub fn init_ifx(mut self, value: i32) -> Self {
        self.r#ifx = value.into();
        self
    }
}
impl ::micropb::MessageDecode for Rpc_Req_WifiGetBandwidth {
    fn decode<IMPL_MICROPB_READ: ::micropb::PbRead>(
        &mut self,
        decoder: &mut ::micropb::PbDecoder<IMPL_MICROPB_READ>,
        len: usize,
    ) -> Result<(), ::micropb::DecodeError<IMPL_MICROPB_READ::Error>> {
        use ::micropb::{FieldDecode, PbBytes, PbMap, PbString, PbVec};
        let before = decoder.bytes_read();
        while decoder.bytes_read() - before < len {
            let tag = decoder.decode_tag()?;
            match tag.field_num() {
                0 => return Err(::micropb::DecodeError::ZeroField),
                1u32 => {
                    let mut_ref = &mut self.r#ifx;
                    {
                        let val = decoder.decode_int32()?;
                        let val_ref = &val;
                        if *val_ref != 0 {
                            *mut_ref = val as _;
                        }
                    };
                }
                _ => {
                    decoder.skip_wire_value(tag.wire_type())?;
                }
            }
        }
        Ok(())
    }
}
impl ::micropb::MessageEncode for Rpc_Req_WifiGetBandwidth {
    const MAX_SIZE: ::core::option::Option<usize> = 'msg: {
        let mut max_size = 0;
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(10usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        ::core::option::Option::Some(max_size)
    };
    fn encode<IMPL_MICROPB_WRITE: ::micropb::PbWrite>(
        &self,
        encoder: &mut ::micropb::PbEncoder<IMPL_MICROPB_WRITE>,
    ) -> Result<(), IMPL_MICROPB_WRITE::Error> {
        use ::micropb::{FieldEncode, PbMap};
        {
            let val_ref = &self.r#ifx;
            if *val_ref != 0 {
                encoder.encode_varint32(8u32)?;
                encoder.encode_int32(*val_ref as _)?;
            }
        }
        Ok(())
    }
    fn compute_size(&self) -> usize {
        use ::micropb::{FieldEncode, PbMap};
        let mut size = 0;
        {
            let val_ref = &self.r#ifx;
            if *val_ref != 0 {
                size += 1usize + ::micropb::size::sizeof_int32(*val_ref as _);
            }
        }
        size
    }
}
#[derive(Debug, Default, PartialEq, Clone)]
pub struct Rpc_Resp_WifiGetBandwidth {
    pub r#resp: i32,
    pub r#bw: i32,
}
impl Rpc_Resp_WifiGetBandwidth {
    ///Return a reference to `resp`
    #[inline]
    pub fn r#resp(&self) -> &i32 {
        &self.r#resp
    }
    ///Return a mutable reference to `resp`
    #[inline]
    pub fn mut_resp(&mut self) -> &mut i32 {
        &mut self.r#resp
    }
    ///Set the value of `resp`
    #[inline]
    pub fn set_resp(&mut self, value: i32) -> &mut Self {
        self.r#resp = value.into();
        self
    }
    ///Builder method that sets the value of `resp`. Useful for initializing the message.
    #[inline]
    pub fn init_resp(mut self, value: i32) -> Self {
        self.r#resp = value.into();
        self
    }
    ///Return a reference to `bw`
    #[inline]
    pub fn r#bw(&self) -> &i32 {
        &self.r#bw
    }
    ///Return a mutable reference to `bw`
    #[inline]
    pub fn mut_bw(&mut self) -> &mut i32 {
        &mut self.r#bw
    }
    ///Set the value of `bw`
    #[inline]
    pub fn set_bw(&mut self, value: i32) -> &mut Self {
        self.r#bw = value.into();
        self
    }
    ///Builder method that sets the value of `bw`. Useful for initializing the message.
    #[inline]
    pub fn init_bw(mut self, value: i32) -> Self {
        self.r#bw = value.into();
        self
    }
}
impl ::micropb::MessageDecode for Rpc_Resp_WifiGetBandwidth {
    fn decode<IMPL_MICROPB_READ: ::micropb::PbRead>(
        &mut self,
        decoder: &mut ::micropb::PbDecoder<IMPL_MICROPB_READ>,
        len: usize,
    ) -> Result<(), ::micropb::DecodeError<IMPL_MICROPB_READ::Error>> {
        use ::micropb::{FieldDecode, PbBytes, PbMap, PbString, PbVec};
        let before = decoder.bytes_read();
        while decoder.bytes_read() - before < len {
            let tag = decoder.decode_tag()?;
            match tag.field_num() {
                0 => return Err(::micropb::DecodeError::ZeroField),
                1u32 => {
                    let mut_ref = &mut self.r#resp;
                    {
                        let val = decoder.decode_int32()?;
                        let val_ref = &val;
                        if *val_ref != 0 {
                            *mut_ref = val as _;
                        }
                    };
                }
                2u32 => {
                    let mut_ref = &mut self.r#bw;
                    {
                        let val = decoder.decode_int32()?;
                        let val_ref = &val;
                        if *val_ref != 0 {
                            *mut_ref = val as _;
                        }
                    };
                }
                _ => {
                    decoder.skip_wire_value(tag.wire_type())?;
                }
            }
        }
        Ok(())
    }
}
impl ::micropb::MessageEncode for Rpc_Resp_WifiGetBandwidth {
    const MAX_SIZE: ::core::option::Option<usize> = 'msg: {
        let mut max_size = 0;
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(10usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(10usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        ::core::option::Option::Some(max_size)
    };
    fn encode<IMPL_MICROPB_WRITE: ::micropb::PbWrite>(
        &self,
        encoder: &mut ::micropb::PbEncoder<IMPL_MICROPB_WRITE>,
    ) -> Result<(), IMPL_MICROPB_WRITE::Error> {
        use ::micropb::{FieldEncode, PbMap};
        {
            let val_ref = &self.r#resp;
            if *val_ref != 0 {
                encoder.encode_varint32(8u32)?;
                encoder.encode_int32(*val_ref as _)?;
            }
        }
        {
            let val_ref = &self.r#bw;
            if *val_ref != 0 {
                encoder.encode_varint32(16u32)?;
                encoder.encode_int32(*val_ref as _)?;
            }
        }
        Ok(())
    }
    fn compute_size(&self) -> usize {
        use ::micropb::{FieldEncode, PbMap};
        let mut size = 0;
        {
            let val_ref = &self.r#resp;
            if *val_ref != 0 {
                size += 1usize + ::micropb::size::sizeof_int32(*val_ref as _);
            }
        }
        {
            let val_ref = &self.r#bw;
            if *val_ref != 0 {
                size += 1usize + ::micropb::size::sizeof_int32(*val_ref as _);
            }
        }
        size
    }
}
#[derive(Debug, Default, PartialEq, Clone)]
pub struct Rpc_Req_WifiSetChannel {
    pub r#primary: i32,
    pub r#second: i32,
}
impl Rpc_Req_WifiSetChannel {
    ///Return a reference to `primary`
    #[inline]
    pub fn r#primary(&self) -> &i32 {
        &self.r#primary
    }
    ///Return a mutable reference to `primary`
    #[inline]
    pub fn mut_primary(&mut self) -> &mut i32 {
        &mut self.r#primary
    }
    ///Set the value of `primary`
    #[inline]
    pub fn set_primary(&mut self, value: i32) -> &mut Self {
        self.r#primary = value.into();
        self
    }
    ///Builder method that sets the value of `primary`. Useful for initializing the message.
    #[inline]
    pub fn init_primary(mut self, value: i32) -> Self {
        self.r#primary = value.into();
        self
    }
    ///Return a reference to `second`
    #[inline]
    pub fn r#second(&self) -> &i32 {
        &self.r#second
    }
    ///Return a mutable reference to `second`
    #[inline]
    pub fn mut_second(&mut self) -> &mut i32 {
        &mut self.r#second
    }
    ///Set the value of `second`
    #[inline]
    pub fn set_second(&mut self, value: i32) -> &mut Self {
        self.r#second = value.into();
        self
    }
    ///Builder method that sets the value of `second`. Useful for initializing the message.
    #[inline]
    pub fn init_second(mut self, value: i32) -> Self {
        self.r#second = value.into();
        self
    }
}
impl ::micropb::MessageDecode for Rpc_Req_WifiSetChannel {
    fn decode<IMPL_MICROPB_READ: ::micropb::PbRead>(
        &mut self,
        decoder: &mut ::micropb::PbDecoder<IMPL_MICROPB_READ>,
        len: usize,
    ) -> Result<(), ::micropb::DecodeError<IMPL_MICROPB_READ::Error>> {
        use ::micropb::{FieldDecode, PbBytes, PbMap, PbString, PbVec};
        let before = decoder.bytes_read();
        while decoder.bytes_read() - before < len {
            let tag = decoder.decode_tag()?;
            match tag.field_num() {
                0 => return Err(::micropb::DecodeError::ZeroField),
                1u32 => {
                    let mut_ref = &mut self.r#primary;
                    {
                        let val = decoder.decode_int32()?;
                        let val_ref = &val;
                        if *val_ref != 0 {
                            *mut_ref = val as _;
                        }
                    };
                }
                2u32 => {
                    let mut_ref = &mut self.r#second;
                    {
                        let val = decoder.decode_int32()?;
                        let val_ref = &val;
                        if *val_ref != 0 {
                            *mut_ref = val as _;
                        }
                    };
                }
                _ => {
                    decoder.skip_wire_value(tag.wire_type())?;
                }
            }
        }
        Ok(())
    }
}
impl ::micropb::MessageEncode for Rpc_Req_WifiSetChannel {
    const MAX_SIZE: ::core::option::Option<usize> = 'msg: {
        let mut max_size = 0;
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(10usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(10usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        ::core::option::Option::Some(max_size)
    };
    fn encode<IMPL_MICROPB_WRITE: ::micropb::PbWrite>(
        &self,
        encoder: &mut ::micropb::PbEncoder<IMPL_MICROPB_WRITE>,
    ) -> Result<(), IMPL_MICROPB_WRITE::Error> {
        use ::micropb::{FieldEncode, PbMap};
        {
            let val_ref = &self.r#primary;
            if *val_ref != 0 {
                encoder.encode_varint32(8u32)?;
                encoder.encode_int32(*val_ref as _)?;
            }
        }
        {
            let val_ref = &self.r#second;
            if *val_ref != 0 {
                encoder.encode_varint32(16u32)?;
                encoder.encode_int32(*val_ref as _)?;
            }
        }
        Ok(())
    }
    fn compute_size(&self) -> usize {
        use ::micropb::{FieldEncode, PbMap};
        let mut size = 0;
        {
            let val_ref = &self.r#primary;
            if *val_ref != 0 {
                size += 1usize + ::micropb::size::sizeof_int32(*val_ref as _);
            }
        }
        {
            let val_ref = &self.r#second;
            if *val_ref != 0 {
                size += 1usize + ::micropb::size::sizeof_int32(*val_ref as _);
            }
        }
        size
    }
}
#[derive(Debug, Default, PartialEq, Clone)]
pub struct Rpc_Resp_WifiSetChannel {
    pub r#resp: i32,
}
impl Rpc_Resp_WifiSetChannel {
    ///Return a reference to `resp`
    #[inline]
    pub fn r#resp(&self) -> &i32 {
        &self.r#resp
    }
    ///Return a mutable reference to `resp`
    #[inline]
    pub fn mut_resp(&mut self) -> &mut i32 {
        &mut self.r#resp
    }
    ///Set the value of `resp`
    #[inline]
    pub fn set_resp(&mut self, value: i32) -> &mut Self {
        self.r#resp = value.into();
        self
    }
    ///Builder method that sets the value of `resp`. Useful for initializing the message.
    #[inline]
    pub fn init_resp(mut self, value: i32) -> Self {
        self.r#resp = value.into();
        self
    }
}
impl ::micropb::MessageDecode for Rpc_Resp_WifiSetChannel {
    fn decode<IMPL_MICROPB_READ: ::micropb::PbRead>(
        &mut self,
        decoder: &mut ::micropb::PbDecoder<IMPL_MICROPB_READ>,
        len: usize,
    ) -> Result<(), ::micropb::DecodeError<IMPL_MICROPB_READ::Error>> {
        use ::micropb::{FieldDecode, PbBytes, PbMap, PbString, PbVec};
        let before = decoder.bytes_read();
        while decoder.bytes_read() - before < len {
            let tag = decoder.decode_tag()?;
            match tag.field_num() {
                0 => return Err(::micropb::DecodeError::ZeroField),
                1u32 => {
                    let mut_ref = &mut self.r#resp;
                    {
                        let val = decoder.decode_int32()?;
                        let val_ref = &val;
                        if *val_ref != 0 {
                            *mut_ref = val as _;
                        }
                    };
                }
                _ => {
                    decoder.skip_wire_value(tag.wire_type())?;
                }
            }
        }
        Ok(())
    }
}
impl ::micropb::MessageEncode for Rpc_Resp_WifiSetChannel {
    const MAX_SIZE: ::core::option::Option<usize> = 'msg: {
        let mut max_size = 0;
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(10usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        ::core::option::Option::Some(max_size)
    };
    fn encode<IMPL_MICROPB_WRITE: ::micropb::PbWrite>(
        &self,
        encoder: &mut ::micropb::PbEncoder<IMPL_MICROPB_WRITE>,
    ) -> Result<(), IMPL_MICROPB_WRITE::Error> {
        use ::micropb::{FieldEncode, PbMap};
        {
            let val_ref = &self.r#resp;
            if *val_ref != 0 {
                encoder.encode_varint32(8u32)?;
                encoder.encode_int32(*val_ref as _)?;
            }
        }
        Ok(())
    }
    fn compute_size(&self) -> usize {
        use ::micropb::{FieldEncode, PbMap};
        let mut size = 0;
        {
            let val_ref = &self.r#resp;
            if *val_ref != 0 {
                size += 1usize + ::micropb::size::sizeof_int32(*val_ref as _);
            }
        }
        size
    }
}
#[derive(Debug, Default, PartialEq, Clone)]
pub struct Rpc_Req_WifiGetChannel {}
impl Rpc_Req_WifiGetChannel {}
impl ::micropb::MessageDecode for Rpc_Req_WifiGetChannel {
    fn decode<IMPL_MICROPB_READ: ::micropb::PbRead>(
        &mut self,
        decoder: &mut ::micropb::PbDecoder<IMPL_MICROPB_READ>,
        len: usize,
    ) -> Result<(), ::micropb::DecodeError<IMPL_MICROPB_READ::Error>> {
        use ::micropb::{FieldDecode, PbBytes, PbMap, PbString, PbVec};
        let before = decoder.bytes_read();
        while decoder.bytes_read() - before < len {
            let tag = decoder.decode_tag()?;
            match tag.field_num() {
                0 => return Err(::micropb::DecodeError::ZeroField),
                _ => {
                    decoder.skip_wire_value(tag.wire_type())?;
                }
            }
        }
        Ok(())
    }
}
impl ::micropb::MessageEncode for Rpc_Req_WifiGetChannel {
    const MAX_SIZE: ::core::option::Option<usize> = 'msg: {
        let mut max_size = 0;
        ::core::option::Option::Some(max_size)
    };
    fn encode<IMPL_MICROPB_WRITE: ::micropb::PbWrite>(
        &self,
        encoder: &mut ::micropb::PbEncoder<IMPL_MICROPB_WRITE>,
    ) -> Result<(), IMPL_MICROPB_WRITE::Error> {
        use ::micropb::{FieldEncode, PbMap};
        Ok(())
    }
    fn compute_size(&self) -> usize {
        use ::micropb::{FieldEncode, PbMap};
        let mut size = 0;
        size
    }
}
#[derive(Debug, Default, PartialEq, Clone)]
pub struct Rpc_Resp_WifiGetChannel {
    pub r#resp: i32,
    pub r#primary: i32,
    pub r#second: i32,
}
impl Rpc_Resp_WifiGetChannel {
    ///Return a reference to `resp`
    #[inline]
    pub fn r#resp(&self) -> &i32 {
        &self.r#resp
    }
    ///Return a mutable reference to `resp`
    #[inline]
    pub fn mut_resp(&mut self) -> &mut i32 {
        &mut self.r#resp
    }
    ///Set the value of `resp`
    #[inline]
    pub fn set_resp(&mut self, value: i32) -> &mut Self {
        self.r#resp = value.into();
        self
    }
    ///Builder method that sets the value of `resp`. Useful for initializing the message.
    #[inline]
    pub fn init_resp(mut self, value: i32) -> Self {
        self.r#resp = value.into();
        self
    }
    ///Return a reference to `primary`
    #[inline]
    pub fn r#primary(&self) -> &i32 {
        &self.r#primary
    }
    ///Return a mutable reference to `primary`
    #[inline]
    pub fn mut_primary(&mut self) -> &mut i32 {
        &mut self.r#primary
    }
    ///Set the value of `primary`
    #[inline]
    pub fn set_primary(&mut self, value: i32) -> &mut Self {
        self.r#primary = value.into();
        self
    }
    ///Builder method that sets the value of `primary`. Useful for initializing the message.
    #[inline]
    pub fn init_primary(mut self, value: i32) -> Self {
        self.r#primary = value.into();
        self
    }
    ///Return a reference to `second`
    #[inline]
    pub fn r#second(&self) -> &i32 {
        &self.r#second
    }
    ///Return a mutable reference to `second`
    #[inline]
    pub fn mut_second(&mut self) -> &mut i32 {
        &mut self.r#second
    }
    ///Set the value of `second`
    #[inline]
    pub fn set_second(&mut self, value: i32) -> &mut Self {
        self.r#second = value.into();
        self
    }
    ///Builder method that sets the value of `second`. Useful for initializing the message.
    #[inline]
    pub fn init_second(mut self, value: i32) -> Self {
        self.r#second = value.into();
        self
    }
}
impl ::micropb::MessageDecode for Rpc_Resp_WifiGetChannel {
    fn decode<IMPL_MICROPB_READ: ::micropb::PbRead>(
        &mut self,
        decoder: &mut ::micropb::PbDecoder<IMPL_MICROPB_READ>,
        len: usize,
    ) -> Result<(), ::micropb::DecodeError<IMPL_MICROPB_READ::Error>> {
        use ::micropb::{FieldDecode, PbBytes, PbMap, PbString, PbVec};
        let before = decoder.bytes_read();
        while decoder.bytes_read() - before < len {
            let tag = decoder.decode_tag()?;
            match tag.field_num() {
                0 => return Err(::micropb::DecodeError::ZeroField),
                1u32 => {
                    let mut_ref = &mut self.r#resp;
                    {
                        let val = decoder.decode_int32()?;
                        let val_ref = &val;
                        if *val_ref != 0 {
                            *mut_ref = val as _;
                        }
                    };
                }
                2u32 => {
                    let mut_ref = &mut self.r#primary;
                    {
                        let val = decoder.decode_int32()?;
                        let val_ref = &val;
                        if *val_ref != 0 {
                            *mut_ref = val as _;
                        }
                    };
                }
                3u32 => {
                    let mut_ref = &mut self.r#second;
                    {
                        let val = decoder.decode_int32()?;
                        let val_ref = &val;
                        if *val_ref != 0 {
                            *mut_ref = val as _;
                        }
                    };
                }
                _ => {
                    decoder.skip_wire_value(tag.wire_type())?;
                }
            }
        }
        Ok(())
    }
}
impl ::micropb::MessageEncode for Rpc_Resp_WifiGetChannel {
    const MAX_SIZE: ::core::option::Option<usize> = 'msg: {
        let mut max_size = 0;
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(10usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(10usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(10usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        ::core::option::Option::Some(max_size)
    };
    fn encode<IMPL_MICROPB_WRITE: ::micropb::PbWrite>(
        &self,
        encoder: &mut ::micropb::PbEncoder<IMPL_MICROPB_WRITE>,
    ) -> Result<(), IMPL_MICROPB_WRITE::Error> {
        use ::micropb::{FieldEncode, PbMap};
        {
            let val_ref = &self.r#resp;
            if *val_ref != 0 {
                encoder.encode_varint32(8u32)?;
                encoder.encode_int32(*val_ref as _)?;
            }
        }
        {
            let val_ref = &self.r#primary;
            if *val_ref != 0 {
                encoder.encode_varint32(16u32)?;
                encoder.encode_int32(*val_ref as _)?;
            }
        }
        {
            let val_ref = &self.r#second;
            if *val_ref != 0 {
                encoder.encode_varint32(24u32)?;
                encoder.encode_int32(*val_ref as _)?;
            }
        }
        Ok(())
    }
    fn compute_size(&self) -> usize {
        use ::micropb::{FieldEncode, PbMap};
        let mut size = 0;
        {
            let val_ref = &self.r#resp;
            if *val_ref != 0 {
                size += 1usize + ::micropb::size::sizeof_int32(*val_ref as _);
            }
        }
        {
            let val_ref = &self.r#primary;
            if *val_ref != 0 {
                size += 1usize + ::micropb::size::sizeof_int32(*val_ref as _);
            }
        }
        {
            let val_ref = &self.r#second;
            if *val_ref != 0 {
                size += 1usize + ::micropb::size::sizeof_int32(*val_ref as _);
            }
        }
        size
    }
}
#[derive(Debug, Default, PartialEq, Clone)]
pub struct Rpc_Req_WifiSetStorage {
    pub r#storage: i32,
}
impl Rpc_Req_WifiSetStorage {
    ///Return a reference to `storage`
    #[inline]
    pub fn r#storage(&self) -> &i32 {
        &self.r#storage
    }
    ///Return a mutable reference to `storage`
    #[inline]
    pub fn mut_storage(&mut self) -> &mut i32 {
        &mut self.r#storage
    }
    ///Set the value of `storage`
    #[inline]
    pub fn set_storage(&mut self, value: i32) -> &mut Self {
        self.r#storage = value.into();
        self
    }
    ///Builder method that sets the value of `storage`. Useful for initializing the message.
    #[inline]
    pub fn init_storage(mut self, value: i32) -> Self {
        self.r#storage = value.into();
        self
    }
}
impl ::micropb::MessageDecode for Rpc_Req_WifiSetStorage {
    fn decode<IMPL_MICROPB_READ: ::micropb::PbRead>(
        &mut self,
        decoder: &mut ::micropb::PbDecoder<IMPL_MICROPB_READ>,
        len: usize,
    ) -> Result<(), ::micropb::DecodeError<IMPL_MICROPB_READ::Error>> {
        use ::micropb::{FieldDecode, PbBytes, PbMap, PbString, PbVec};
        let before = decoder.bytes_read();
        while decoder.bytes_read() - before < len {
            let tag = decoder.decode_tag()?;
            match tag.field_num() {
                0 => return Err(::micropb::DecodeError::ZeroField),
                1u32 => {
                    let mut_ref = &mut self.r#storage;
                    {
                        let val = decoder.decode_int32()?;
                        let val_ref = &val;
                        if *val_ref != 0 {
                            *mut_ref = val as _;
                        }
                    };
                }
                _ => {
                    decoder.skip_wire_value(tag.wire_type())?;
                }
            }
        }
        Ok(())
    }
}
impl ::micropb::MessageEncode for Rpc_Req_WifiSetStorage {
    const MAX_SIZE: ::core::option::Option<usize> = 'msg: {
        let mut max_size = 0;
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(10usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        ::core::option::Option::Some(max_size)
    };
    fn encode<IMPL_MICROPB_WRITE: ::micropb::PbWrite>(
        &self,
        encoder: &mut ::micropb::PbEncoder<IMPL_MICROPB_WRITE>,
    ) -> Result<(), IMPL_MICROPB_WRITE::Error> {
        use ::micropb::{FieldEncode, PbMap};
        {
            let val_ref = &self.r#storage;
            if *val_ref != 0 {
                encoder.encode_varint32(8u32)?;
                encoder.encode_int32(*val_ref as _)?;
            }
        }
        Ok(())
    }
    fn compute_size(&self) -> usize {
        use ::micropb::{FieldEncode, PbMap};
        let mut size = 0;
        {
            let val_ref = &self.r#storage;
            if *val_ref != 0 {
                size += 1usize + ::micropb::size::sizeof_int32(*val_ref as _);
            }
        }
        size
    }
}
#[derive(Debug, Default, PartialEq, Clone)]
pub struct Rpc_Resp_WifiSetStorage {
    pub r#resp: i32,
}
impl Rpc_Resp_WifiSetStorage {
    ///Return a reference to `resp`
    #[inline]
    pub fn r#resp(&self) -> &i32 {
        &self.r#resp
    }
    ///Return a mutable reference to `resp`
    #[inline]
    pub fn mut_resp(&mut self) -> &mut i32 {
        &mut self.r#resp
    }
    ///Set the value of `resp`
    #[inline]
    pub fn set_resp(&mut self, value: i32) -> &mut Self {
        self.r#resp = value.into();
        self
    }
    ///Builder method that sets the value of `resp`. Useful for initializing the message.
    #[inline]
    pub fn init_resp(mut self, value: i32) -> Self {
        self.r#resp = value.into();
        self
    }
}
impl ::micropb::MessageDecode for Rpc_Resp_WifiSetStorage {
    fn decode<IMPL_MICROPB_READ: ::micropb::PbRead>(
        &mut self,
        decoder: &mut ::micropb::PbDecoder<IMPL_MICROPB_READ>,
        len: usize,
    ) -> Result<(), ::micropb::DecodeError<IMPL_MICROPB_READ::Error>> {
        use ::micropb::{FieldDecode, PbBytes, PbMap, PbString, PbVec};
        let before = decoder.bytes_read();
        while decoder.bytes_read() - before < len {
            let tag = decoder.decode_tag()?;
            match tag.field_num() {
                0 => return Err(::micropb::DecodeError::ZeroField),
                1u32 => {
                    let mut_ref = &mut self.r#resp;
                    {
                        let val = decoder.decode_int32()?;
                        let val_ref = &val;
                        if *val_ref != 0 {
                            *mut_ref = val as _;
                        }
                    };
                }
                _ => {
                    decoder.skip_wire_value(tag.wire_type())?;
                }
            }
        }
        Ok(())
    }
}
impl ::micropb::MessageEncode for Rpc_Resp_WifiSetStorage {
    const MAX_SIZE: ::core::option::Option<usize> = 'msg: {
        let mut max_size = 0;
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(10usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        ::core::option::Option::Some(max_size)
    };
    fn encode<IMPL_MICROPB_WRITE: ::micropb::PbWrite>(
        &self,
        encoder: &mut ::micropb::PbEncoder<IMPL_MICROPB_WRITE>,
    ) -> Result<(), IMPL_MICROPB_WRITE::Error> {
        use ::micropb::{FieldEncode, PbMap};
        {
            let val_ref = &self.r#resp;
            if *val_ref != 0 {
                encoder.encode_varint32(8u32)?;
                encoder.encode_int32(*val_ref as _)?;
            }
        }
        Ok(())
    }
    fn compute_size(&self) -> usize {
        use ::micropb::{FieldEncode, PbMap};
        let mut size = 0;
        {
            let val_ref = &self.r#resp;
            if *val_ref != 0 {
                size += 1usize + ::micropb::size::sizeof_int32(*val_ref as _);
            }
        }
        size
    }
}
#[derive(Debug, Default, PartialEq, Clone)]
pub struct Rpc_Req_WifiSetCountryCode {
    pub r#country: ::micropb::heapless::Vec<u8, 3>,
    pub r#ieee80211d_enabled: bool,
}
impl Rpc_Req_WifiSetCountryCode {
    ///Return a reference to `country`
    #[inline]
    pub fn r#country(&self) -> &::micropb::heapless::Vec<u8, 3> {
        &self.r#country
    }
    ///Return a mutable reference to `country`
    #[inline]
    pub fn mut_country(&mut self) -> &mut ::micropb::heapless::Vec<u8, 3> {
        &mut self.r#country
    }
    ///Set the value of `country`
    #[inline]
    pub fn set_country(&mut self, value: ::micropb::heapless::Vec<u8, 3>) -> &mut Self {
        self.r#country = value.into();
        self
    }
    ///Builder method that sets the value of `country`. Useful for initializing the message.
    #[inline]
    pub fn init_country(mut self, value: ::micropb::heapless::Vec<u8, 3>) -> Self {
        self.r#country = value.into();
        self
    }
    ///Return a reference to `ieee80211d_enabled`
    #[inline]
    pub fn r#ieee80211d_enabled(&self) -> &bool {
        &self.r#ieee80211d_enabled
    }
    ///Return a mutable reference to `ieee80211d_enabled`
    #[inline]
    pub fn mut_ieee80211d_enabled(&mut self) -> &mut bool {
        &mut self.r#ieee80211d_enabled
    }
    ///Set the value of `ieee80211d_enabled`
    #[inline]
    pub fn set_ieee80211d_enabled(&mut self, value: bool) -> &mut Self {
        self.r#ieee80211d_enabled = value.into();
        self
    }
    ///Builder method that sets the value of `ieee80211d_enabled`. Useful for initializing the message.
    #[inline]
    pub fn init_ieee80211d_enabled(mut self, value: bool) -> Self {
        self.r#ieee80211d_enabled = value.into();
        self
    }
}
impl ::micropb::MessageDecode for Rpc_Req_WifiSetCountryCode {
    fn decode<IMPL_MICROPB_READ: ::micropb::PbRead>(
        &mut self,
        decoder: &mut ::micropb::PbDecoder<IMPL_MICROPB_READ>,
        len: usize,
    ) -> Result<(), ::micropb::DecodeError<IMPL_MICROPB_READ::Error>> {
        use ::micropb::{FieldDecode, PbBytes, PbMap, PbString, PbVec};
        let before = decoder.bytes_read();
        while decoder.bytes_read() - before < len {
            let tag = decoder.decode_tag()?;
            match tag.field_num() {
                0 => return Err(::micropb::DecodeError::ZeroField),
                1u32 => {
                    let mut_ref = &mut self.r#country;
                    {
                        decoder.decode_bytes(mut_ref, ::micropb::Presence::Implicit)?;
                    };
                }
                2u32 => {
                    let mut_ref = &mut self.r#ieee80211d_enabled;
                    {
                        let val = decoder.decode_bool()?;
                        let val_ref = &val;
                        if *val_ref {
                            *mut_ref = val as _;
                        }
                    };
                }
                _ => {
                    decoder.skip_wire_value(tag.wire_type())?;
                }
            }
        }
        Ok(())
    }
}
impl ::micropb::MessageEncode for Rpc_Req_WifiSetCountryCode {
    const MAX_SIZE: ::core::option::Option<usize> = 'msg: {
        let mut max_size = 0;
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(4usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(1usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        ::core::option::Option::Some(max_size)
    };
    fn encode<IMPL_MICROPB_WRITE: ::micropb::PbWrite>(
        &self,
        encoder: &mut ::micropb::PbEncoder<IMPL_MICROPB_WRITE>,
    ) -> Result<(), IMPL_MICROPB_WRITE::Error> {
        use ::micropb::{FieldEncode, PbMap};
        {
            let val_ref = &self.r#country;
            if !val_ref.is_empty() {
                encoder.encode_varint32(10u32)?;
                encoder.encode_bytes(val_ref)?;
            }
        }
        {
            let val_ref = &self.r#ieee80211d_enabled;
            if *val_ref {
                encoder.encode_varint32(16u32)?;
                encoder.encode_bool(*val_ref)?;
            }
        }
        Ok(())
    }
    fn compute_size(&self) -> usize {
        use ::micropb::{FieldEncode, PbMap};
        let mut size = 0;
        {
            let val_ref = &self.r#country;
            if !val_ref.is_empty() {
                size += 1usize + ::micropb::size::sizeof_len_record(val_ref.len());
            }
        }
        {
            let val_ref = &self.r#ieee80211d_enabled;
            if *val_ref {
                size += 1usize + 1;
            }
        }
        size
    }
}
#[derive(Debug, Default, PartialEq, Clone)]
pub struct Rpc_Resp_WifiSetCountryCode {
    pub r#resp: i32,
}
impl Rpc_Resp_WifiSetCountryCode {
    ///Return a reference to `resp`
    #[inline]
    pub fn r#resp(&self) -> &i32 {
        &self.r#resp
    }
    ///Return a mutable reference to `resp`
    #[inline]
    pub fn mut_resp(&mut self) -> &mut i32 {
        &mut self.r#resp
    }
    ///Set the value of `resp`
    #[inline]
    pub fn set_resp(&mut self, value: i32) -> &mut Self {
        self.r#resp = value.into();
        self
    }
    ///Builder method that sets the value of `resp`. Useful for initializing the message.
    #[inline]
    pub fn init_resp(mut self, value: i32) -> Self {
        self.r#resp = value.into();
        self
    }
}
impl ::micropb::MessageDecode for Rpc_Resp_WifiSetCountryCode {
    fn decode<IMPL_MICROPB_READ: ::micropb::PbRead>(
        &mut self,
        decoder: &mut ::micropb::PbDecoder<IMPL_MICROPB_READ>,
        len: usize,
    ) -> Result<(), ::micropb::DecodeError<IMPL_MICROPB_READ::Error>> {
        use ::micropb::{FieldDecode, PbBytes, PbMap, PbString, PbVec};
        let before = decoder.bytes_read();
        while decoder.bytes_read() - before < len {
            let tag = decoder.decode_tag()?;
            match tag.field_num() {
                0 => return Err(::micropb::DecodeError::ZeroField),
                1u32 => {
                    let mut_ref = &mut self.r#resp;
                    {
                        let val = decoder.decode_int32()?;
                        let val_ref = &val;
                        if *val_ref != 0 {
                            *mut_ref = val as _;
                        }
                    };
                }
                _ => {
                    decoder.skip_wire_value(tag.wire_type())?;
                }
            }
        }
        Ok(())
    }
}
impl ::micropb::MessageEncode for Rpc_Resp_WifiSetCountryCode {
    const MAX_SIZE: ::core::option::Option<usize> = 'msg: {
        let mut max_size = 0;
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(10usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        ::core::option::Option::Some(max_size)
    };
    fn encode<IMPL_MICROPB_WRITE: ::micropb::PbWrite>(
        &self,
        encoder: &mut ::micropb::PbEncoder<IMPL_MICROPB_WRITE>,
    ) -> Result<(), IMPL_MICROPB_WRITE::Error> {
        use ::micropb::{FieldEncode, PbMap};
        {
            let val_ref = &self.r#resp;
            if *val_ref != 0 {
                encoder.encode_varint32(8u32)?;
                encoder.encode_int32(*val_ref as _)?;
            }
        }
        Ok(())
    }
    fn compute_size(&self) -> usize {
        use ::micropb::{FieldEncode, PbMap};
        let mut size = 0;
        {
            let val_ref = &self.r#resp;
            if *val_ref != 0 {
                size += 1usize + ::micropb::size::sizeof_int32(*val_ref as _);
            }
        }
        size
    }
}
#[derive(Debug, Default, PartialEq, Clone)]
pub struct Rpc_Req_WifiGetCountryCode {}
impl Rpc_Req_WifiGetCountryCode {}
impl ::micropb::MessageDecode for Rpc_Req_WifiGetCountryCode {
    fn decode<IMPL_MICROPB_READ: ::micropb::PbRead>(
        &mut self,
        decoder: &mut ::micropb::PbDecoder<IMPL_MICROPB_READ>,
        len: usize,
    ) -> Result<(), ::micropb::DecodeError<IMPL_MICROPB_READ::Error>> {
        use ::micropb::{FieldDecode, PbBytes, PbMap, PbString, PbVec};
        let before = decoder.bytes_read();
        while decoder.bytes_read() - before < len {
            let tag = decoder.decode_tag()?;
            match tag.field_num() {
                0 => return Err(::micropb::DecodeError::ZeroField),
                _ => {
                    decoder.skip_wire_value(tag.wire_type())?;
                }
            }
        }
        Ok(())
    }
}
impl ::micropb::MessageEncode for Rpc_Req_WifiGetCountryCode {
    const MAX_SIZE: ::core::option::Option<usize> = 'msg: {
        let mut max_size = 0;
        ::core::option::Option::Some(max_size)
    };
    fn encode<IMPL_MICROPB_WRITE: ::micropb::PbWrite>(
        &self,
        encoder: &mut ::micropb::PbEncoder<IMPL_MICROPB_WRITE>,
    ) -> Result<(), IMPL_MICROPB_WRITE::Error> {
        use ::micropb::{FieldEncode, PbMap};
        Ok(())
    }
    fn compute_size(&self) -> usize {
        use ::micropb::{FieldEncode, PbMap};
        let mut size = 0;
        size
    }
}
#[derive(Debug, Default, PartialEq, Clone)]
pub struct Rpc_Resp_WifiGetCountryCode {
    pub r#resp: i32,
    pub r#country: ::micropb::heapless::Vec<u8, 3>,
}
impl Rpc_Resp_WifiGetCountryCode {
    ///Return a reference to `resp`
    #[inline]
    pub fn r#resp(&self) -> &i32 {
        &self.r#resp
    }
    ///Return a mutable reference to `resp`
    #[inline]
    pub fn mut_resp(&mut self) -> &mut i32 {
        &mut self.r#resp
    }
    ///Set the value of `resp`
    #[inline]
    pub fn set_resp(&mut self, value: i32) -> &mut Self {
        self.r#resp = value.into();
        self
    }
    ///Builder method that sets the value of `resp`. Useful for initializing the message.
    #[inline]
    pub fn init_resp(mut self, value: i32) -> Self {
        self.r#resp = value.into();
        self
    }
    ///Return a reference to `country`
    #[inline]
    pub fn r#country(&self) -> &::micropb::heapless::Vec<u8, 3> {
        &self.r#country
    }
    ///Return a mutable reference to `country`
    #[inline]
    pub fn mut_country(&mut self) -> &mut ::micropb::heapless::Vec<u8, 3> {
        &mut self.r#country
    }
    ///Set the value of `country`
    #[inline]
    pub fn set_country(&mut self, value: ::micropb::heapless::Vec<u8, 3>) -> &mut Self {
        self.r#country = value.into();
        self
    }
    ///Builder method that sets the value of `country`. Useful for initializing the message.
    #[inline]
    pub fn init_country(mut self, value: ::micropb::heapless::Vec<u8, 3>) -> Self {
        self.r#country = value.into();
        self
    }
}
impl ::micropb::MessageDecode for Rpc_Resp_WifiGetCountryCode {
    fn decode<IMPL_MICROPB_READ: ::micropb::PbRead>(
        &mut self,
        decoder: &mut ::micropb::PbDecoder<IMPL_MICROPB_READ>,
        len: usize,
    ) -> Result<(), ::micropb::DecodeError<IMPL_MICROPB_READ::Error>> {
        use ::micropb::{FieldDecode, PbBytes, PbMap, PbString, PbVec};
        let before = decoder.bytes_read();
        while decoder.bytes_read() - before < len {
            let tag = decoder.decode_tag()?;
            match tag.field_num() {
                0 => return Err(::micropb::DecodeError::ZeroField),
                1u32 => {
                    let mut_ref = &mut self.r#resp;
                    {
                        let val = decoder.decode_int32()?;
                        let val_ref = &val;
                        if *val_ref != 0 {
                            *mut_ref = val as _;
                        }
                    };
                }
                2u32 => {
                    let mut_ref = &mut self.r#country;
                    {
                        decoder.decode_bytes(mut_ref, ::micropb::Presence::Implicit)?;
                    };
                }
                _ => {
                    decoder.skip_wire_value(tag.wire_type())?;
                }
            }
        }
        Ok(())
    }
}
impl ::micropb::MessageEncode for Rpc_Resp_WifiGetCountryCode {
    const MAX_SIZE: ::core::option::Option<usize> = 'msg: {
        let mut max_size = 0;
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(10usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(4usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        ::core::option::Option::Some(max_size)
    };
    fn encode<IMPL_MICROPB_WRITE: ::micropb::PbWrite>(
        &self,
        encoder: &mut ::micropb::PbEncoder<IMPL_MICROPB_WRITE>,
    ) -> Result<(), IMPL_MICROPB_WRITE::Error> {
        use ::micropb::{FieldEncode, PbMap};
        {
            let val_ref = &self.r#resp;
            if *val_ref != 0 {
                encoder.encode_varint32(8u32)?;
                encoder.encode_int32(*val_ref as _)?;
            }
        }
        {
            let val_ref = &self.r#country;
            if !val_ref.is_empty() {
                encoder.encode_varint32(18u32)?;
                encoder.encode_bytes(val_ref)?;
            }
        }
        Ok(())
    }
    fn compute_size(&self) -> usize {
        use ::micropb::{FieldEncode, PbMap};
        let mut size = 0;
        {
            let val_ref = &self.r#resp;
            if *val_ref != 0 {
                size += 1usize + ::micropb::size::sizeof_int32(*val_ref as _);
            }
        }
        {
            let val_ref = &self.r#country;
            if !val_ref.is_empty() {
                size += 1usize + ::micropb::size::sizeof_len_record(val_ref.len());
            }
        }
        size
    }
}
pub mod Rpc_Req_WifiSetCountry_ {
    #[derive(Debug, Default, PartialEq, Clone)]
    pub struct _Hazzer([u8; 1]);
    impl _Hazzer {
        ///New hazzer with all fields set to off
        #[inline]
        pub const fn _new() -> Self {
            Self([0; 1])
        }
        ///Query presence of `country`
        #[inline]
        pub const fn r#country(&self) -> bool {
            (self.0[0] & 1) != 0
        }
        ///Set presence of `country`
        #[inline]
        pub const fn set_country(&mut self) -> &mut Self {
            let elem = &mut self.0[0];
            *elem |= 1;
            self
        }
        ///Clear presence of `country`
        #[inline]
        pub const fn clear_country(&mut self) -> &mut Self {
            let elem = &mut self.0[0];
            *elem &= !1;
            self
        }
        ///Builder method that sets the presence of `country`. Useful for initializing the Hazzer.
        #[inline]
        pub const fn init_country(mut self) -> Self {
            self.set_country();
            self
        }
    }
}
#[derive(Debug, Default, Clone)]
pub struct Rpc_Req_WifiSetCountry {
    pub r#country: r#wifi_country,
    pub _has: Rpc_Req_WifiSetCountry_::_Hazzer,
}
impl ::core::cmp::PartialEq for Rpc_Req_WifiSetCountry {
    fn eq(&self, other: &Self) -> bool {
        let mut ret = true;
        ret &= (self.r#country() == other.r#country());
        ret
    }
}
impl Rpc_Req_WifiSetCountry {
    ///Return a reference to `country` as an `Option`
    #[inline]
    pub fn r#country(&self) -> ::core::option::Option<&r#wifi_country> {
        self._has.r#country().then_some(&self.r#country)
    }
    ///Set the value and presence of `country`
    #[inline]
    pub fn set_country(&mut self, value: r#wifi_country) -> &mut Self {
        self._has.set_country();
        self.r#country = value.into();
        self
    }
    ///Return a mutable reference to `country` as an `Option`
    #[inline]
    pub fn mut_country(&mut self) -> ::core::option::Option<&mut r#wifi_country> {
        self._has.r#country().then_some(&mut self.r#country)
    }
    ///Clear the presence of `country`
    #[inline]
    pub fn clear_country(&mut self) -> &mut Self {
        self._has.clear_country();
        self
    }
    ///Take the value of `country` and clear its presence
    #[inline]
    pub fn take_country(&mut self) -> ::core::option::Option<r#wifi_country> {
        let val = self
            ._has
            .r#country()
            .then(|| ::core::mem::take(&mut self.r#country));
        self._has.clear_country();
        val
    }
    ///Builder method that sets the value of `country`. Useful for initializing the message.
    #[inline]
    pub fn init_country(mut self, value: r#wifi_country) -> Self {
        self.set_country(value);
        self
    }
}
impl ::micropb::MessageDecode for Rpc_Req_WifiSetCountry {
    fn decode<IMPL_MICROPB_READ: ::micropb::PbRead>(
        &mut self,
        decoder: &mut ::micropb::PbDecoder<IMPL_MICROPB_READ>,
        len: usize,
    ) -> Result<(), ::micropb::DecodeError<IMPL_MICROPB_READ::Error>> {
        use ::micropb::{FieldDecode, PbBytes, PbMap, PbString, PbVec};
        let before = decoder.bytes_read();
        while decoder.bytes_read() - before < len {
            let tag = decoder.decode_tag()?;
            match tag.field_num() {
                0 => return Err(::micropb::DecodeError::ZeroField),
                1u32 => {
                    let mut_ref = &mut self.r#country;
                    {
                        mut_ref.decode_len_delimited(decoder)?;
                    };
                    self._has.set_country();
                }
                _ => {
                    decoder.skip_wire_value(tag.wire_type())?;
                }
            }
        }
        Ok(())
    }
}
impl ::micropb::MessageEncode for Rpc_Req_WifiSetCountry {
    const MAX_SIZE: ::core::option::Option<usize> = 'msg: {
        let mut max_size = 0;
        if let ::core::option::Option::Some(size) = ::micropb::const_map!(
            ::micropb::const_map!(
                <r#wifi_country as ::micropb::MessageEncode>::MAX_SIZE,
                |size| ::micropb::size::sizeof_len_record(size)
            ),
            |size| size + 1usize
        ) {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        ::core::option::Option::Some(max_size)
    };
    fn encode<IMPL_MICROPB_WRITE: ::micropb::PbWrite>(
        &self,
        encoder: &mut ::micropb::PbEncoder<IMPL_MICROPB_WRITE>,
    ) -> Result<(), IMPL_MICROPB_WRITE::Error> {
        use ::micropb::{FieldEncode, PbMap};
        {
            if let ::core::option::Option::Some(val_ref) = self.r#country() {
                encoder.encode_varint32(10u32)?;
                val_ref.encode_len_delimited(encoder)?;
            }
        }
        Ok(())
    }
    fn compute_size(&self) -> usize {
        use ::micropb::{FieldEncode, PbMap};
        let mut size = 0;
        {
            if let ::core::option::Option::Some(val_ref) = self.r#country() {
                size += 1usize + ::micropb::size::sizeof_len_record(val_ref.compute_size());
            }
        }
        size
    }
}
#[derive(Debug, Default, PartialEq, Clone)]
pub struct Rpc_Resp_WifiSetCountry {
    pub r#resp: i32,
}
impl Rpc_Resp_WifiSetCountry {
    ///Return a reference to `resp`
    #[inline]
    pub fn r#resp(&self) -> &i32 {
        &self.r#resp
    }
    ///Return a mutable reference to `resp`
    #[inline]
    pub fn mut_resp(&mut self) -> &mut i32 {
        &mut self.r#resp
    }
    ///Set the value of `resp`
    #[inline]
    pub fn set_resp(&mut self, value: i32) -> &mut Self {
        self.r#resp = value.into();
        self
    }
    ///Builder method that sets the value of `resp`. Useful for initializing the message.
    #[inline]
    pub fn init_resp(mut self, value: i32) -> Self {
        self.r#resp = value.into();
        self
    }
}
impl ::micropb::MessageDecode for Rpc_Resp_WifiSetCountry {
    fn decode<IMPL_MICROPB_READ: ::micropb::PbRead>(
        &mut self,
        decoder: &mut ::micropb::PbDecoder<IMPL_MICROPB_READ>,
        len: usize,
    ) -> Result<(), ::micropb::DecodeError<IMPL_MICROPB_READ::Error>> {
        use ::micropb::{FieldDecode, PbBytes, PbMap, PbString, PbVec};
        let before = decoder.bytes_read();
        while decoder.bytes_read() - before < len {
            let tag = decoder.decode_tag()?;
            match tag.field_num() {
                0 => return Err(::micropb::DecodeError::ZeroField),
                1u32 => {
                    let mut_ref = &mut self.r#resp;
                    {
                        let val = decoder.decode_int32()?;
                        let val_ref = &val;
                        if *val_ref != 0 {
                            *mut_ref = val as _;
                        }
                    };
                }
                _ => {
                    decoder.skip_wire_value(tag.wire_type())?;
                }
            }
        }
        Ok(())
    }
}
impl ::micropb::MessageEncode for Rpc_Resp_WifiSetCountry {
    const MAX_SIZE: ::core::option::Option<usize> = 'msg: {
        let mut max_size = 0;
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(10usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        ::core::option::Option::Some(max_size)
    };
    fn encode<IMPL_MICROPB_WRITE: ::micropb::PbWrite>(
        &self,
        encoder: &mut ::micropb::PbEncoder<IMPL_MICROPB_WRITE>,
    ) -> Result<(), IMPL_MICROPB_WRITE::Error> {
        use ::micropb::{FieldEncode, PbMap};
        {
            let val_ref = &self.r#resp;
            if *val_ref != 0 {
                encoder.encode_varint32(8u32)?;
                encoder.encode_int32(*val_ref as _)?;
            }
        }
        Ok(())
    }
    fn compute_size(&self) -> usize {
        use ::micropb::{FieldEncode, PbMap};
        let mut size = 0;
        {
            let val_ref = &self.r#resp;
            if *val_ref != 0 {
                size += 1usize + ::micropb::size::sizeof_int32(*val_ref as _);
            }
        }
        size
    }
}
#[derive(Debug, Default, PartialEq, Clone)]
pub struct Rpc_Req_WifiGetCountry {}
impl Rpc_Req_WifiGetCountry {}
impl ::micropb::MessageDecode for Rpc_Req_WifiGetCountry {
    fn decode<IMPL_MICROPB_READ: ::micropb::PbRead>(
        &mut self,
        decoder: &mut ::micropb::PbDecoder<IMPL_MICROPB_READ>,
        len: usize,
    ) -> Result<(), ::micropb::DecodeError<IMPL_MICROPB_READ::Error>> {
        use ::micropb::{FieldDecode, PbBytes, PbMap, PbString, PbVec};
        let before = decoder.bytes_read();
        while decoder.bytes_read() - before < len {
            let tag = decoder.decode_tag()?;
            match tag.field_num() {
                0 => return Err(::micropb::DecodeError::ZeroField),
                _ => {
                    decoder.skip_wire_value(tag.wire_type())?;
                }
            }
        }
        Ok(())
    }
}
impl ::micropb::MessageEncode for Rpc_Req_WifiGetCountry {
    const MAX_SIZE: ::core::option::Option<usize> = 'msg: {
        let mut max_size = 0;
        ::core::option::Option::Some(max_size)
    };
    fn encode<IMPL_MICROPB_WRITE: ::micropb::PbWrite>(
        &self,
        encoder: &mut ::micropb::PbEncoder<IMPL_MICROPB_WRITE>,
    ) -> Result<(), IMPL_MICROPB_WRITE::Error> {
        use ::micropb::{FieldEncode, PbMap};
        Ok(())
    }
    fn compute_size(&self) -> usize {
        use ::micropb::{FieldEncode, PbMap};
        let mut size = 0;
        size
    }
}
pub mod Rpc_Resp_WifiGetCountry_ {
    #[derive(Debug, Default, PartialEq, Clone)]
    pub struct _Hazzer([u8; 1]);
    impl _Hazzer {
        ///New hazzer with all fields set to off
        #[inline]
        pub const fn _new() -> Self {
            Self([0; 1])
        }
        ///Query presence of `country`
        #[inline]
        pub const fn r#country(&self) -> bool {
            (self.0[0] & 1) != 0
        }
        ///Set presence of `country`
        #[inline]
        pub const fn set_country(&mut self) -> &mut Self {
            let elem = &mut self.0[0];
            *elem |= 1;
            self
        }
        ///Clear presence of `country`
        #[inline]
        pub const fn clear_country(&mut self) -> &mut Self {
            let elem = &mut self.0[0];
            *elem &= !1;
            self
        }
        ///Builder method that sets the presence of `country`. Useful for initializing the Hazzer.
        #[inline]
        pub const fn init_country(mut self) -> Self {
            self.set_country();
            self
        }
    }
}
#[derive(Debug, Default, Clone)]
pub struct Rpc_Resp_WifiGetCountry {
    pub r#resp: i32,
    pub r#country: r#wifi_country,
    pub _has: Rpc_Resp_WifiGetCountry_::_Hazzer,
}
impl ::core::cmp::PartialEq for Rpc_Resp_WifiGetCountry {
    fn eq(&self, other: &Self) -> bool {
        let mut ret = true;
        ret &= (self.r#resp == other.r#resp);
        ret &= (self.r#country() == other.r#country());
        ret
    }
}
impl Rpc_Resp_WifiGetCountry {
    ///Return a reference to `resp`
    #[inline]
    pub fn r#resp(&self) -> &i32 {
        &self.r#resp
    }
    ///Return a mutable reference to `resp`
    #[inline]
    pub fn mut_resp(&mut self) -> &mut i32 {
        &mut self.r#resp
    }
    ///Set the value of `resp`
    #[inline]
    pub fn set_resp(&mut self, value: i32) -> &mut Self {
        self.r#resp = value.into();
        self
    }
    ///Builder method that sets the value of `resp`. Useful for initializing the message.
    #[inline]
    pub fn init_resp(mut self, value: i32) -> Self {
        self.r#resp = value.into();
        self
    }
    ///Return a reference to `country` as an `Option`
    #[inline]
    pub fn r#country(&self) -> ::core::option::Option<&r#wifi_country> {
        self._has.r#country().then_some(&self.r#country)
    }
    ///Set the value and presence of `country`
    #[inline]
    pub fn set_country(&mut self, value: r#wifi_country) -> &mut Self {
        self._has.set_country();
        self.r#country = value.into();
        self
    }
    ///Return a mutable reference to `country` as an `Option`
    #[inline]
    pub fn mut_country(&mut self) -> ::core::option::Option<&mut r#wifi_country> {
        self._has.r#country().then_some(&mut self.r#country)
    }
    ///Clear the presence of `country`
    #[inline]
    pub fn clear_country(&mut self) -> &mut Self {
        self._has.clear_country();
        self
    }
    ///Take the value of `country` and clear its presence
    #[inline]
    pub fn take_country(&mut self) -> ::core::option::Option<r#wifi_country> {
        let val = self
            ._has
            .r#country()
            .then(|| ::core::mem::take(&mut self.r#country));
        self._has.clear_country();
        val
    }
    ///Builder method that sets the value of `country`. Useful for initializing the message.
    #[inline]
    pub fn init_country(mut self, value: r#wifi_country) -> Self {
        self.set_country(value);
        self
    }
}
impl ::micropb::MessageDecode for Rpc_Resp_WifiGetCountry {
    fn decode<IMPL_MICROPB_READ: ::micropb::PbRead>(
        &mut self,
        decoder: &mut ::micropb::PbDecoder<IMPL_MICROPB_READ>,
        len: usize,
    ) -> Result<(), ::micropb::DecodeError<IMPL_MICROPB_READ::Error>> {
        use ::micropb::{FieldDecode, PbBytes, PbMap, PbString, PbVec};
        let before = decoder.bytes_read();
        while decoder.bytes_read() - before < len {
            let tag = decoder.decode_tag()?;
            match tag.field_num() {
                0 => return Err(::micropb::DecodeError::ZeroField),
                1u32 => {
                    let mut_ref = &mut self.r#resp;
                    {
                        let val = decoder.decode_int32()?;
                        let val_ref = &val;
                        if *val_ref != 0 {
                            *mut_ref = val as _;
                        }
                    };
                }
                2u32 => {
                    let mut_ref = &mut self.r#country;
                    {
                        mut_ref.decode_len_delimited(decoder)?;
                    };
                    self._has.set_country();
                }
                _ => {
                    decoder.skip_wire_value(tag.wire_type())?;
                }
            }
        }
        Ok(())
    }
}
impl ::micropb::MessageEncode for Rpc_Resp_WifiGetCountry {
    const MAX_SIZE: ::core::option::Option<usize> = 'msg: {
        let mut max_size = 0;
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(10usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        if let ::core::option::Option::Some(size) = ::micropb::const_map!(
            ::micropb::const_map!(
                <r#wifi_country as ::micropb::MessageEncode>::MAX_SIZE,
                |size| ::micropb::size::sizeof_len_record(size)
            ),
            |size| size + 1usize
        ) {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        ::core::option::Option::Some(max_size)
    };
    fn encode<IMPL_MICROPB_WRITE: ::micropb::PbWrite>(
        &self,
        encoder: &mut ::micropb::PbEncoder<IMPL_MICROPB_WRITE>,
    ) -> Result<(), IMPL_MICROPB_WRITE::Error> {
        use ::micropb::{FieldEncode, PbMap};
        {
            let val_ref = &self.r#resp;
            if *val_ref != 0 {
                encoder.encode_varint32(8u32)?;
                encoder.encode_int32(*val_ref as _)?;
            }
        }
        {
            if let ::core::option::Option::Some(val_ref) = self.r#country() {
                encoder.encode_varint32(18u32)?;
                val_ref.encode_len_delimited(encoder)?;
            }
        }
        Ok(())
    }
    fn compute_size(&self) -> usize {
        use ::micropb::{FieldEncode, PbMap};
        let mut size = 0;
        {
            let val_ref = &self.r#resp;
            if *val_ref != 0 {
                size += 1usize + ::micropb::size::sizeof_int32(*val_ref as _);
            }
        }
        {
            if let ::core::option::Option::Some(val_ref) = self.r#country() {
                size += 1usize + ::micropb::size::sizeof_len_record(val_ref.compute_size());
            }
        }
        size
    }
}
#[derive(Debug, Default, PartialEq, Clone)]
pub struct Rpc_Req_WifiApGetStaList {}
impl Rpc_Req_WifiApGetStaList {}
impl ::micropb::MessageDecode for Rpc_Req_WifiApGetStaList {
    fn decode<IMPL_MICROPB_READ: ::micropb::PbRead>(
        &mut self,
        decoder: &mut ::micropb::PbDecoder<IMPL_MICROPB_READ>,
        len: usize,
    ) -> Result<(), ::micropb::DecodeError<IMPL_MICROPB_READ::Error>> {
        use ::micropb::{FieldDecode, PbBytes, PbMap, PbString, PbVec};
        let before = decoder.bytes_read();
        while decoder.bytes_read() - before < len {
            let tag = decoder.decode_tag()?;
            match tag.field_num() {
                0 => return Err(::micropb::DecodeError::ZeroField),
                _ => {
                    decoder.skip_wire_value(tag.wire_type())?;
                }
            }
        }
        Ok(())
    }
}
impl ::micropb::MessageEncode for Rpc_Req_WifiApGetStaList {
    const MAX_SIZE: ::core::option::Option<usize> = 'msg: {
        let mut max_size = 0;
        ::core::option::Option::Some(max_size)
    };
    fn encode<IMPL_MICROPB_WRITE: ::micropb::PbWrite>(
        &self,
        encoder: &mut ::micropb::PbEncoder<IMPL_MICROPB_WRITE>,
    ) -> Result<(), IMPL_MICROPB_WRITE::Error> {
        use ::micropb::{FieldEncode, PbMap};
        Ok(())
    }
    fn compute_size(&self) -> usize {
        use ::micropb::{FieldEncode, PbMap};
        let mut size = 0;
        size
    }
}
pub mod Rpc_Resp_WifiApGetStaList_ {
    #[derive(Debug, Default, PartialEq, Clone)]
    pub struct _Hazzer([u8; 1]);
    impl _Hazzer {
        ///New hazzer with all fields set to off
        #[inline]
        pub const fn _new() -> Self {
            Self([0; 1])
        }
        ///Query presence of `sta_list`
        #[inline]
        pub const fn r#sta_list(&self) -> bool {
            (self.0[0] & 1) != 0
        }
        ///Set presence of `sta_list`
        #[inline]
        pub const fn set_sta_list(&mut self) -> &mut Self {
            let elem = &mut self.0[0];
            *elem |= 1;
            self
        }
        ///Clear presence of `sta_list`
        #[inline]
        pub const fn clear_sta_list(&mut self) -> &mut Self {
            let elem = &mut self.0[0];
            *elem &= !1;
            self
        }
        ///Builder method that sets the presence of `sta_list`. Useful for initializing the Hazzer.
        #[inline]
        pub const fn init_sta_list(mut self) -> Self {
            self.set_sta_list();
            self
        }
    }
}
#[derive(Debug, Default, Clone)]
pub struct Rpc_Resp_WifiApGetStaList {
    pub r#resp: i32,
    pub r#sta_list: r#wifi_sta_list,
    pub _has: Rpc_Resp_WifiApGetStaList_::_Hazzer,
}
impl ::core::cmp::PartialEq for Rpc_Resp_WifiApGetStaList {
    fn eq(&self, other: &Self) -> bool {
        let mut ret = true;
        ret &= (self.r#resp == other.r#resp);
        ret &= (self.r#sta_list() == other.r#sta_list());
        ret
    }
}
impl Rpc_Resp_WifiApGetStaList {
    ///Return a reference to `resp`
    #[inline]
    pub fn r#resp(&self) -> &i32 {
        &self.r#resp
    }
    ///Return a mutable reference to `resp`
    #[inline]
    pub fn mut_resp(&mut self) -> &mut i32 {
        &mut self.r#resp
    }
    ///Set the value of `resp`
    #[inline]
    pub fn set_resp(&mut self, value: i32) -> &mut Self {
        self.r#resp = value.into();
        self
    }
    ///Builder method that sets the value of `resp`. Useful for initializing the message.
    #[inline]
    pub fn init_resp(mut self, value: i32) -> Self {
        self.r#resp = value.into();
        self
    }
    ///Return a reference to `sta_list` as an `Option`
    #[inline]
    pub fn r#sta_list(&self) -> ::core::option::Option<&r#wifi_sta_list> {
        self._has.r#sta_list().then_some(&self.r#sta_list)
    }
    ///Set the value and presence of `sta_list`
    #[inline]
    pub fn set_sta_list(&mut self, value: r#wifi_sta_list) -> &mut Self {
        self._has.set_sta_list();
        self.r#sta_list = value.into();
        self
    }
    ///Return a mutable reference to `sta_list` as an `Option`
    #[inline]
    pub fn mut_sta_list(&mut self) -> ::core::option::Option<&mut r#wifi_sta_list> {
        self._has.r#sta_list().then_some(&mut self.r#sta_list)
    }
    ///Clear the presence of `sta_list`
    #[inline]
    pub fn clear_sta_list(&mut self) -> &mut Self {
        self._has.clear_sta_list();
        self
    }
    ///Take the value of `sta_list` and clear its presence
    #[inline]
    pub fn take_sta_list(&mut self) -> ::core::option::Option<r#wifi_sta_list> {
        let val = self
            ._has
            .r#sta_list()
            .then(|| ::core::mem::take(&mut self.r#sta_list));
        self._has.clear_sta_list();
        val
    }
    ///Builder method that sets the value of `sta_list`. Useful for initializing the message.
    #[inline]
    pub fn init_sta_list(mut self, value: r#wifi_sta_list) -> Self {
        self.set_sta_list(value);
        self
    }
}
impl ::micropb::MessageDecode for Rpc_Resp_WifiApGetStaList {
    fn decode<IMPL_MICROPB_READ: ::micropb::PbRead>(
        &mut self,
        decoder: &mut ::micropb::PbDecoder<IMPL_MICROPB_READ>,
        len: usize,
    ) -> Result<(), ::micropb::DecodeError<IMPL_MICROPB_READ::Error>> {
        use ::micropb::{FieldDecode, PbBytes, PbMap, PbString, PbVec};
        let before = decoder.bytes_read();
        while decoder.bytes_read() - before < len {
            let tag = decoder.decode_tag()?;
            match tag.field_num() {
                0 => return Err(::micropb::DecodeError::ZeroField),
                1u32 => {
                    let mut_ref = &mut self.r#resp;
                    {
                        let val = decoder.decode_int32()?;
                        let val_ref = &val;
                        if *val_ref != 0 {
                            *mut_ref = val as _;
                        }
                    };
                }
                2u32 => {
                    let mut_ref = &mut self.r#sta_list;
                    {
                        mut_ref.decode_len_delimited(decoder)?;
                    };
                    self._has.set_sta_list();
                }
                _ => {
                    decoder.skip_wire_value(tag.wire_type())?;
                }
            }
        }
        Ok(())
    }
}
impl ::micropb::MessageEncode for Rpc_Resp_WifiApGetStaList {
    const MAX_SIZE: ::core::option::Option<usize> = 'msg: {
        let mut max_size = 0;
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(10usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        if let ::core::option::Option::Some(size) = ::micropb::const_map!(
            ::micropb::const_map!(
                <r#wifi_sta_list as ::micropb::MessageEncode>::MAX_SIZE,
                |size| ::micropb::size::sizeof_len_record(size)
            ),
            |size| size + 1usize
        ) {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        ::core::option::Option::Some(max_size)
    };
    fn encode<IMPL_MICROPB_WRITE: ::micropb::PbWrite>(
        &self,
        encoder: &mut ::micropb::PbEncoder<IMPL_MICROPB_WRITE>,
    ) -> Result<(), IMPL_MICROPB_WRITE::Error> {
        use ::micropb::{FieldEncode, PbMap};
        {
            let val_ref = &self.r#resp;
            if *val_ref != 0 {
                encoder.encode_varint32(8u32)?;
                encoder.encode_int32(*val_ref as _)?;
            }
        }
        {
            if let ::core::option::Option::Some(val_ref) = self.r#sta_list() {
                encoder.encode_varint32(18u32)?;
                val_ref.encode_len_delimited(encoder)?;
            }
        }
        Ok(())
    }
    fn compute_size(&self) -> usize {
        use ::micropb::{FieldEncode, PbMap};
        let mut size = 0;
        {
            let val_ref = &self.r#resp;
            if *val_ref != 0 {
                size += 1usize + ::micropb::size::sizeof_int32(*val_ref as _);
            }
        }
        {
            if let ::core::option::Option::Some(val_ref) = self.r#sta_list() {
                size += 1usize + ::micropb::size::sizeof_len_record(val_ref.compute_size());
            }
        }
        size
    }
}
#[derive(Debug, Default, PartialEq, Clone)]
pub struct Rpc_Req_WifiApGetStaAid {
    pub r#mac: ::micropb::heapless::Vec<u8, 6>,
}
impl Rpc_Req_WifiApGetStaAid {
    ///Return a reference to `mac`
    #[inline]
    pub fn r#mac(&self) -> &::micropb::heapless::Vec<u8, 6> {
        &self.r#mac
    }
    ///Return a mutable reference to `mac`
    #[inline]
    pub fn mut_mac(&mut self) -> &mut ::micropb::heapless::Vec<u8, 6> {
        &mut self.r#mac
    }
    ///Set the value of `mac`
    #[inline]
    pub fn set_mac(&mut self, value: ::micropb::heapless::Vec<u8, 6>) -> &mut Self {
        self.r#mac = value.into();
        self
    }
    ///Builder method that sets the value of `mac`. Useful for initializing the message.
    #[inline]
    pub fn init_mac(mut self, value: ::micropb::heapless::Vec<u8, 6>) -> Self {
        self.r#mac = value.into();
        self
    }
}
impl ::micropb::MessageDecode for Rpc_Req_WifiApGetStaAid {
    fn decode<IMPL_MICROPB_READ: ::micropb::PbRead>(
        &mut self,
        decoder: &mut ::micropb::PbDecoder<IMPL_MICROPB_READ>,
        len: usize,
    ) -> Result<(), ::micropb::DecodeError<IMPL_MICROPB_READ::Error>> {
        use ::micropb::{FieldDecode, PbBytes, PbMap, PbString, PbVec};
        let before = decoder.bytes_read();
        while decoder.bytes_read() - before < len {
            let tag = decoder.decode_tag()?;
            match tag.field_num() {
                0 => return Err(::micropb::DecodeError::ZeroField),
                1u32 => {
                    let mut_ref = &mut self.r#mac;
                    {
                        decoder.decode_bytes(mut_ref, ::micropb::Presence::Implicit)?;
                    };
                }
                _ => {
                    decoder.skip_wire_value(tag.wire_type())?;
                }
            }
        }
        Ok(())
    }
}
impl ::micropb::MessageEncode for Rpc_Req_WifiApGetStaAid {
    const MAX_SIZE: ::core::option::Option<usize> = 'msg: {
        let mut max_size = 0;
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(7usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        ::core::option::Option::Some(max_size)
    };
    fn encode<IMPL_MICROPB_WRITE: ::micropb::PbWrite>(
        &self,
        encoder: &mut ::micropb::PbEncoder<IMPL_MICROPB_WRITE>,
    ) -> Result<(), IMPL_MICROPB_WRITE::Error> {
        use ::micropb::{FieldEncode, PbMap};
        {
            let val_ref = &self.r#mac;
            if !val_ref.is_empty() {
                encoder.encode_varint32(10u32)?;
                encoder.encode_bytes(val_ref)?;
            }
        }
        Ok(())
    }
    fn compute_size(&self) -> usize {
        use ::micropb::{FieldEncode, PbMap};
        let mut size = 0;
        {
            let val_ref = &self.r#mac;
            if !val_ref.is_empty() {
                size += 1usize + ::micropb::size::sizeof_len_record(val_ref.len());
            }
        }
        size
    }
}
#[derive(Debug, Default, PartialEq, Clone)]
pub struct Rpc_Req_WifiStaGetNegotiatedPhymode {}
impl Rpc_Req_WifiStaGetNegotiatedPhymode {}
impl ::micropb::MessageDecode for Rpc_Req_WifiStaGetNegotiatedPhymode {
    fn decode<IMPL_MICROPB_READ: ::micropb::PbRead>(
        &mut self,
        decoder: &mut ::micropb::PbDecoder<IMPL_MICROPB_READ>,
        len: usize,
    ) -> Result<(), ::micropb::DecodeError<IMPL_MICROPB_READ::Error>> {
        use ::micropb::{FieldDecode, PbBytes, PbMap, PbString, PbVec};
        let before = decoder.bytes_read();
        while decoder.bytes_read() - before < len {
            let tag = decoder.decode_tag()?;
            match tag.field_num() {
                0 => return Err(::micropb::DecodeError::ZeroField),
                _ => {
                    decoder.skip_wire_value(tag.wire_type())?;
                }
            }
        }
        Ok(())
    }
}
impl ::micropb::MessageEncode for Rpc_Req_WifiStaGetNegotiatedPhymode {
    const MAX_SIZE: ::core::option::Option<usize> = 'msg: {
        let mut max_size = 0;
        ::core::option::Option::Some(max_size)
    };
    fn encode<IMPL_MICROPB_WRITE: ::micropb::PbWrite>(
        &self,
        encoder: &mut ::micropb::PbEncoder<IMPL_MICROPB_WRITE>,
    ) -> Result<(), IMPL_MICROPB_WRITE::Error> {
        use ::micropb::{FieldEncode, PbMap};
        Ok(())
    }
    fn compute_size(&self) -> usize {
        use ::micropb::{FieldEncode, PbMap};
        let mut size = 0;
        size
    }
}
#[derive(Debug, Default, PartialEq, Clone)]
pub struct Rpc_Resp_WifiStaGetNegotiatedPhymode {
    pub r#resp: i32,
    pub r#phymode: u32,
}
impl Rpc_Resp_WifiStaGetNegotiatedPhymode {
    ///Return a reference to `resp`
    #[inline]
    pub fn r#resp(&self) -> &i32 {
        &self.r#resp
    }
    ///Return a mutable reference to `resp`
    #[inline]
    pub fn mut_resp(&mut self) -> &mut i32 {
        &mut self.r#resp
    }
    ///Set the value of `resp`
    #[inline]
    pub fn set_resp(&mut self, value: i32) -> &mut Self {
        self.r#resp = value.into();
        self
    }
    ///Builder method that sets the value of `resp`. Useful for initializing the message.
    #[inline]
    pub fn init_resp(mut self, value: i32) -> Self {
        self.r#resp = value.into();
        self
    }
    ///Return a reference to `phymode`
    #[inline]
    pub fn r#phymode(&self) -> &u32 {
        &self.r#phymode
    }
    ///Return a mutable reference to `phymode`
    #[inline]
    pub fn mut_phymode(&mut self) -> &mut u32 {
        &mut self.r#phymode
    }
    ///Set the value of `phymode`
    #[inline]
    pub fn set_phymode(&mut self, value: u32) -> &mut Self {
        self.r#phymode = value.into();
        self
    }
    ///Builder method that sets the value of `phymode`. Useful for initializing the message.
    #[inline]
    pub fn init_phymode(mut self, value: u32) -> Self {
        self.r#phymode = value.into();
        self
    }
}
impl ::micropb::MessageDecode for Rpc_Resp_WifiStaGetNegotiatedPhymode {
    fn decode<IMPL_MICROPB_READ: ::micropb::PbRead>(
        &mut self,
        decoder: &mut ::micropb::PbDecoder<IMPL_MICROPB_READ>,
        len: usize,
    ) -> Result<(), ::micropb::DecodeError<IMPL_MICROPB_READ::Error>> {
        use ::micropb::{FieldDecode, PbBytes, PbMap, PbString, PbVec};
        let before = decoder.bytes_read();
        while decoder.bytes_read() - before < len {
            let tag = decoder.decode_tag()?;
            match tag.field_num() {
                0 => return Err(::micropb::DecodeError::ZeroField),
                1u32 => {
                    let mut_ref = &mut self.r#resp;
                    {
                        let val = decoder.decode_int32()?;
                        let val_ref = &val;
                        if *val_ref != 0 {
                            *mut_ref = val as _;
                        }
                    };
                }
                2u32 => {
                    let mut_ref = &mut self.r#phymode;
                    {
                        let val = decoder.decode_varint32()?;
                        let val_ref = &val;
                        if *val_ref != 0 {
                            *mut_ref = val as _;
                        }
                    };
                }
                _ => {
                    decoder.skip_wire_value(tag.wire_type())?;
                }
            }
        }
        Ok(())
    }
}
impl ::micropb::MessageEncode for Rpc_Resp_WifiStaGetNegotiatedPhymode {
    const MAX_SIZE: ::core::option::Option<usize> = 'msg: {
        let mut max_size = 0;
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(10usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(5usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        ::core::option::Option::Some(max_size)
    };
    fn encode<IMPL_MICROPB_WRITE: ::micropb::PbWrite>(
        &self,
        encoder: &mut ::micropb::PbEncoder<IMPL_MICROPB_WRITE>,
    ) -> Result<(), IMPL_MICROPB_WRITE::Error> {
        use ::micropb::{FieldEncode, PbMap};
        {
            let val_ref = &self.r#resp;
            if *val_ref != 0 {
                encoder.encode_varint32(8u32)?;
                encoder.encode_int32(*val_ref as _)?;
            }
        }
        {
            let val_ref = &self.r#phymode;
            if *val_ref != 0 {
                encoder.encode_varint32(16u32)?;
                encoder.encode_varint32(*val_ref as _)?;
            }
        }
        Ok(())
    }
    fn compute_size(&self) -> usize {
        use ::micropb::{FieldEncode, PbMap};
        let mut size = 0;
        {
            let val_ref = &self.r#resp;
            if *val_ref != 0 {
                size += 1usize + ::micropb::size::sizeof_int32(*val_ref as _);
            }
        }
        {
            let val_ref = &self.r#phymode;
            if *val_ref != 0 {
                size += 1usize + ::micropb::size::sizeof_varint32(*val_ref as _);
            }
        }
        size
    }
}
#[derive(Debug, Default, PartialEq, Clone)]
pub struct Rpc_Resp_WifiApGetStaAid {
    pub r#resp: i32,
    pub r#aid: u32,
}
impl Rpc_Resp_WifiApGetStaAid {
    ///Return a reference to `resp`
    #[inline]
    pub fn r#resp(&self) -> &i32 {
        &self.r#resp
    }
    ///Return a mutable reference to `resp`
    #[inline]
    pub fn mut_resp(&mut self) -> &mut i32 {
        &mut self.r#resp
    }
    ///Set the value of `resp`
    #[inline]
    pub fn set_resp(&mut self, value: i32) -> &mut Self {
        self.r#resp = value.into();
        self
    }
    ///Builder method that sets the value of `resp`. Useful for initializing the message.
    #[inline]
    pub fn init_resp(mut self, value: i32) -> Self {
        self.r#resp = value.into();
        self
    }
    ///Return a reference to `aid`
    #[inline]
    pub fn r#aid(&self) -> &u32 {
        &self.r#aid
    }
    ///Return a mutable reference to `aid`
    #[inline]
    pub fn mut_aid(&mut self) -> &mut u32 {
        &mut self.r#aid
    }
    ///Set the value of `aid`
    #[inline]
    pub fn set_aid(&mut self, value: u32) -> &mut Self {
        self.r#aid = value.into();
        self
    }
    ///Builder method that sets the value of `aid`. Useful for initializing the message.
    #[inline]
    pub fn init_aid(mut self, value: u32) -> Self {
        self.r#aid = value.into();
        self
    }
}
impl ::micropb::MessageDecode for Rpc_Resp_WifiApGetStaAid {
    fn decode<IMPL_MICROPB_READ: ::micropb::PbRead>(
        &mut self,
        decoder: &mut ::micropb::PbDecoder<IMPL_MICROPB_READ>,
        len: usize,
    ) -> Result<(), ::micropb::DecodeError<IMPL_MICROPB_READ::Error>> {
        use ::micropb::{FieldDecode, PbBytes, PbMap, PbString, PbVec};
        let before = decoder.bytes_read();
        while decoder.bytes_read() - before < len {
            let tag = decoder.decode_tag()?;
            match tag.field_num() {
                0 => return Err(::micropb::DecodeError::ZeroField),
                1u32 => {
                    let mut_ref = &mut self.r#resp;
                    {
                        let val = decoder.decode_int32()?;
                        let val_ref = &val;
                        if *val_ref != 0 {
                            *mut_ref = val as _;
                        }
                    };
                }
                2u32 => {
                    let mut_ref = &mut self.r#aid;
                    {
                        let val = decoder.decode_varint32()?;
                        let val_ref = &val;
                        if *val_ref != 0 {
                            *mut_ref = val as _;
                        }
                    };
                }
                _ => {
                    decoder.skip_wire_value(tag.wire_type())?;
                }
            }
        }
        Ok(())
    }
}
impl ::micropb::MessageEncode for Rpc_Resp_WifiApGetStaAid {
    const MAX_SIZE: ::core::option::Option<usize> = 'msg: {
        let mut max_size = 0;
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(10usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(5usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        ::core::option::Option::Some(max_size)
    };
    fn encode<IMPL_MICROPB_WRITE: ::micropb::PbWrite>(
        &self,
        encoder: &mut ::micropb::PbEncoder<IMPL_MICROPB_WRITE>,
    ) -> Result<(), IMPL_MICROPB_WRITE::Error> {
        use ::micropb::{FieldEncode, PbMap};
        {
            let val_ref = &self.r#resp;
            if *val_ref != 0 {
                encoder.encode_varint32(8u32)?;
                encoder.encode_int32(*val_ref as _)?;
            }
        }
        {
            let val_ref = &self.r#aid;
            if *val_ref != 0 {
                encoder.encode_varint32(16u32)?;
                encoder.encode_varint32(*val_ref as _)?;
            }
        }
        Ok(())
    }
    fn compute_size(&self) -> usize {
        use ::micropb::{FieldEncode, PbMap};
        let mut size = 0;
        {
            let val_ref = &self.r#resp;
            if *val_ref != 0 {
                size += 1usize + ::micropb::size::sizeof_int32(*val_ref as _);
            }
        }
        {
            let val_ref = &self.r#aid;
            if *val_ref != 0 {
                size += 1usize + ::micropb::size::sizeof_varint32(*val_ref as _);
            }
        }
        size
    }
}
#[derive(Debug, Default, PartialEq, Clone)]
pub struct Rpc_Req_WifiStaGetRssi {}
impl Rpc_Req_WifiStaGetRssi {}
impl ::micropb::MessageDecode for Rpc_Req_WifiStaGetRssi {
    fn decode<IMPL_MICROPB_READ: ::micropb::PbRead>(
        &mut self,
        decoder: &mut ::micropb::PbDecoder<IMPL_MICROPB_READ>,
        len: usize,
    ) -> Result<(), ::micropb::DecodeError<IMPL_MICROPB_READ::Error>> {
        use ::micropb::{FieldDecode, PbBytes, PbMap, PbString, PbVec};
        let before = decoder.bytes_read();
        while decoder.bytes_read() - before < len {
            let tag = decoder.decode_tag()?;
            match tag.field_num() {
                0 => return Err(::micropb::DecodeError::ZeroField),
                _ => {
                    decoder.skip_wire_value(tag.wire_type())?;
                }
            }
        }
        Ok(())
    }
}
impl ::micropb::MessageEncode for Rpc_Req_WifiStaGetRssi {
    const MAX_SIZE: ::core::option::Option<usize> = 'msg: {
        let mut max_size = 0;
        ::core::option::Option::Some(max_size)
    };
    fn encode<IMPL_MICROPB_WRITE: ::micropb::PbWrite>(
        &self,
        encoder: &mut ::micropb::PbEncoder<IMPL_MICROPB_WRITE>,
    ) -> Result<(), IMPL_MICROPB_WRITE::Error> {
        use ::micropb::{FieldEncode, PbMap};
        Ok(())
    }
    fn compute_size(&self) -> usize {
        use ::micropb::{FieldEncode, PbMap};
        let mut size = 0;
        size
    }
}
#[derive(Debug, Default, PartialEq, Clone)]
pub struct Rpc_Resp_WifiStaGetRssi {
    pub r#resp: i32,
    pub r#rssi: i32,
}
impl Rpc_Resp_WifiStaGetRssi {
    ///Return a reference to `resp`
    #[inline]
    pub fn r#resp(&self) -> &i32 {
        &self.r#resp
    }
    ///Return a mutable reference to `resp`
    #[inline]
    pub fn mut_resp(&mut self) -> &mut i32 {
        &mut self.r#resp
    }
    ///Set the value of `resp`
    #[inline]
    pub fn set_resp(&mut self, value: i32) -> &mut Self {
        self.r#resp = value.into();
        self
    }
    ///Builder method that sets the value of `resp`. Useful for initializing the message.
    #[inline]
    pub fn init_resp(mut self, value: i32) -> Self {
        self.r#resp = value.into();
        self
    }
    ///Return a reference to `rssi`
    #[inline]
    pub fn r#rssi(&self) -> &i32 {
        &self.r#rssi
    }
    ///Return a mutable reference to `rssi`
    #[inline]
    pub fn mut_rssi(&mut self) -> &mut i32 {
        &mut self.r#rssi
    }
    ///Set the value of `rssi`
    #[inline]
    pub fn set_rssi(&mut self, value: i32) -> &mut Self {
        self.r#rssi = value.into();
        self
    }
    ///Builder method that sets the value of `rssi`. Useful for initializing the message.
    #[inline]
    pub fn init_rssi(mut self, value: i32) -> Self {
        self.r#rssi = value.into();
        self
    }
}
impl ::micropb::MessageDecode for Rpc_Resp_WifiStaGetRssi {
    fn decode<IMPL_MICROPB_READ: ::micropb::PbRead>(
        &mut self,
        decoder: &mut ::micropb::PbDecoder<IMPL_MICROPB_READ>,
        len: usize,
    ) -> Result<(), ::micropb::DecodeError<IMPL_MICROPB_READ::Error>> {
        use ::micropb::{FieldDecode, PbBytes, PbMap, PbString, PbVec};
        let before = decoder.bytes_read();
        while decoder.bytes_read() - before < len {
            let tag = decoder.decode_tag()?;
            match tag.field_num() {
                0 => return Err(::micropb::DecodeError::ZeroField),
                1u32 => {
                    let mut_ref = &mut self.r#resp;
                    {
                        let val = decoder.decode_int32()?;
                        let val_ref = &val;
                        if *val_ref != 0 {
                            *mut_ref = val as _;
                        }
                    };
                }
                2u32 => {
                    let mut_ref = &mut self.r#rssi;
                    {
                        let val = decoder.decode_int32()?;
                        let val_ref = &val;
                        if *val_ref != 0 {
                            *mut_ref = val as _;
                        }
                    };
                }
                _ => {
                    decoder.skip_wire_value(tag.wire_type())?;
                }
            }
        }
        Ok(())
    }
}
impl ::micropb::MessageEncode for Rpc_Resp_WifiStaGetRssi {
    const MAX_SIZE: ::core::option::Option<usize> = 'msg: {
        let mut max_size = 0;
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(10usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(10usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        ::core::option::Option::Some(max_size)
    };
    fn encode<IMPL_MICROPB_WRITE: ::micropb::PbWrite>(
        &self,
        encoder: &mut ::micropb::PbEncoder<IMPL_MICROPB_WRITE>,
    ) -> Result<(), IMPL_MICROPB_WRITE::Error> {
        use ::micropb::{FieldEncode, PbMap};
        {
            let val_ref = &self.r#resp;
            if *val_ref != 0 {
                encoder.encode_varint32(8u32)?;
                encoder.encode_int32(*val_ref as _)?;
            }
        }
        {
            let val_ref = &self.r#rssi;
            if *val_ref != 0 {
                encoder.encode_varint32(16u32)?;
                encoder.encode_int32(*val_ref as _)?;
            }
        }
        Ok(())
    }
    fn compute_size(&self) -> usize {
        use ::micropb::{FieldEncode, PbMap};
        let mut size = 0;
        {
            let val_ref = &self.r#resp;
            if *val_ref != 0 {
                size += 1usize + ::micropb::size::sizeof_int32(*val_ref as _);
            }
        }
        {
            let val_ref = &self.r#rssi;
            if *val_ref != 0 {
                size += 1usize + ::micropb::size::sizeof_int32(*val_ref as _);
            }
        }
        size
    }
}
#[derive(Debug, Default, PartialEq, Clone)]
pub struct Rpc_Req_WifiStaGetAid {}
impl Rpc_Req_WifiStaGetAid {}
impl ::micropb::MessageDecode for Rpc_Req_WifiStaGetAid {
    fn decode<IMPL_MICROPB_READ: ::micropb::PbRead>(
        &mut self,
        decoder: &mut ::micropb::PbDecoder<IMPL_MICROPB_READ>,
        len: usize,
    ) -> Result<(), ::micropb::DecodeError<IMPL_MICROPB_READ::Error>> {
        use ::micropb::{FieldDecode, PbBytes, PbMap, PbString, PbVec};
        let before = decoder.bytes_read();
        while decoder.bytes_read() - before < len {
            let tag = decoder.decode_tag()?;
            match tag.field_num() {
                0 => return Err(::micropb::DecodeError::ZeroField),
                _ => {
                    decoder.skip_wire_value(tag.wire_type())?;
                }
            }
        }
        Ok(())
    }
}
impl ::micropb::MessageEncode for Rpc_Req_WifiStaGetAid {
    const MAX_SIZE: ::core::option::Option<usize> = 'msg: {
        let mut max_size = 0;
        ::core::option::Option::Some(max_size)
    };
    fn encode<IMPL_MICROPB_WRITE: ::micropb::PbWrite>(
        &self,
        encoder: &mut ::micropb::PbEncoder<IMPL_MICROPB_WRITE>,
    ) -> Result<(), IMPL_MICROPB_WRITE::Error> {
        use ::micropb::{FieldEncode, PbMap};
        Ok(())
    }
    fn compute_size(&self) -> usize {
        use ::micropb::{FieldEncode, PbMap};
        let mut size = 0;
        size
    }
}
#[derive(Debug, Default, PartialEq, Clone)]
pub struct Rpc_Resp_WifiStaGetAid {
    pub r#resp: i32,
    pub r#aid: u32,
}
impl Rpc_Resp_WifiStaGetAid {
    ///Return a reference to `resp`
    #[inline]
    pub fn r#resp(&self) -> &i32 {
        &self.r#resp
    }
    ///Return a mutable reference to `resp`
    #[inline]
    pub fn mut_resp(&mut self) -> &mut i32 {
        &mut self.r#resp
    }
    ///Set the value of `resp`
    #[inline]
    pub fn set_resp(&mut self, value: i32) -> &mut Self {
        self.r#resp = value.into();
        self
    }
    ///Builder method that sets the value of `resp`. Useful for initializing the message.
    #[inline]
    pub fn init_resp(mut self, value: i32) -> Self {
        self.r#resp = value.into();
        self
    }
    ///Return a reference to `aid`
    #[inline]
    pub fn r#aid(&self) -> &u32 {
        &self.r#aid
    }
    ///Return a mutable reference to `aid`
    #[inline]
    pub fn mut_aid(&mut self) -> &mut u32 {
        &mut self.r#aid
    }
    ///Set the value of `aid`
    #[inline]
    pub fn set_aid(&mut self, value: u32) -> &mut Self {
        self.r#aid = value.into();
        self
    }
    ///Builder method that sets the value of `aid`. Useful for initializing the message.
    #[inline]
    pub fn init_aid(mut self, value: u32) -> Self {
        self.r#aid = value.into();
        self
    }
}
impl ::micropb::MessageDecode for Rpc_Resp_WifiStaGetAid {
    fn decode<IMPL_MICROPB_READ: ::micropb::PbRead>(
        &mut self,
        decoder: &mut ::micropb::PbDecoder<IMPL_MICROPB_READ>,
        len: usize,
    ) -> Result<(), ::micropb::DecodeError<IMPL_MICROPB_READ::Error>> {
        use ::micropb::{FieldDecode, PbBytes, PbMap, PbString, PbVec};
        let before = decoder.bytes_read();
        while decoder.bytes_read() - before < len {
            let tag = decoder.decode_tag()?;
            match tag.field_num() {
                0 => return Err(::micropb::DecodeError::ZeroField),
                1u32 => {
                    let mut_ref = &mut self.r#resp;
                    {
                        let val = decoder.decode_int32()?;
                        let val_ref = &val;
                        if *val_ref != 0 {
                            *mut_ref = val as _;
                        }
                    };
                }
                2u32 => {
                    let mut_ref = &mut self.r#aid;
                    {
                        let val = decoder.decode_varint32()?;
                        let val_ref = &val;
                        if *val_ref != 0 {
                            *mut_ref = val as _;
                        }
                    };
                }
                _ => {
                    decoder.skip_wire_value(tag.wire_type())?;
                }
            }
        }
        Ok(())
    }
}
impl ::micropb::MessageEncode for Rpc_Resp_WifiStaGetAid {
    const MAX_SIZE: ::core::option::Option<usize> = 'msg: {
        let mut max_size = 0;
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(10usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(5usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        ::core::option::Option::Some(max_size)
    };
    fn encode<IMPL_MICROPB_WRITE: ::micropb::PbWrite>(
        &self,
        encoder: &mut ::micropb::PbEncoder<IMPL_MICROPB_WRITE>,
    ) -> Result<(), IMPL_MICROPB_WRITE::Error> {
        use ::micropb::{FieldEncode, PbMap};
        {
            let val_ref = &self.r#resp;
            if *val_ref != 0 {
                encoder.encode_varint32(8u32)?;
                encoder.encode_int32(*val_ref as _)?;
            }
        }
        {
            let val_ref = &self.r#aid;
            if *val_ref != 0 {
                encoder.encode_varint32(16u32)?;
                encoder.encode_varint32(*val_ref as _)?;
            }
        }
        Ok(())
    }
    fn compute_size(&self) -> usize {
        use ::micropb::{FieldEncode, PbMap};
        let mut size = 0;
        {
            let val_ref = &self.r#resp;
            if *val_ref != 0 {
                size += 1usize + ::micropb::size::sizeof_int32(*val_ref as _);
            }
        }
        {
            let val_ref = &self.r#aid;
            if *val_ref != 0 {
                size += 1usize + ::micropb::size::sizeof_varint32(*val_ref as _);
            }
        }
        size
    }
}
pub mod Rpc_Req_WifiSetProtocols_ {
    #[derive(Debug, Default, PartialEq, Clone)]
    pub struct _Hazzer([u8; 1]);
    impl _Hazzer {
        ///New hazzer with all fields set to off
        #[inline]
        pub const fn _new() -> Self {
            Self([0; 1])
        }
        ///Query presence of `protocols`
        #[inline]
        pub const fn r#protocols(&self) -> bool {
            (self.0[0] & 1) != 0
        }
        ///Set presence of `protocols`
        #[inline]
        pub const fn set_protocols(&mut self) -> &mut Self {
            let elem = &mut self.0[0];
            *elem |= 1;
            self
        }
        ///Clear presence of `protocols`
        #[inline]
        pub const fn clear_protocols(&mut self) -> &mut Self {
            let elem = &mut self.0[0];
            *elem &= !1;
            self
        }
        ///Builder method that sets the presence of `protocols`. Useful for initializing the Hazzer.
        #[inline]
        pub const fn init_protocols(mut self) -> Self {
            self.set_protocols();
            self
        }
    }
}
#[derive(Debug, Default, Clone)]
pub struct Rpc_Req_WifiSetProtocols {
    pub r#ifx: i32,
    pub r#protocols: r#wifi_protocols,
    pub _has: Rpc_Req_WifiSetProtocols_::_Hazzer,
}
impl ::core::cmp::PartialEq for Rpc_Req_WifiSetProtocols {
    fn eq(&self, other: &Self) -> bool {
        let mut ret = true;
        ret &= (self.r#ifx == other.r#ifx);
        ret &= (self.r#protocols() == other.r#protocols());
        ret
    }
}
impl Rpc_Req_WifiSetProtocols {
    ///Return a reference to `ifx`
    #[inline]
    pub fn r#ifx(&self) -> &i32 {
        &self.r#ifx
    }
    ///Return a mutable reference to `ifx`
    #[inline]
    pub fn mut_ifx(&mut self) -> &mut i32 {
        &mut self.r#ifx
    }
    ///Set the value of `ifx`
    #[inline]
    pub fn set_ifx(&mut self, value: i32) -> &mut Self {
        self.r#ifx = value.into();
        self
    }
    ///Builder method that sets the value of `ifx`. Useful for initializing the message.
    #[inline]
    pub fn init_ifx(mut self, value: i32) -> Self {
        self.r#ifx = value.into();
        self
    }
    ///Return a reference to `protocols` as an `Option`
    #[inline]
    pub fn r#protocols(&self) -> ::core::option::Option<&r#wifi_protocols> {
        self._has.r#protocols().then_some(&self.r#protocols)
    }
    ///Set the value and presence of `protocols`
    #[inline]
    pub fn set_protocols(&mut self, value: r#wifi_protocols) -> &mut Self {
        self._has.set_protocols();
        self.r#protocols = value.into();
        self
    }
    ///Return a mutable reference to `protocols` as an `Option`
    #[inline]
    pub fn mut_protocols(&mut self) -> ::core::option::Option<&mut r#wifi_protocols> {
        self._has.r#protocols().then_some(&mut self.r#protocols)
    }
    ///Clear the presence of `protocols`
    #[inline]
    pub fn clear_protocols(&mut self) -> &mut Self {
        self._has.clear_protocols();
        self
    }
    ///Take the value of `protocols` and clear its presence
    #[inline]
    pub fn take_protocols(&mut self) -> ::core::option::Option<r#wifi_protocols> {
        let val = self
            ._has
            .r#protocols()
            .then(|| ::core::mem::take(&mut self.r#protocols));
        self._has.clear_protocols();
        val
    }
    ///Builder method that sets the value of `protocols`. Useful for initializing the message.
    #[inline]
    pub fn init_protocols(mut self, value: r#wifi_protocols) -> Self {
        self.set_protocols(value);
        self
    }
}
impl ::micropb::MessageDecode for Rpc_Req_WifiSetProtocols {
    fn decode<IMPL_MICROPB_READ: ::micropb::PbRead>(
        &mut self,
        decoder: &mut ::micropb::PbDecoder<IMPL_MICROPB_READ>,
        len: usize,
    ) -> Result<(), ::micropb::DecodeError<IMPL_MICROPB_READ::Error>> {
        use ::micropb::{FieldDecode, PbBytes, PbMap, PbString, PbVec};
        let before = decoder.bytes_read();
        while decoder.bytes_read() - before < len {
            let tag = decoder.decode_tag()?;
            match tag.field_num() {
                0 => return Err(::micropb::DecodeError::ZeroField),
                1u32 => {
                    let mut_ref = &mut self.r#ifx;
                    {
                        let val = decoder.decode_int32()?;
                        let val_ref = &val;
                        if *val_ref != 0 {
                            *mut_ref = val as _;
                        }
                    };
                }
                2u32 => {
                    let mut_ref = &mut self.r#protocols;
                    {
                        mut_ref.decode_len_delimited(decoder)?;
                    };
                    self._has.set_protocols();
                }
                _ => {
                    decoder.skip_wire_value(tag.wire_type())?;
                }
            }
        }
        Ok(())
    }
}
impl ::micropb::MessageEncode for Rpc_Req_WifiSetProtocols {
    const MAX_SIZE: ::core::option::Option<usize> = 'msg: {
        let mut max_size = 0;
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(10usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        if let ::core::option::Option::Some(size) = ::micropb::const_map!(
            ::micropb::const_map!(
                <r#wifi_protocols as ::micropb::MessageEncode>::MAX_SIZE,
                |size| ::micropb::size::sizeof_len_record(size)
            ),
            |size| size + 1usize
        ) {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        ::core::option::Option::Some(max_size)
    };
    fn encode<IMPL_MICROPB_WRITE: ::micropb::PbWrite>(
        &self,
        encoder: &mut ::micropb::PbEncoder<IMPL_MICROPB_WRITE>,
    ) -> Result<(), IMPL_MICROPB_WRITE::Error> {
        use ::micropb::{FieldEncode, PbMap};
        {
            let val_ref = &self.r#ifx;
            if *val_ref != 0 {
                encoder.encode_varint32(8u32)?;
                encoder.encode_int32(*val_ref as _)?;
            }
        }
        {
            if let ::core::option::Option::Some(val_ref) = self.r#protocols() {
                encoder.encode_varint32(18u32)?;
                val_ref.encode_len_delimited(encoder)?;
            }
        }
        Ok(())
    }
    fn compute_size(&self) -> usize {
        use ::micropb::{FieldEncode, PbMap};
        let mut size = 0;
        {
            let val_ref = &self.r#ifx;
            if *val_ref != 0 {
                size += 1usize + ::micropb::size::sizeof_int32(*val_ref as _);
            }
        }
        {
            if let ::core::option::Option::Some(val_ref) = self.r#protocols() {
                size += 1usize + ::micropb::size::sizeof_len_record(val_ref.compute_size());
            }
        }
        size
    }
}
#[derive(Debug, Default, PartialEq, Clone)]
pub struct Rpc_Resp_WifiSetProtocols {
    pub r#resp: i32,
    pub r#ifx: u32,
}
impl Rpc_Resp_WifiSetProtocols {
    ///Return a reference to `resp`
    #[inline]
    pub fn r#resp(&self) -> &i32 {
        &self.r#resp
    }
    ///Return a mutable reference to `resp`
    #[inline]
    pub fn mut_resp(&mut self) -> &mut i32 {
        &mut self.r#resp
    }
    ///Set the value of `resp`
    #[inline]
    pub fn set_resp(&mut self, value: i32) -> &mut Self {
        self.r#resp = value.into();
        self
    }
    ///Builder method that sets the value of `resp`. Useful for initializing the message.
    #[inline]
    pub fn init_resp(mut self, value: i32) -> Self {
        self.r#resp = value.into();
        self
    }
    ///Return a reference to `ifx`
    #[inline]
    pub fn r#ifx(&self) -> &u32 {
        &self.r#ifx
    }
    ///Return a mutable reference to `ifx`
    #[inline]
    pub fn mut_ifx(&mut self) -> &mut u32 {
        &mut self.r#ifx
    }
    ///Set the value of `ifx`
    #[inline]
    pub fn set_ifx(&mut self, value: u32) -> &mut Self {
        self.r#ifx = value.into();
        self
    }
    ///Builder method that sets the value of `ifx`. Useful for initializing the message.
    #[inline]
    pub fn init_ifx(mut self, value: u32) -> Self {
        self.r#ifx = value.into();
        self
    }
}
impl ::micropb::MessageDecode for Rpc_Resp_WifiSetProtocols {
    fn decode<IMPL_MICROPB_READ: ::micropb::PbRead>(
        &mut self,
        decoder: &mut ::micropb::PbDecoder<IMPL_MICROPB_READ>,
        len: usize,
    ) -> Result<(), ::micropb::DecodeError<IMPL_MICROPB_READ::Error>> {
        use ::micropb::{FieldDecode, PbBytes, PbMap, PbString, PbVec};
        let before = decoder.bytes_read();
        while decoder.bytes_read() - before < len {
            let tag = decoder.decode_tag()?;
            match tag.field_num() {
                0 => return Err(::micropb::DecodeError::ZeroField),
                1u32 => {
                    let mut_ref = &mut self.r#resp;
                    {
                        let val = decoder.decode_int32()?;
                        let val_ref = &val;
                        if *val_ref != 0 {
                            *mut_ref = val as _;
                        }
                    };
                }
                2u32 => {
                    let mut_ref = &mut self.r#ifx;
                    {
                        let val = decoder.decode_varint32()?;
                        let val_ref = &val;
                        if *val_ref != 0 {
                            *mut_ref = val as _;
                        }
                    };
                }
                _ => {
                    decoder.skip_wire_value(tag.wire_type())?;
                }
            }
        }
        Ok(())
    }
}
impl ::micropb::MessageEncode for Rpc_Resp_WifiSetProtocols {
    const MAX_SIZE: ::core::option::Option<usize> = 'msg: {
        let mut max_size = 0;
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(10usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(5usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        ::core::option::Option::Some(max_size)
    };
    fn encode<IMPL_MICROPB_WRITE: ::micropb::PbWrite>(
        &self,
        encoder: &mut ::micropb::PbEncoder<IMPL_MICROPB_WRITE>,
    ) -> Result<(), IMPL_MICROPB_WRITE::Error> {
        use ::micropb::{FieldEncode, PbMap};
        {
            let val_ref = &self.r#resp;
            if *val_ref != 0 {
                encoder.encode_varint32(8u32)?;
                encoder.encode_int32(*val_ref as _)?;
            }
        }
        {
            let val_ref = &self.r#ifx;
            if *val_ref != 0 {
                encoder.encode_varint32(16u32)?;
                encoder.encode_varint32(*val_ref as _)?;
            }
        }
        Ok(())
    }
    fn compute_size(&self) -> usize {
        use ::micropb::{FieldEncode, PbMap};
        let mut size = 0;
        {
            let val_ref = &self.r#resp;
            if *val_ref != 0 {
                size += 1usize + ::micropb::size::sizeof_int32(*val_ref as _);
            }
        }
        {
            let val_ref = &self.r#ifx;
            if *val_ref != 0 {
                size += 1usize + ::micropb::size::sizeof_varint32(*val_ref as _);
            }
        }
        size
    }
}
#[derive(Debug, Default, PartialEq, Clone)]
pub struct Rpc_Req_WifiGetProtocols {
    pub r#ifx: i32,
}
impl Rpc_Req_WifiGetProtocols {
    ///Return a reference to `ifx`
    #[inline]
    pub fn r#ifx(&self) -> &i32 {
        &self.r#ifx
    }
    ///Return a mutable reference to `ifx`
    #[inline]
    pub fn mut_ifx(&mut self) -> &mut i32 {
        &mut self.r#ifx
    }
    ///Set the value of `ifx`
    #[inline]
    pub fn set_ifx(&mut self, value: i32) -> &mut Self {
        self.r#ifx = value.into();
        self
    }
    ///Builder method that sets the value of `ifx`. Useful for initializing the message.
    #[inline]
    pub fn init_ifx(mut self, value: i32) -> Self {
        self.r#ifx = value.into();
        self
    }
}
impl ::micropb::MessageDecode for Rpc_Req_WifiGetProtocols {
    fn decode<IMPL_MICROPB_READ: ::micropb::PbRead>(
        &mut self,
        decoder: &mut ::micropb::PbDecoder<IMPL_MICROPB_READ>,
        len: usize,
    ) -> Result<(), ::micropb::DecodeError<IMPL_MICROPB_READ::Error>> {
        use ::micropb::{FieldDecode, PbBytes, PbMap, PbString, PbVec};
        let before = decoder.bytes_read();
        while decoder.bytes_read() - before < len {
            let tag = decoder.decode_tag()?;
            match tag.field_num() {
                0 => return Err(::micropb::DecodeError::ZeroField),
                1u32 => {
                    let mut_ref = &mut self.r#ifx;
                    {
                        let val = decoder.decode_int32()?;
                        let val_ref = &val;
                        if *val_ref != 0 {
                            *mut_ref = val as _;
                        }
                    };
                }
                _ => {
                    decoder.skip_wire_value(tag.wire_type())?;
                }
            }
        }
        Ok(())
    }
}
impl ::micropb::MessageEncode for Rpc_Req_WifiGetProtocols {
    const MAX_SIZE: ::core::option::Option<usize> = 'msg: {
        let mut max_size = 0;
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(10usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        ::core::option::Option::Some(max_size)
    };
    fn encode<IMPL_MICROPB_WRITE: ::micropb::PbWrite>(
        &self,
        encoder: &mut ::micropb::PbEncoder<IMPL_MICROPB_WRITE>,
    ) -> Result<(), IMPL_MICROPB_WRITE::Error> {
        use ::micropb::{FieldEncode, PbMap};
        {
            let val_ref = &self.r#ifx;
            if *val_ref != 0 {
                encoder.encode_varint32(8u32)?;
                encoder.encode_int32(*val_ref as _)?;
            }
        }
        Ok(())
    }
    fn compute_size(&self) -> usize {
        use ::micropb::{FieldEncode, PbMap};
        let mut size = 0;
        {
            let val_ref = &self.r#ifx;
            if *val_ref != 0 {
                size += 1usize + ::micropb::size::sizeof_int32(*val_ref as _);
            }
        }
        size
    }
}
pub mod Rpc_Resp_WifiGetProtocols_ {
    #[derive(Debug, Default, PartialEq, Clone)]
    pub struct _Hazzer([u8; 1]);
    impl _Hazzer {
        ///New hazzer with all fields set to off
        #[inline]
        pub const fn _new() -> Self {
            Self([0; 1])
        }
        ///Query presence of `protocols`
        #[inline]
        pub const fn r#protocols(&self) -> bool {
            (self.0[0] & 1) != 0
        }
        ///Set presence of `protocols`
        #[inline]
        pub const fn set_protocols(&mut self) -> &mut Self {
            let elem = &mut self.0[0];
            *elem |= 1;
            self
        }
        ///Clear presence of `protocols`
        #[inline]
        pub const fn clear_protocols(&mut self) -> &mut Self {
            let elem = &mut self.0[0];
            *elem &= !1;
            self
        }
        ///Builder method that sets the presence of `protocols`. Useful for initializing the Hazzer.
        #[inline]
        pub const fn init_protocols(mut self) -> Self {
            self.set_protocols();
            self
        }
    }
}
#[derive(Debug, Default, Clone)]
pub struct Rpc_Resp_WifiGetProtocols {
    pub r#resp: i32,
    pub r#ifx: i32,
    pub r#protocols: r#wifi_protocols,
    pub _has: Rpc_Resp_WifiGetProtocols_::_Hazzer,
}
impl ::core::cmp::PartialEq for Rpc_Resp_WifiGetProtocols {
    fn eq(&self, other: &Self) -> bool {
        let mut ret = true;
        ret &= (self.r#resp == other.r#resp);
        ret &= (self.r#ifx == other.r#ifx);
        ret &= (self.r#protocols() == other.r#protocols());
        ret
    }
}
impl Rpc_Resp_WifiGetProtocols {
    ///Return a reference to `resp`
    #[inline]
    pub fn r#resp(&self) -> &i32 {
        &self.r#resp
    }
    ///Return a mutable reference to `resp`
    #[inline]
    pub fn mut_resp(&mut self) -> &mut i32 {
        &mut self.r#resp
    }
    ///Set the value of `resp`
    #[inline]
    pub fn set_resp(&mut self, value: i32) -> &mut Self {
        self.r#resp = value.into();
        self
    }
    ///Builder method that sets the value of `resp`. Useful for initializing the message.
    #[inline]
    pub fn init_resp(mut self, value: i32) -> Self {
        self.r#resp = value.into();
        self
    }
    ///Return a reference to `ifx`
    #[inline]
    pub fn r#ifx(&self) -> &i32 {
        &self.r#ifx
    }
    ///Return a mutable reference to `ifx`
    #[inline]
    pub fn mut_ifx(&mut self) -> &mut i32 {
        &mut self.r#ifx
    }
    ///Set the value of `ifx`
    #[inline]
    pub fn set_ifx(&mut self, value: i32) -> &mut Self {
        self.r#ifx = value.into();
        self
    }
    ///Builder method that sets the value of `ifx`. Useful for initializing the message.
    #[inline]
    pub fn init_ifx(mut self, value: i32) -> Self {
        self.r#ifx = value.into();
        self
    }
    ///Return a reference to `protocols` as an `Option`
    #[inline]
    pub fn r#protocols(&self) -> ::core::option::Option<&r#wifi_protocols> {
        self._has.r#protocols().then_some(&self.r#protocols)
    }
    ///Set the value and presence of `protocols`
    #[inline]
    pub fn set_protocols(&mut self, value: r#wifi_protocols) -> &mut Self {
        self._has.set_protocols();
        self.r#protocols = value.into();
        self
    }
    ///Return a mutable reference to `protocols` as an `Option`
    #[inline]
    pub fn mut_protocols(&mut self) -> ::core::option::Option<&mut r#wifi_protocols> {
        self._has.r#protocols().then_some(&mut self.r#protocols)
    }
    ///Clear the presence of `protocols`
    #[inline]
    pub fn clear_protocols(&mut self) -> &mut Self {
        self._has.clear_protocols();
        self
    }
    ///Take the value of `protocols` and clear its presence
    #[inline]
    pub fn take_protocols(&mut self) -> ::core::option::Option<r#wifi_protocols> {
        let val = self
            ._has
            .r#protocols()
            .then(|| ::core::mem::take(&mut self.r#protocols));
        self._has.clear_protocols();
        val
    }
    ///Builder method that sets the value of `protocols`. Useful for initializing the message.
    #[inline]
    pub fn init_protocols(mut self, value: r#wifi_protocols) -> Self {
        self.set_protocols(value);
        self
    }
}
impl ::micropb::MessageDecode for Rpc_Resp_WifiGetProtocols {
    fn decode<IMPL_MICROPB_READ: ::micropb::PbRead>(
        &mut self,
        decoder: &mut ::micropb::PbDecoder<IMPL_MICROPB_READ>,
        len: usize,
    ) -> Result<(), ::micropb::DecodeError<IMPL_MICROPB_READ::Error>> {
        use ::micropb::{FieldDecode, PbBytes, PbMap, PbString, PbVec};
        let before = decoder.bytes_read();
        while decoder.bytes_read() - before < len {
            let tag = decoder.decode_tag()?;
            match tag.field_num() {
                0 => return Err(::micropb::DecodeError::ZeroField),
                1u32 => {
                    let mut_ref = &mut self.r#resp;
                    {
                        let val = decoder.decode_int32()?;
                        let val_ref = &val;
                        if *val_ref != 0 {
                            *mut_ref = val as _;
                        }
                    };
                }
                2u32 => {
                    let mut_ref = &mut self.r#ifx;
                    {
                        let val = decoder.decode_int32()?;
                        let val_ref = &val;
                        if *val_ref != 0 {
                            *mut_ref = val as _;
                        }
                    };
                }
                3u32 => {
                    let mut_ref = &mut self.r#protocols;
                    {
                        mut_ref.decode_len_delimited(decoder)?;
                    };
                    self._has.set_protocols();
                }
                _ => {
                    decoder.skip_wire_value(tag.wire_type())?;
                }
            }
        }
        Ok(())
    }
}
impl ::micropb::MessageEncode for Rpc_Resp_WifiGetProtocols {
    const MAX_SIZE: ::core::option::Option<usize> = 'msg: {
        let mut max_size = 0;
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(10usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(10usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        if let ::core::option::Option::Some(size) = ::micropb::const_map!(
            ::micropb::const_map!(
                <r#wifi_protocols as ::micropb::MessageEncode>::MAX_SIZE,
                |size| ::micropb::size::sizeof_len_record(size)
            ),
            |size| size + 1usize
        ) {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        ::core::option::Option::Some(max_size)
    };
    fn encode<IMPL_MICROPB_WRITE: ::micropb::PbWrite>(
        &self,
        encoder: &mut ::micropb::PbEncoder<IMPL_MICROPB_WRITE>,
    ) -> Result<(), IMPL_MICROPB_WRITE::Error> {
        use ::micropb::{FieldEncode, PbMap};
        {
            let val_ref = &self.r#resp;
            if *val_ref != 0 {
                encoder.encode_varint32(8u32)?;
                encoder.encode_int32(*val_ref as _)?;
            }
        }
        {
            let val_ref = &self.r#ifx;
            if *val_ref != 0 {
                encoder.encode_varint32(16u32)?;
                encoder.encode_int32(*val_ref as _)?;
            }
        }
        {
            if let ::core::option::Option::Some(val_ref) = self.r#protocols() {
                encoder.encode_varint32(26u32)?;
                val_ref.encode_len_delimited(encoder)?;
            }
        }
        Ok(())
    }
    fn compute_size(&self) -> usize {
        use ::micropb::{FieldEncode, PbMap};
        let mut size = 0;
        {
            let val_ref = &self.r#resp;
            if *val_ref != 0 {
                size += 1usize + ::micropb::size::sizeof_int32(*val_ref as _);
            }
        }
        {
            let val_ref = &self.r#ifx;
            if *val_ref != 0 {
                size += 1usize + ::micropb::size::sizeof_int32(*val_ref as _);
            }
        }
        {
            if let ::core::option::Option::Some(val_ref) = self.r#protocols() {
                size += 1usize + ::micropb::size::sizeof_len_record(val_ref.compute_size());
            }
        }
        size
    }
}
pub mod Rpc_Req_WifiSetBandwidths_ {
    #[derive(Debug, Default, PartialEq, Clone)]
    pub struct _Hazzer([u8; 1]);
    impl _Hazzer {
        ///New hazzer with all fields set to off
        #[inline]
        pub const fn _new() -> Self {
            Self([0; 1])
        }
        ///Query presence of `bandwidths`
        #[inline]
        pub const fn r#bandwidths(&self) -> bool {
            (self.0[0] & 1) != 0
        }
        ///Set presence of `bandwidths`
        #[inline]
        pub const fn set_bandwidths(&mut self) -> &mut Self {
            let elem = &mut self.0[0];
            *elem |= 1;
            self
        }
        ///Clear presence of `bandwidths`
        #[inline]
        pub const fn clear_bandwidths(&mut self) -> &mut Self {
            let elem = &mut self.0[0];
            *elem &= !1;
            self
        }
        ///Builder method that sets the presence of `bandwidths`. Useful for initializing the Hazzer.
        #[inline]
        pub const fn init_bandwidths(mut self) -> Self {
            self.set_bandwidths();
            self
        }
    }
}
#[derive(Debug, Default, Clone)]
pub struct Rpc_Req_WifiSetBandwidths {
    pub r#ifx: i32,
    pub r#bandwidths: r#wifi_bandwidths,
    pub _has: Rpc_Req_WifiSetBandwidths_::_Hazzer,
}
impl ::core::cmp::PartialEq for Rpc_Req_WifiSetBandwidths {
    fn eq(&self, other: &Self) -> bool {
        let mut ret = true;
        ret &= (self.r#ifx == other.r#ifx);
        ret &= (self.r#bandwidths() == other.r#bandwidths());
        ret
    }
}
impl Rpc_Req_WifiSetBandwidths {
    ///Return a reference to `ifx`
    #[inline]
    pub fn r#ifx(&self) -> &i32 {
        &self.r#ifx
    }
    ///Return a mutable reference to `ifx`
    #[inline]
    pub fn mut_ifx(&mut self) -> &mut i32 {
        &mut self.r#ifx
    }
    ///Set the value of `ifx`
    #[inline]
    pub fn set_ifx(&mut self, value: i32) -> &mut Self {
        self.r#ifx = value.into();
        self
    }
    ///Builder method that sets the value of `ifx`. Useful for initializing the message.
    #[inline]
    pub fn init_ifx(mut self, value: i32) -> Self {
        self.r#ifx = value.into();
        self
    }
    ///Return a reference to `bandwidths` as an `Option`
    #[inline]
    pub fn r#bandwidths(&self) -> ::core::option::Option<&r#wifi_bandwidths> {
        self._has.r#bandwidths().then_some(&self.r#bandwidths)
    }
    ///Set the value and presence of `bandwidths`
    #[inline]
    pub fn set_bandwidths(&mut self, value: r#wifi_bandwidths) -> &mut Self {
        self._has.set_bandwidths();
        self.r#bandwidths = value.into();
        self
    }
    ///Return a mutable reference to `bandwidths` as an `Option`
    #[inline]
    pub fn mut_bandwidths(&mut self) -> ::core::option::Option<&mut r#wifi_bandwidths> {
        self._has.r#bandwidths().then_some(&mut self.r#bandwidths)
    }
    ///Clear the presence of `bandwidths`
    #[inline]
    pub fn clear_bandwidths(&mut self) -> &mut Self {
        self._has.clear_bandwidths();
        self
    }
    ///Take the value of `bandwidths` and clear its presence
    #[inline]
    pub fn take_bandwidths(&mut self) -> ::core::option::Option<r#wifi_bandwidths> {
        let val = self
            ._has
            .r#bandwidths()
            .then(|| ::core::mem::take(&mut self.r#bandwidths));
        self._has.clear_bandwidths();
        val
    }
    ///Builder method that sets the value of `bandwidths`. Useful for initializing the message.
    #[inline]
    pub fn init_bandwidths(mut self, value: r#wifi_bandwidths) -> Self {
        self.set_bandwidths(value);
        self
    }
}
impl ::micropb::MessageDecode for Rpc_Req_WifiSetBandwidths {
    fn decode<IMPL_MICROPB_READ: ::micropb::PbRead>(
        &mut self,
        decoder: &mut ::micropb::PbDecoder<IMPL_MICROPB_READ>,
        len: usize,
    ) -> Result<(), ::micropb::DecodeError<IMPL_MICROPB_READ::Error>> {
        use ::micropb::{FieldDecode, PbBytes, PbMap, PbString, PbVec};
        let before = decoder.bytes_read();
        while decoder.bytes_read() - before < len {
            let tag = decoder.decode_tag()?;
            match tag.field_num() {
                0 => return Err(::micropb::DecodeError::ZeroField),
                1u32 => {
                    let mut_ref = &mut self.r#ifx;
                    {
                        let val = decoder.decode_int32()?;
                        let val_ref = &val;
                        if *val_ref != 0 {
                            *mut_ref = val as _;
                        }
                    };
                }
                2u32 => {
                    let mut_ref = &mut self.r#bandwidths;
                    {
                        mut_ref.decode_len_delimited(decoder)?;
                    };
                    self._has.set_bandwidths();
                }
                _ => {
                    decoder.skip_wire_value(tag.wire_type())?;
                }
            }
        }
        Ok(())
    }
}
impl ::micropb::MessageEncode for Rpc_Req_WifiSetBandwidths {
    const MAX_SIZE: ::core::option::Option<usize> = 'msg: {
        let mut max_size = 0;
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(10usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        if let ::core::option::Option::Some(size) = ::micropb::const_map!(
            ::micropb::const_map!(
                <r#wifi_bandwidths as ::micropb::MessageEncode>::MAX_SIZE,
                |size| ::micropb::size::sizeof_len_record(size)
            ),
            |size| size + 1usize
        ) {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        ::core::option::Option::Some(max_size)
    };
    fn encode<IMPL_MICROPB_WRITE: ::micropb::PbWrite>(
        &self,
        encoder: &mut ::micropb::PbEncoder<IMPL_MICROPB_WRITE>,
    ) -> Result<(), IMPL_MICROPB_WRITE::Error> {
        use ::micropb::{FieldEncode, PbMap};
        {
            let val_ref = &self.r#ifx;
            if *val_ref != 0 {
                encoder.encode_varint32(8u32)?;
                encoder.encode_int32(*val_ref as _)?;
            }
        }
        {
            if let ::core::option::Option::Some(val_ref) = self.r#bandwidths() {
                encoder.encode_varint32(18u32)?;
                val_ref.encode_len_delimited(encoder)?;
            }
        }
        Ok(())
    }
    fn compute_size(&self) -> usize {
        use ::micropb::{FieldEncode, PbMap};
        let mut size = 0;
        {
            let val_ref = &self.r#ifx;
            if *val_ref != 0 {
                size += 1usize + ::micropb::size::sizeof_int32(*val_ref as _);
            }
        }
        {
            if let ::core::option::Option::Some(val_ref) = self.r#bandwidths() {
                size += 1usize + ::micropb::size::sizeof_len_record(val_ref.compute_size());
            }
        }
        size
    }
}
#[derive(Debug, Default, PartialEq, Clone)]
pub struct Rpc_Resp_WifiSetBandwidths {
    pub r#resp: i32,
    pub r#ifx: i32,
}
impl Rpc_Resp_WifiSetBandwidths {
    ///Return a reference to `resp`
    #[inline]
    pub fn r#resp(&self) -> &i32 {
        &self.r#resp
    }
    ///Return a mutable reference to `resp`
    #[inline]
    pub fn mut_resp(&mut self) -> &mut i32 {
        &mut self.r#resp
    }
    ///Set the value of `resp`
    #[inline]
    pub fn set_resp(&mut self, value: i32) -> &mut Self {
        self.r#resp = value.into();
        self
    }
    ///Builder method that sets the value of `resp`. Useful for initializing the message.
    #[inline]
    pub fn init_resp(mut self, value: i32) -> Self {
        self.r#resp = value.into();
        self
    }
    ///Return a reference to `ifx`
    #[inline]
    pub fn r#ifx(&self) -> &i32 {
        &self.r#ifx
    }
    ///Return a mutable reference to `ifx`
    #[inline]
    pub fn mut_ifx(&mut self) -> &mut i32 {
        &mut self.r#ifx
    }
    ///Set the value of `ifx`
    #[inline]
    pub fn set_ifx(&mut self, value: i32) -> &mut Self {
        self.r#ifx = value.into();
        self
    }
    ///Builder method that sets the value of `ifx`. Useful for initializing the message.
    #[inline]
    pub fn init_ifx(mut self, value: i32) -> Self {
        self.r#ifx = value.into();
        self
    }
}
impl ::micropb::MessageDecode for Rpc_Resp_WifiSetBandwidths {
    fn decode<IMPL_MICROPB_READ: ::micropb::PbRead>(
        &mut self,
        decoder: &mut ::micropb::PbDecoder<IMPL_MICROPB_READ>,
        len: usize,
    ) -> Result<(), ::micropb::DecodeError<IMPL_MICROPB_READ::Error>> {
        use ::micropb::{FieldDecode, PbBytes, PbMap, PbString, PbVec};
        let before = decoder.bytes_read();
        while decoder.bytes_read() - before < len {
            let tag = decoder.decode_tag()?;
            match tag.field_num() {
                0 => return Err(::micropb::DecodeError::ZeroField),
                1u32 => {
                    let mut_ref = &mut self.r#resp;
                    {
                        let val = decoder.decode_int32()?;
                        let val_ref = &val;
                        if *val_ref != 0 {
                            *mut_ref = val as _;
                        }
                    };
                }
                2u32 => {
                    let mut_ref = &mut self.r#ifx;
                    {
                        let val = decoder.decode_int32()?;
                        let val_ref = &val;
                        if *val_ref != 0 {
                            *mut_ref = val as _;
                        }
                    };
                }
                _ => {
                    decoder.skip_wire_value(tag.wire_type())?;
                }
            }
        }
        Ok(())
    }
}
impl ::micropb::MessageEncode for Rpc_Resp_WifiSetBandwidths {
    const MAX_SIZE: ::core::option::Option<usize> = 'msg: {
        let mut max_size = 0;
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(10usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(10usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        ::core::option::Option::Some(max_size)
    };
    fn encode<IMPL_MICROPB_WRITE: ::micropb::PbWrite>(
        &self,
        encoder: &mut ::micropb::PbEncoder<IMPL_MICROPB_WRITE>,
    ) -> Result<(), IMPL_MICROPB_WRITE::Error> {
        use ::micropb::{FieldEncode, PbMap};
        {
            let val_ref = &self.r#resp;
            if *val_ref != 0 {
                encoder.encode_varint32(8u32)?;
                encoder.encode_int32(*val_ref as _)?;
            }
        }
        {
            let val_ref = &self.r#ifx;
            if *val_ref != 0 {
                encoder.encode_varint32(16u32)?;
                encoder.encode_int32(*val_ref as _)?;
            }
        }
        Ok(())
    }
    fn compute_size(&self) -> usize {
        use ::micropb::{FieldEncode, PbMap};
        let mut size = 0;
        {
            let val_ref = &self.r#resp;
            if *val_ref != 0 {
                size += 1usize + ::micropb::size::sizeof_int32(*val_ref as _);
            }
        }
        {
            let val_ref = &self.r#ifx;
            if *val_ref != 0 {
                size += 1usize + ::micropb::size::sizeof_int32(*val_ref as _);
            }
        }
        size
    }
}
#[derive(Debug, Default, PartialEq, Clone)]
pub struct Rpc_Req_WifiGetBandwidths {
    pub r#ifx: i32,
}
impl Rpc_Req_WifiGetBandwidths {
    ///Return a reference to `ifx`
    #[inline]
    pub fn r#ifx(&self) -> &i32 {
        &self.r#ifx
    }
    ///Return a mutable reference to `ifx`
    #[inline]
    pub fn mut_ifx(&mut self) -> &mut i32 {
        &mut self.r#ifx
    }
    ///Set the value of `ifx`
    #[inline]
    pub fn set_ifx(&mut self, value: i32) -> &mut Self {
        self.r#ifx = value.into();
        self
    }
    ///Builder method that sets the value of `ifx`. Useful for initializing the message.
    #[inline]
    pub fn init_ifx(mut self, value: i32) -> Self {
        self.r#ifx = value.into();
        self
    }
}
impl ::micropb::MessageDecode for Rpc_Req_WifiGetBandwidths {
    fn decode<IMPL_MICROPB_READ: ::micropb::PbRead>(
        &mut self,
        decoder: &mut ::micropb::PbDecoder<IMPL_MICROPB_READ>,
        len: usize,
    ) -> Result<(), ::micropb::DecodeError<IMPL_MICROPB_READ::Error>> {
        use ::micropb::{FieldDecode, PbBytes, PbMap, PbString, PbVec};
        let before = decoder.bytes_read();
        while decoder.bytes_read() - before < len {
            let tag = decoder.decode_tag()?;
            match tag.field_num() {
                0 => return Err(::micropb::DecodeError::ZeroField),
                1u32 => {
                    let mut_ref = &mut self.r#ifx;
                    {
                        let val = decoder.decode_int32()?;
                        let val_ref = &val;
                        if *val_ref != 0 {
                            *mut_ref = val as _;
                        }
                    };
                }
                _ => {
                    decoder.skip_wire_value(tag.wire_type())?;
                }
            }
        }
        Ok(())
    }
}
impl ::micropb::MessageEncode for Rpc_Req_WifiGetBandwidths {
    const MAX_SIZE: ::core::option::Option<usize> = 'msg: {
        let mut max_size = 0;
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(10usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        ::core::option::Option::Some(max_size)
    };
    fn encode<IMPL_MICROPB_WRITE: ::micropb::PbWrite>(
        &self,
        encoder: &mut ::micropb::PbEncoder<IMPL_MICROPB_WRITE>,
    ) -> Result<(), IMPL_MICROPB_WRITE::Error> {
        use ::micropb::{FieldEncode, PbMap};
        {
            let val_ref = &self.r#ifx;
            if *val_ref != 0 {
                encoder.encode_varint32(8u32)?;
                encoder.encode_int32(*val_ref as _)?;
            }
        }
        Ok(())
    }
    fn compute_size(&self) -> usize {
        use ::micropb::{FieldEncode, PbMap};
        let mut size = 0;
        {
            let val_ref = &self.r#ifx;
            if *val_ref != 0 {
                size += 1usize + ::micropb::size::sizeof_int32(*val_ref as _);
            }
        }
        size
    }
}
pub mod Rpc_Resp_WifiGetBandwidths_ {
    #[derive(Debug, Default, PartialEq, Clone)]
    pub struct _Hazzer([u8; 1]);
    impl _Hazzer {
        ///New hazzer with all fields set to off
        #[inline]
        pub const fn _new() -> Self {
            Self([0; 1])
        }
        ///Query presence of `bandwidths`
        #[inline]
        pub const fn r#bandwidths(&self) -> bool {
            (self.0[0] & 1) != 0
        }
        ///Set presence of `bandwidths`
        #[inline]
        pub const fn set_bandwidths(&mut self) -> &mut Self {
            let elem = &mut self.0[0];
            *elem |= 1;
            self
        }
        ///Clear presence of `bandwidths`
        #[inline]
        pub const fn clear_bandwidths(&mut self) -> &mut Self {
            let elem = &mut self.0[0];
            *elem &= !1;
            self
        }
        ///Builder method that sets the presence of `bandwidths`. Useful for initializing the Hazzer.
        #[inline]
        pub const fn init_bandwidths(mut self) -> Self {
            self.set_bandwidths();
            self
        }
    }
}
#[derive(Debug, Default, Clone)]
pub struct Rpc_Resp_WifiGetBandwidths {
    pub r#resp: i32,
    pub r#ifx: i32,
    pub r#bandwidths: r#wifi_bandwidths,
    pub _has: Rpc_Resp_WifiGetBandwidths_::_Hazzer,
}
impl ::core::cmp::PartialEq for Rpc_Resp_WifiGetBandwidths {
    fn eq(&self, other: &Self) -> bool {
        let mut ret = true;
        ret &= (self.r#resp == other.r#resp);
        ret &= (self.r#ifx == other.r#ifx);
        ret &= (self.r#bandwidths() == other.r#bandwidths());
        ret
    }
}
impl Rpc_Resp_WifiGetBandwidths {
    ///Return a reference to `resp`
    #[inline]
    pub fn r#resp(&self) -> &i32 {
        &self.r#resp
    }
    ///Return a mutable reference to `resp`
    #[inline]
    pub fn mut_resp(&mut self) -> &mut i32 {
        &mut self.r#resp
    }
    ///Set the value of `resp`
    #[inline]
    pub fn set_resp(&mut self, value: i32) -> &mut Self {
        self.r#resp = value.into();
        self
    }
    ///Builder method that sets the value of `resp`. Useful for initializing the message.
    #[inline]
    pub fn init_resp(mut self, value: i32) -> Self {
        self.r#resp = value.into();
        self
    }
    ///Return a reference to `ifx`
    #[inline]
    pub fn r#ifx(&self) -> &i32 {
        &self.r#ifx
    }
    ///Return a mutable reference to `ifx`
    #[inline]
    pub fn mut_ifx(&mut self) -> &mut i32 {
        &mut self.r#ifx
    }
    ///Set the value of `ifx`
    #[inline]
    pub fn set_ifx(&mut self, value: i32) -> &mut Self {
        self.r#ifx = value.into();
        self
    }
    ///Builder method that sets the value of `ifx`. Useful for initializing the message.
    #[inline]
    pub fn init_ifx(mut self, value: i32) -> Self {
        self.r#ifx = value.into();
        self
    }
    ///Return a reference to `bandwidths` as an `Option`
    #[inline]
    pub fn r#bandwidths(&self) -> ::core::option::Option<&r#wifi_bandwidths> {
        self._has.r#bandwidths().then_some(&self.r#bandwidths)
    }
    ///Set the value and presence of `bandwidths`
    #[inline]
    pub fn set_bandwidths(&mut self, value: r#wifi_bandwidths) -> &mut Self {
        self._has.set_bandwidths();
        self.r#bandwidths = value.into();
        self
    }
    ///Return a mutable reference to `bandwidths` as an `Option`
    #[inline]
    pub fn mut_bandwidths(&mut self) -> ::core::option::Option<&mut r#wifi_bandwidths> {
        self._has.r#bandwidths().then_some(&mut self.r#bandwidths)
    }
    ///Clear the presence of `bandwidths`
    #[inline]
    pub fn clear_bandwidths(&mut self) -> &mut Self {
        self._has.clear_bandwidths();
        self
    }
    ///Take the value of `bandwidths` and clear its presence
    #[inline]
    pub fn take_bandwidths(&mut self) -> ::core::option::Option<r#wifi_bandwidths> {
        let val = self
            ._has
            .r#bandwidths()
            .then(|| ::core::mem::take(&mut self.r#bandwidths));
        self._has.clear_bandwidths();
        val
    }
    ///Builder method that sets the value of `bandwidths`. Useful for initializing the message.
    #[inline]
    pub fn init_bandwidths(mut self, value: r#wifi_bandwidths) -> Self {
        self.set_bandwidths(value);
        self
    }
}
impl ::micropb::MessageDecode for Rpc_Resp_WifiGetBandwidths {
    fn decode<IMPL_MICROPB_READ: ::micropb::PbRead>(
        &mut self,
        decoder: &mut ::micropb::PbDecoder<IMPL_MICROPB_READ>,
        len: usize,
    ) -> Result<(), ::micropb::DecodeError<IMPL_MICROPB_READ::Error>> {
        use ::micropb::{FieldDecode, PbBytes, PbMap, PbString, PbVec};
        let before = decoder.bytes_read();
        while decoder.bytes_read() - before < len {
            let tag = decoder.decode_tag()?;
            match tag.field_num() {
                0 => return Err(::micropb::DecodeError::ZeroField),
                1u32 => {
                    let mut_ref = &mut self.r#resp;
                    {
                        let val = decoder.decode_int32()?;
                        let val_ref = &val;
                        if *val_ref != 0 {
                            *mut_ref = val as _;
                        }
                    };
                }
                2u32 => {
                    let mut_ref = &mut self.r#ifx;
                    {
                        let val = decoder.decode_int32()?;
                        let val_ref = &val;
                        if *val_ref != 0 {
                            *mut_ref = val as _;
                        }
                    };
                }
                3u32 => {
                    let mut_ref = &mut self.r#bandwidths;
                    {
                        mut_ref.decode_len_delimited(decoder)?;
                    };
                    self._has.set_bandwidths();
                }
                _ => {
                    decoder.skip_wire_value(tag.wire_type())?;
                }
            }
        }
        Ok(())
    }
}
impl ::micropb::MessageEncode for Rpc_Resp_WifiGetBandwidths {
    const MAX_SIZE: ::core::option::Option<usize> = 'msg: {
        let mut max_size = 0;
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(10usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(10usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        if let ::core::option::Option::Some(size) = ::micropb::const_map!(
            ::micropb::const_map!(
                <r#wifi_bandwidths as ::micropb::MessageEncode>::MAX_SIZE,
                |size| ::micropb::size::sizeof_len_record(size)
            ),
            |size| size + 1usize
        ) {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        ::core::option::Option::Some(max_size)
    };
    fn encode<IMPL_MICROPB_WRITE: ::micropb::PbWrite>(
        &self,
        encoder: &mut ::micropb::PbEncoder<IMPL_MICROPB_WRITE>,
    ) -> Result<(), IMPL_MICROPB_WRITE::Error> {
        use ::micropb::{FieldEncode, PbMap};
        {
            let val_ref = &self.r#resp;
            if *val_ref != 0 {
                encoder.encode_varint32(8u32)?;
                encoder.encode_int32(*val_ref as _)?;
            }
        }
        {
            let val_ref = &self.r#ifx;
            if *val_ref != 0 {
                encoder.encode_varint32(16u32)?;
                encoder.encode_int32(*val_ref as _)?;
            }
        }
        {
            if let ::core::option::Option::Some(val_ref) = self.r#bandwidths() {
                encoder.encode_varint32(26u32)?;
                val_ref.encode_len_delimited(encoder)?;
            }
        }
        Ok(())
    }
    fn compute_size(&self) -> usize {
        use ::micropb::{FieldEncode, PbMap};
        let mut size = 0;
        {
            let val_ref = &self.r#resp;
            if *val_ref != 0 {
                size += 1usize + ::micropb::size::sizeof_int32(*val_ref as _);
            }
        }
        {
            let val_ref = &self.r#ifx;
            if *val_ref != 0 {
                size += 1usize + ::micropb::size::sizeof_int32(*val_ref as _);
            }
        }
        {
            if let ::core::option::Option::Some(val_ref) = self.r#bandwidths() {
                size += 1usize + ::micropb::size::sizeof_len_record(val_ref.compute_size());
            }
        }
        size
    }
}
#[derive(Debug, Default, PartialEq, Clone)]
pub struct Rpc_Req_WifiSetBand {
    pub r#band: u32,
}
impl Rpc_Req_WifiSetBand {
    ///Return a reference to `band`
    #[inline]
    pub fn r#band(&self) -> &u32 {
        &self.r#band
    }
    ///Return a mutable reference to `band`
    #[inline]
    pub fn mut_band(&mut self) -> &mut u32 {
        &mut self.r#band
    }
    ///Set the value of `band`
    #[inline]
    pub fn set_band(&mut self, value: u32) -> &mut Self {
        self.r#band = value.into();
        self
    }
    ///Builder method that sets the value of `band`. Useful for initializing the message.
    #[inline]
    pub fn init_band(mut self, value: u32) -> Self {
        self.r#band = value.into();
        self
    }
}
impl ::micropb::MessageDecode for Rpc_Req_WifiSetBand {
    fn decode<IMPL_MICROPB_READ: ::micropb::PbRead>(
        &mut self,
        decoder: &mut ::micropb::PbDecoder<IMPL_MICROPB_READ>,
        len: usize,
    ) -> Result<(), ::micropb::DecodeError<IMPL_MICROPB_READ::Error>> {
        use ::micropb::{FieldDecode, PbBytes, PbMap, PbString, PbVec};
        let before = decoder.bytes_read();
        while decoder.bytes_read() - before < len {
            let tag = decoder.decode_tag()?;
            match tag.field_num() {
                0 => return Err(::micropb::DecodeError::ZeroField),
                1u32 => {
                    let mut_ref = &mut self.r#band;
                    {
                        let val = decoder.decode_varint32()?;
                        let val_ref = &val;
                        if *val_ref != 0 {
                            *mut_ref = val as _;
                        }
                    };
                }
                _ => {
                    decoder.skip_wire_value(tag.wire_type())?;
                }
            }
        }
        Ok(())
    }
}
impl ::micropb::MessageEncode for Rpc_Req_WifiSetBand {
    const MAX_SIZE: ::core::option::Option<usize> = 'msg: {
        let mut max_size = 0;
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(5usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        ::core::option::Option::Some(max_size)
    };
    fn encode<IMPL_MICROPB_WRITE: ::micropb::PbWrite>(
        &self,
        encoder: &mut ::micropb::PbEncoder<IMPL_MICROPB_WRITE>,
    ) -> Result<(), IMPL_MICROPB_WRITE::Error> {
        use ::micropb::{FieldEncode, PbMap};
        {
            let val_ref = &self.r#band;
            if *val_ref != 0 {
                encoder.encode_varint32(8u32)?;
                encoder.encode_varint32(*val_ref as _)?;
            }
        }
        Ok(())
    }
    fn compute_size(&self) -> usize {
        use ::micropb::{FieldEncode, PbMap};
        let mut size = 0;
        {
            let val_ref = &self.r#band;
            if *val_ref != 0 {
                size += 1usize + ::micropb::size::sizeof_varint32(*val_ref as _);
            }
        }
        size
    }
}
#[derive(Debug, Default, PartialEq, Clone)]
pub struct Rpc_Resp_WifiSetBand {
    pub r#resp: i32,
}
impl Rpc_Resp_WifiSetBand {
    ///Return a reference to `resp`
    #[inline]
    pub fn r#resp(&self) -> &i32 {
        &self.r#resp
    }
    ///Return a mutable reference to `resp`
    #[inline]
    pub fn mut_resp(&mut self) -> &mut i32 {
        &mut self.r#resp
    }
    ///Set the value of `resp`
    #[inline]
    pub fn set_resp(&mut self, value: i32) -> &mut Self {
        self.r#resp = value.into();
        self
    }
    ///Builder method that sets the value of `resp`. Useful for initializing the message.
    #[inline]
    pub fn init_resp(mut self, value: i32) -> Self {
        self.r#resp = value.into();
        self
    }
}
impl ::micropb::MessageDecode for Rpc_Resp_WifiSetBand {
    fn decode<IMPL_MICROPB_READ: ::micropb::PbRead>(
        &mut self,
        decoder: &mut ::micropb::PbDecoder<IMPL_MICROPB_READ>,
        len: usize,
    ) -> Result<(), ::micropb::DecodeError<IMPL_MICROPB_READ::Error>> {
        use ::micropb::{FieldDecode, PbBytes, PbMap, PbString, PbVec};
        let before = decoder.bytes_read();
        while decoder.bytes_read() - before < len {
            let tag = decoder.decode_tag()?;
            match tag.field_num() {
                0 => return Err(::micropb::DecodeError::ZeroField),
                1u32 => {
                    let mut_ref = &mut self.r#resp;
                    {
                        let val = decoder.decode_int32()?;
                        let val_ref = &val;
                        if *val_ref != 0 {
                            *mut_ref = val as _;
                        }
                    };
                }
                _ => {
                    decoder.skip_wire_value(tag.wire_type())?;
                }
            }
        }
        Ok(())
    }
}
impl ::micropb::MessageEncode for Rpc_Resp_WifiSetBand {
    const MAX_SIZE: ::core::option::Option<usize> = 'msg: {
        let mut max_size = 0;
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(10usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        ::core::option::Option::Some(max_size)
    };
    fn encode<IMPL_MICROPB_WRITE: ::micropb::PbWrite>(
        &self,
        encoder: &mut ::micropb::PbEncoder<IMPL_MICROPB_WRITE>,
    ) -> Result<(), IMPL_MICROPB_WRITE::Error> {
        use ::micropb::{FieldEncode, PbMap};
        {
            let val_ref = &self.r#resp;
            if *val_ref != 0 {
                encoder.encode_varint32(8u32)?;
                encoder.encode_int32(*val_ref as _)?;
            }
        }
        Ok(())
    }
    fn compute_size(&self) -> usize {
        use ::micropb::{FieldEncode, PbMap};
        let mut size = 0;
        {
            let val_ref = &self.r#resp;
            if *val_ref != 0 {
                size += 1usize + ::micropb::size::sizeof_int32(*val_ref as _);
            }
        }
        size
    }
}
#[derive(Debug, Default, PartialEq, Clone)]
pub struct Rpc_Req_WifiGetBand {}
impl Rpc_Req_WifiGetBand {}
impl ::micropb::MessageDecode for Rpc_Req_WifiGetBand {
    fn decode<IMPL_MICROPB_READ: ::micropb::PbRead>(
        &mut self,
        decoder: &mut ::micropb::PbDecoder<IMPL_MICROPB_READ>,
        len: usize,
    ) -> Result<(), ::micropb::DecodeError<IMPL_MICROPB_READ::Error>> {
        use ::micropb::{FieldDecode, PbBytes, PbMap, PbString, PbVec};
        let before = decoder.bytes_read();
        while decoder.bytes_read() - before < len {
            let tag = decoder.decode_tag()?;
            match tag.field_num() {
                0 => return Err(::micropb::DecodeError::ZeroField),
                _ => {
                    decoder.skip_wire_value(tag.wire_type())?;
                }
            }
        }
        Ok(())
    }
}
impl ::micropb::MessageEncode for Rpc_Req_WifiGetBand {
    const MAX_SIZE: ::core::option::Option<usize> = 'msg: {
        let mut max_size = 0;
        ::core::option::Option::Some(max_size)
    };
    fn encode<IMPL_MICROPB_WRITE: ::micropb::PbWrite>(
        &self,
        encoder: &mut ::micropb::PbEncoder<IMPL_MICROPB_WRITE>,
    ) -> Result<(), IMPL_MICROPB_WRITE::Error> {
        use ::micropb::{FieldEncode, PbMap};
        Ok(())
    }
    fn compute_size(&self) -> usize {
        use ::micropb::{FieldEncode, PbMap};
        let mut size = 0;
        size
    }
}
#[derive(Debug, Default, PartialEq, Clone)]
pub struct Rpc_Resp_WifiGetBand {
    pub r#resp: i32,
    pub r#band: u32,
}
impl Rpc_Resp_WifiGetBand {
    ///Return a reference to `resp`
    #[inline]
    pub fn r#resp(&self) -> &i32 {
        &self.r#resp
    }
    ///Return a mutable reference to `resp`
    #[inline]
    pub fn mut_resp(&mut self) -> &mut i32 {
        &mut self.r#resp
    }
    ///Set the value of `resp`
    #[inline]
    pub fn set_resp(&mut self, value: i32) -> &mut Self {
        self.r#resp = value.into();
        self
    }
    ///Builder method that sets the value of `resp`. Useful for initializing the message.
    #[inline]
    pub fn init_resp(mut self, value: i32) -> Self {
        self.r#resp = value.into();
        self
    }
    ///Return a reference to `band`
    #[inline]
    pub fn r#band(&self) -> &u32 {
        &self.r#band
    }
    ///Return a mutable reference to `band`
    #[inline]
    pub fn mut_band(&mut self) -> &mut u32 {
        &mut self.r#band
    }
    ///Set the value of `band`
    #[inline]
    pub fn set_band(&mut self, value: u32) -> &mut Self {
        self.r#band = value.into();
        self
    }
    ///Builder method that sets the value of `band`. Useful for initializing the message.
    #[inline]
    pub fn init_band(mut self, value: u32) -> Self {
        self.r#band = value.into();
        self
    }
}
impl ::micropb::MessageDecode for Rpc_Resp_WifiGetBand {
    fn decode<IMPL_MICROPB_READ: ::micropb::PbRead>(
        &mut self,
        decoder: &mut ::micropb::PbDecoder<IMPL_MICROPB_READ>,
        len: usize,
    ) -> Result<(), ::micropb::DecodeError<IMPL_MICROPB_READ::Error>> {
        use ::micropb::{FieldDecode, PbBytes, PbMap, PbString, PbVec};
        let before = decoder.bytes_read();
        while decoder.bytes_read() - before < len {
            let tag = decoder.decode_tag()?;
            match tag.field_num() {
                0 => return Err(::micropb::DecodeError::ZeroField),
                1u32 => {
                    let mut_ref = &mut self.r#resp;
                    {
                        let val = decoder.decode_int32()?;
                        let val_ref = &val;
                        if *val_ref != 0 {
                            *mut_ref = val as _;
                        }
                    };
                }
                2u32 => {
                    let mut_ref = &mut self.r#band;
                    {
                        let val = decoder.decode_varint32()?;
                        let val_ref = &val;
                        if *val_ref != 0 {
                            *mut_ref = val as _;
                        }
                    };
                }
                _ => {
                    decoder.skip_wire_value(tag.wire_type())?;
                }
            }
        }
        Ok(())
    }
}
impl ::micropb::MessageEncode for Rpc_Resp_WifiGetBand {
    const MAX_SIZE: ::core::option::Option<usize> = 'msg: {
        let mut max_size = 0;
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(10usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(5usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        ::core::option::Option::Some(max_size)
    };
    fn encode<IMPL_MICROPB_WRITE: ::micropb::PbWrite>(
        &self,
        encoder: &mut ::micropb::PbEncoder<IMPL_MICROPB_WRITE>,
    ) -> Result<(), IMPL_MICROPB_WRITE::Error> {
        use ::micropb::{FieldEncode, PbMap};
        {
            let val_ref = &self.r#resp;
            if *val_ref != 0 {
                encoder.encode_varint32(8u32)?;
                encoder.encode_int32(*val_ref as _)?;
            }
        }
        {
            let val_ref = &self.r#band;
            if *val_ref != 0 {
                encoder.encode_varint32(16u32)?;
                encoder.encode_varint32(*val_ref as _)?;
            }
        }
        Ok(())
    }
    fn compute_size(&self) -> usize {
        use ::micropb::{FieldEncode, PbMap};
        let mut size = 0;
        {
            let val_ref = &self.r#resp;
            if *val_ref != 0 {
                size += 1usize + ::micropb::size::sizeof_int32(*val_ref as _);
            }
        }
        {
            let val_ref = &self.r#band;
            if *val_ref != 0 {
                size += 1usize + ::micropb::size::sizeof_varint32(*val_ref as _);
            }
        }
        size
    }
}
#[derive(Debug, Default, PartialEq, Clone)]
pub struct Rpc_Req_WifiSetBandMode {
    pub r#bandmode: u32,
}
impl Rpc_Req_WifiSetBandMode {
    ///Return a reference to `bandmode`
    #[inline]
    pub fn r#bandmode(&self) -> &u32 {
        &self.r#bandmode
    }
    ///Return a mutable reference to `bandmode`
    #[inline]
    pub fn mut_bandmode(&mut self) -> &mut u32 {
        &mut self.r#bandmode
    }
    ///Set the value of `bandmode`
    #[inline]
    pub fn set_bandmode(&mut self, value: u32) -> &mut Self {
        self.r#bandmode = value.into();
        self
    }
    ///Builder method that sets the value of `bandmode`. Useful for initializing the message.
    #[inline]
    pub fn init_bandmode(mut self, value: u32) -> Self {
        self.r#bandmode = value.into();
        self
    }
}
impl ::micropb::MessageDecode for Rpc_Req_WifiSetBandMode {
    fn decode<IMPL_MICROPB_READ: ::micropb::PbRead>(
        &mut self,
        decoder: &mut ::micropb::PbDecoder<IMPL_MICROPB_READ>,
        len: usize,
    ) -> Result<(), ::micropb::DecodeError<IMPL_MICROPB_READ::Error>> {
        use ::micropb::{FieldDecode, PbBytes, PbMap, PbString, PbVec};
        let before = decoder.bytes_read();
        while decoder.bytes_read() - before < len {
            let tag = decoder.decode_tag()?;
            match tag.field_num() {
                0 => return Err(::micropb::DecodeError::ZeroField),
                1u32 => {
                    let mut_ref = &mut self.r#bandmode;
                    {
                        let val = decoder.decode_varint32()?;
                        let val_ref = &val;
                        if *val_ref != 0 {
                            *mut_ref = val as _;
                        }
                    };
                }
                _ => {
                    decoder.skip_wire_value(tag.wire_type())?;
                }
            }
        }
        Ok(())
    }
}
impl ::micropb::MessageEncode for Rpc_Req_WifiSetBandMode {
    const MAX_SIZE: ::core::option::Option<usize> = 'msg: {
        let mut max_size = 0;
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(5usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        ::core::option::Option::Some(max_size)
    };
    fn encode<IMPL_MICROPB_WRITE: ::micropb::PbWrite>(
        &self,
        encoder: &mut ::micropb::PbEncoder<IMPL_MICROPB_WRITE>,
    ) -> Result<(), IMPL_MICROPB_WRITE::Error> {
        use ::micropb::{FieldEncode, PbMap};
        {
            let val_ref = &self.r#bandmode;
            if *val_ref != 0 {
                encoder.encode_varint32(8u32)?;
                encoder.encode_varint32(*val_ref as _)?;
            }
        }
        Ok(())
    }
    fn compute_size(&self) -> usize {
        use ::micropb::{FieldEncode, PbMap};
        let mut size = 0;
        {
            let val_ref = &self.r#bandmode;
            if *val_ref != 0 {
                size += 1usize + ::micropb::size::sizeof_varint32(*val_ref as _);
            }
        }
        size
    }
}
#[derive(Debug, Default, PartialEq, Clone)]
pub struct Rpc_Resp_WifiSetBandMode {
    pub r#resp: i32,
}
impl Rpc_Resp_WifiSetBandMode {
    ///Return a reference to `resp`
    #[inline]
    pub fn r#resp(&self) -> &i32 {
        &self.r#resp
    }
    ///Return a mutable reference to `resp`
    #[inline]
    pub fn mut_resp(&mut self) -> &mut i32 {
        &mut self.r#resp
    }
    ///Set the value of `resp`
    #[inline]
    pub fn set_resp(&mut self, value: i32) -> &mut Self {
        self.r#resp = value.into();
        self
    }
    ///Builder method that sets the value of `resp`. Useful for initializing the message.
    #[inline]
    pub fn init_resp(mut self, value: i32) -> Self {
        self.r#resp = value.into();
        self
    }
}
impl ::micropb::MessageDecode for Rpc_Resp_WifiSetBandMode {
    fn decode<IMPL_MICROPB_READ: ::micropb::PbRead>(
        &mut self,
        decoder: &mut ::micropb::PbDecoder<IMPL_MICROPB_READ>,
        len: usize,
    ) -> Result<(), ::micropb::DecodeError<IMPL_MICROPB_READ::Error>> {
        use ::micropb::{FieldDecode, PbBytes, PbMap, PbString, PbVec};
        let before = decoder.bytes_read();
        while decoder.bytes_read() - before < len {
            let tag = decoder.decode_tag()?;
            match tag.field_num() {
                0 => return Err(::micropb::DecodeError::ZeroField),
                1u32 => {
                    let mut_ref = &mut self.r#resp;
                    {
                        let val = decoder.decode_int32()?;
                        let val_ref = &val;
                        if *val_ref != 0 {
                            *mut_ref = val as _;
                        }
                    };
                }
                _ => {
                    decoder.skip_wire_value(tag.wire_type())?;
                }
            }
        }
        Ok(())
    }
}
impl ::micropb::MessageEncode for Rpc_Resp_WifiSetBandMode {
    const MAX_SIZE: ::core::option::Option<usize> = 'msg: {
        let mut max_size = 0;
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(10usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        ::core::option::Option::Some(max_size)
    };
    fn encode<IMPL_MICROPB_WRITE: ::micropb::PbWrite>(
        &self,
        encoder: &mut ::micropb::PbEncoder<IMPL_MICROPB_WRITE>,
    ) -> Result<(), IMPL_MICROPB_WRITE::Error> {
        use ::micropb::{FieldEncode, PbMap};
        {
            let val_ref = &self.r#resp;
            if *val_ref != 0 {
                encoder.encode_varint32(8u32)?;
                encoder.encode_int32(*val_ref as _)?;
            }
        }
        Ok(())
    }
    fn compute_size(&self) -> usize {
        use ::micropb::{FieldEncode, PbMap};
        let mut size = 0;
        {
            let val_ref = &self.r#resp;
            if *val_ref != 0 {
                size += 1usize + ::micropb::size::sizeof_int32(*val_ref as _);
            }
        }
        size
    }
}
#[derive(Debug, Default, PartialEq, Clone)]
pub struct Rpc_Req_WifiGetBandMode {}
impl Rpc_Req_WifiGetBandMode {}
impl ::micropb::MessageDecode for Rpc_Req_WifiGetBandMode {
    fn decode<IMPL_MICROPB_READ: ::micropb::PbRead>(
        &mut self,
        decoder: &mut ::micropb::PbDecoder<IMPL_MICROPB_READ>,
        len: usize,
    ) -> Result<(), ::micropb::DecodeError<IMPL_MICROPB_READ::Error>> {
        use ::micropb::{FieldDecode, PbBytes, PbMap, PbString, PbVec};
        let before = decoder.bytes_read();
        while decoder.bytes_read() - before < len {
            let tag = decoder.decode_tag()?;
            match tag.field_num() {
                0 => return Err(::micropb::DecodeError::ZeroField),
                _ => {
                    decoder.skip_wire_value(tag.wire_type())?;
                }
            }
        }
        Ok(())
    }
}
impl ::micropb::MessageEncode for Rpc_Req_WifiGetBandMode {
    const MAX_SIZE: ::core::option::Option<usize> = 'msg: {
        let mut max_size = 0;
        ::core::option::Option::Some(max_size)
    };
    fn encode<IMPL_MICROPB_WRITE: ::micropb::PbWrite>(
        &self,
        encoder: &mut ::micropb::PbEncoder<IMPL_MICROPB_WRITE>,
    ) -> Result<(), IMPL_MICROPB_WRITE::Error> {
        use ::micropb::{FieldEncode, PbMap};
        Ok(())
    }
    fn compute_size(&self) -> usize {
        use ::micropb::{FieldEncode, PbMap};
        let mut size = 0;
        size
    }
}
#[derive(Debug, Default, PartialEq, Clone)]
pub struct Rpc_Resp_WifiGetBandMode {
    pub r#resp: i32,
    pub r#bandmode: u32,
}
impl Rpc_Resp_WifiGetBandMode {
    ///Return a reference to `resp`
    #[inline]
    pub fn r#resp(&self) -> &i32 {
        &self.r#resp
    }
    ///Return a mutable reference to `resp`
    #[inline]
    pub fn mut_resp(&mut self) -> &mut i32 {
        &mut self.r#resp
    }
    ///Set the value of `resp`
    #[inline]
    pub fn set_resp(&mut self, value: i32) -> &mut Self {
        self.r#resp = value.into();
        self
    }
    ///Builder method that sets the value of `resp`. Useful for initializing the message.
    #[inline]
    pub fn init_resp(mut self, value: i32) -> Self {
        self.r#resp = value.into();
        self
    }
    ///Return a reference to `bandmode`
    #[inline]
    pub fn r#bandmode(&self) -> &u32 {
        &self.r#bandmode
    }
    ///Return a mutable reference to `bandmode`
    #[inline]
    pub fn mut_bandmode(&mut self) -> &mut u32 {
        &mut self.r#bandmode
    }
    ///Set the value of `bandmode`
    #[inline]
    pub fn set_bandmode(&mut self, value: u32) -> &mut Self {
        self.r#bandmode = value.into();
        self
    }
    ///Builder method that sets the value of `bandmode`. Useful for initializing the message.
    #[inline]
    pub fn init_bandmode(mut self, value: u32) -> Self {
        self.r#bandmode = value.into();
        self
    }
}
impl ::micropb::MessageDecode for Rpc_Resp_WifiGetBandMode {
    fn decode<IMPL_MICROPB_READ: ::micropb::PbRead>(
        &mut self,
        decoder: &mut ::micropb::PbDecoder<IMPL_MICROPB_READ>,
        len: usize,
    ) -> Result<(), ::micropb::DecodeError<IMPL_MICROPB_READ::Error>> {
        use ::micropb::{FieldDecode, PbBytes, PbMap, PbString, PbVec};
        let before = decoder.bytes_read();
        while decoder.bytes_read() - before < len {
            let tag = decoder.decode_tag()?;
            match tag.field_num() {
                0 => return Err(::micropb::DecodeError::ZeroField),
                1u32 => {
                    let mut_ref = &mut self.r#resp;
                    {
                        let val = decoder.decode_int32()?;
                        let val_ref = &val;
                        if *val_ref != 0 {
                            *mut_ref = val as _;
                        }
                    };
                }
                2u32 => {
                    let mut_ref = &mut self.r#bandmode;
                    {
                        let val = decoder.decode_varint32()?;
                        let val_ref = &val;
                        if *val_ref != 0 {
                            *mut_ref = val as _;
                        }
                    };
                }
                _ => {
                    decoder.skip_wire_value(tag.wire_type())?;
                }
            }
        }
        Ok(())
    }
}
impl ::micropb::MessageEncode for Rpc_Resp_WifiGetBandMode {
    const MAX_SIZE: ::core::option::Option<usize> = 'msg: {
        let mut max_size = 0;
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(10usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(5usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        ::core::option::Option::Some(max_size)
    };
    fn encode<IMPL_MICROPB_WRITE: ::micropb::PbWrite>(
        &self,
        encoder: &mut ::micropb::PbEncoder<IMPL_MICROPB_WRITE>,
    ) -> Result<(), IMPL_MICROPB_WRITE::Error> {
        use ::micropb::{FieldEncode, PbMap};
        {
            let val_ref = &self.r#resp;
            if *val_ref != 0 {
                encoder.encode_varint32(8u32)?;
                encoder.encode_int32(*val_ref as _)?;
            }
        }
        {
            let val_ref = &self.r#bandmode;
            if *val_ref != 0 {
                encoder.encode_varint32(16u32)?;
                encoder.encode_varint32(*val_ref as _)?;
            }
        }
        Ok(())
    }
    fn compute_size(&self) -> usize {
        use ::micropb::{FieldEncode, PbMap};
        let mut size = 0;
        {
            let val_ref = &self.r#resp;
            if *val_ref != 0 {
                size += 1usize + ::micropb::size::sizeof_int32(*val_ref as _);
            }
        }
        {
            let val_ref = &self.r#bandmode;
            if *val_ref != 0 {
                size += 1usize + ::micropb::size::sizeof_varint32(*val_ref as _);
            }
        }
        size
    }
}
#[derive(Debug, Default, PartialEq, Clone)]
pub struct Rpc_Req_GetCoprocessorFwVersion {}
impl Rpc_Req_GetCoprocessorFwVersion {}
impl ::micropb::MessageDecode for Rpc_Req_GetCoprocessorFwVersion {
    fn decode<IMPL_MICROPB_READ: ::micropb::PbRead>(
        &mut self,
        decoder: &mut ::micropb::PbDecoder<IMPL_MICROPB_READ>,
        len: usize,
    ) -> Result<(), ::micropb::DecodeError<IMPL_MICROPB_READ::Error>> {
        use ::micropb::{FieldDecode, PbBytes, PbMap, PbString, PbVec};
        let before = decoder.bytes_read();
        while decoder.bytes_read() - before < len {
            let tag = decoder.decode_tag()?;
            match tag.field_num() {
                0 => return Err(::micropb::DecodeError::ZeroField),
                _ => {
                    decoder.skip_wire_value(tag.wire_type())?;
                }
            }
        }
        Ok(())
    }
}
impl ::micropb::MessageEncode for Rpc_Req_GetCoprocessorFwVersion {
    const MAX_SIZE: ::core::option::Option<usize> = 'msg: {
        let mut max_size = 0;
        ::core::option::Option::Some(max_size)
    };
    fn encode<IMPL_MICROPB_WRITE: ::micropb::PbWrite>(
        &self,
        encoder: &mut ::micropb::PbEncoder<IMPL_MICROPB_WRITE>,
    ) -> Result<(), IMPL_MICROPB_WRITE::Error> {
        use ::micropb::{FieldEncode, PbMap};
        Ok(())
    }
    fn compute_size(&self) -> usize {
        use ::micropb::{FieldEncode, PbMap};
        let mut size = 0;
        size
    }
}
#[derive(Debug, Default, PartialEq, Clone)]
pub struct Rpc_Resp_GetCoprocessorFwVersion {
    pub r#resp: i32,
    pub r#major1: u32,
    pub r#minor1: u32,
    pub r#patch1: u32,
}
impl Rpc_Resp_GetCoprocessorFwVersion {
    ///Return a reference to `resp`
    #[inline]
    pub fn r#resp(&self) -> &i32 {
        &self.r#resp
    }
    ///Return a mutable reference to `resp`
    #[inline]
    pub fn mut_resp(&mut self) -> &mut i32 {
        &mut self.r#resp
    }
    ///Set the value of `resp`
    #[inline]
    pub fn set_resp(&mut self, value: i32) -> &mut Self {
        self.r#resp = value.into();
        self
    }
    ///Builder method that sets the value of `resp`. Useful for initializing the message.
    #[inline]
    pub fn init_resp(mut self, value: i32) -> Self {
        self.r#resp = value.into();
        self
    }
    ///Return a reference to `major1`
    #[inline]
    pub fn r#major1(&self) -> &u32 {
        &self.r#major1
    }
    ///Return a mutable reference to `major1`
    #[inline]
    pub fn mut_major1(&mut self) -> &mut u32 {
        &mut self.r#major1
    }
    ///Set the value of `major1`
    #[inline]
    pub fn set_major1(&mut self, value: u32) -> &mut Self {
        self.r#major1 = value.into();
        self
    }
    ///Builder method that sets the value of `major1`. Useful for initializing the message.
    #[inline]
    pub fn init_major1(mut self, value: u32) -> Self {
        self.r#major1 = value.into();
        self
    }
    ///Return a reference to `minor1`
    #[inline]
    pub fn r#minor1(&self) -> &u32 {
        &self.r#minor1
    }
    ///Return a mutable reference to `minor1`
    #[inline]
    pub fn mut_minor1(&mut self) -> &mut u32 {
        &mut self.r#minor1
    }
    ///Set the value of `minor1`
    #[inline]
    pub fn set_minor1(&mut self, value: u32) -> &mut Self {
        self.r#minor1 = value.into();
        self
    }
    ///Builder method that sets the value of `minor1`. Useful for initializing the message.
    #[inline]
    pub fn init_minor1(mut self, value: u32) -> Self {
        self.r#minor1 = value.into();
        self
    }
    ///Return a reference to `patch1`
    #[inline]
    pub fn r#patch1(&self) -> &u32 {
        &self.r#patch1
    }
    ///Return a mutable reference to `patch1`
    #[inline]
    pub fn mut_patch1(&mut self) -> &mut u32 {
        &mut self.r#patch1
    }
    ///Set the value of `patch1`
    #[inline]
    pub fn set_patch1(&mut self, value: u32) -> &mut Self {
        self.r#patch1 = value.into();
        self
    }
    ///Builder method that sets the value of `patch1`. Useful for initializing the message.
    #[inline]
    pub fn init_patch1(mut self, value: u32) -> Self {
        self.r#patch1 = value.into();
        self
    }
}
impl ::micropb::MessageDecode for Rpc_Resp_GetCoprocessorFwVersion {
    fn decode<IMPL_MICROPB_READ: ::micropb::PbRead>(
        &mut self,
        decoder: &mut ::micropb::PbDecoder<IMPL_MICROPB_READ>,
        len: usize,
    ) -> Result<(), ::micropb::DecodeError<IMPL_MICROPB_READ::Error>> {
        use ::micropb::{FieldDecode, PbBytes, PbMap, PbString, PbVec};
        let before = decoder.bytes_read();
        while decoder.bytes_read() - before < len {
            let tag = decoder.decode_tag()?;
            match tag.field_num() {
                0 => return Err(::micropb::DecodeError::ZeroField),
                1u32 => {
                    let mut_ref = &mut self.r#resp;
                    {
                        let val = decoder.decode_int32()?;
                        let val_ref = &val;
                        if *val_ref != 0 {
                            *mut_ref = val as _;
                        }
                    };
                }
                2u32 => {
                    let mut_ref = &mut self.r#major1;
                    {
                        let val = decoder.decode_varint32()?;
                        let val_ref = &val;
                        if *val_ref != 0 {
                            *mut_ref = val as _;
                        }
                    };
                }
                3u32 => {
                    let mut_ref = &mut self.r#minor1;
                    {
                        let val = decoder.decode_varint32()?;
                        let val_ref = &val;
                        if *val_ref != 0 {
                            *mut_ref = val as _;
                        }
                    };
                }
                4u32 => {
                    let mut_ref = &mut self.r#patch1;
                    {
                        let val = decoder.decode_varint32()?;
                        let val_ref = &val;
                        if *val_ref != 0 {
                            *mut_ref = val as _;
                        }
                    };
                }
                _ => {
                    decoder.skip_wire_value(tag.wire_type())?;
                }
            }
        }
        Ok(())
    }
}
impl ::micropb::MessageEncode for Rpc_Resp_GetCoprocessorFwVersion {
    const MAX_SIZE: ::core::option::Option<usize> = 'msg: {
        let mut max_size = 0;
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(10usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(5usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(5usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(5usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        ::core::option::Option::Some(max_size)
    };
    fn encode<IMPL_MICROPB_WRITE: ::micropb::PbWrite>(
        &self,
        encoder: &mut ::micropb::PbEncoder<IMPL_MICROPB_WRITE>,
    ) -> Result<(), IMPL_MICROPB_WRITE::Error> {
        use ::micropb::{FieldEncode, PbMap};
        {
            let val_ref = &self.r#resp;
            if *val_ref != 0 {
                encoder.encode_varint32(8u32)?;
                encoder.encode_int32(*val_ref as _)?;
            }
        }
        {
            let val_ref = &self.r#major1;
            if *val_ref != 0 {
                encoder.encode_varint32(16u32)?;
                encoder.encode_varint32(*val_ref as _)?;
            }
        }
        {
            let val_ref = &self.r#minor1;
            if *val_ref != 0 {
                encoder.encode_varint32(24u32)?;
                encoder.encode_varint32(*val_ref as _)?;
            }
        }
        {
            let val_ref = &self.r#patch1;
            if *val_ref != 0 {
                encoder.encode_varint32(32u32)?;
                encoder.encode_varint32(*val_ref as _)?;
            }
        }
        Ok(())
    }
    fn compute_size(&self) -> usize {
        use ::micropb::{FieldEncode, PbMap};
        let mut size = 0;
        {
            let val_ref = &self.r#resp;
            if *val_ref != 0 {
                size += 1usize + ::micropb::size::sizeof_int32(*val_ref as _);
            }
        }
        {
            let val_ref = &self.r#major1;
            if *val_ref != 0 {
                size += 1usize + ::micropb::size::sizeof_varint32(*val_ref as _);
            }
        }
        {
            let val_ref = &self.r#minor1;
            if *val_ref != 0 {
                size += 1usize + ::micropb::size::sizeof_varint32(*val_ref as _);
            }
        }
        {
            let val_ref = &self.r#patch1;
            if *val_ref != 0 {
                size += 1usize + ::micropb::size::sizeof_varint32(*val_ref as _);
            }
        }
        size
    }
}
#[derive(Debug, Default, PartialEq, Clone)]
pub struct Rpc_Event_WifiEventNoArgs {
    pub r#resp: i32,
    pub r#event_id: i32,
}
impl Rpc_Event_WifiEventNoArgs {
    ///Return a reference to `resp`
    #[inline]
    pub fn r#resp(&self) -> &i32 {
        &self.r#resp
    }
    ///Return a mutable reference to `resp`
    #[inline]
    pub fn mut_resp(&mut self) -> &mut i32 {
        &mut self.r#resp
    }
    ///Set the value of `resp`
    #[inline]
    pub fn set_resp(&mut self, value: i32) -> &mut Self {
        self.r#resp = value.into();
        self
    }
    ///Builder method that sets the value of `resp`. Useful for initializing the message.
    #[inline]
    pub fn init_resp(mut self, value: i32) -> Self {
        self.r#resp = value.into();
        self
    }
    ///Return a reference to `event_id`
    #[inline]
    pub fn r#event_id(&self) -> &i32 {
        &self.r#event_id
    }
    ///Return a mutable reference to `event_id`
    #[inline]
    pub fn mut_event_id(&mut self) -> &mut i32 {
        &mut self.r#event_id
    }
    ///Set the value of `event_id`
    #[inline]
    pub fn set_event_id(&mut self, value: i32) -> &mut Self {
        self.r#event_id = value.into();
        self
    }
    ///Builder method that sets the value of `event_id`. Useful for initializing the message.
    #[inline]
    pub fn init_event_id(mut self, value: i32) -> Self {
        self.r#event_id = value.into();
        self
    }
}
impl ::micropb::MessageDecode for Rpc_Event_WifiEventNoArgs {
    fn decode<IMPL_MICROPB_READ: ::micropb::PbRead>(
        &mut self,
        decoder: &mut ::micropb::PbDecoder<IMPL_MICROPB_READ>,
        len: usize,
    ) -> Result<(), ::micropb::DecodeError<IMPL_MICROPB_READ::Error>> {
        use ::micropb::{FieldDecode, PbBytes, PbMap, PbString, PbVec};
        let before = decoder.bytes_read();
        while decoder.bytes_read() - before < len {
            let tag = decoder.decode_tag()?;
            match tag.field_num() {
                0 => return Err(::micropb::DecodeError::ZeroField),
                1u32 => {
                    let mut_ref = &mut self.r#resp;
                    {
                        let val = decoder.decode_int32()?;
                        let val_ref = &val;
                        if *val_ref != 0 {
                            *mut_ref = val as _;
                        }
                    };
                }
                2u32 => {
                    let mut_ref = &mut self.r#event_id;
                    {
                        let val = decoder.decode_int32()?;
                        let val_ref = &val;
                        if *val_ref != 0 {
                            *mut_ref = val as _;
                        }
                    };
                }
                _ => {
                    decoder.skip_wire_value(tag.wire_type())?;
                }
            }
        }
        Ok(())
    }
}
impl ::micropb::MessageEncode for Rpc_Event_WifiEventNoArgs {
    const MAX_SIZE: ::core::option::Option<usize> = 'msg: {
        let mut max_size = 0;
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(10usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(10usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        ::core::option::Option::Some(max_size)
    };
    fn encode<IMPL_MICROPB_WRITE: ::micropb::PbWrite>(
        &self,
        encoder: &mut ::micropb::PbEncoder<IMPL_MICROPB_WRITE>,
    ) -> Result<(), IMPL_MICROPB_WRITE::Error> {
        use ::micropb::{FieldEncode, PbMap};
        {
            let val_ref = &self.r#resp;
            if *val_ref != 0 {
                encoder.encode_varint32(8u32)?;
                encoder.encode_int32(*val_ref as _)?;
            }
        }
        {
            let val_ref = &self.r#event_id;
            if *val_ref != 0 {
                encoder.encode_varint32(16u32)?;
                encoder.encode_int32(*val_ref as _)?;
            }
        }
        Ok(())
    }
    fn compute_size(&self) -> usize {
        use ::micropb::{FieldEncode, PbMap};
        let mut size = 0;
        {
            let val_ref = &self.r#resp;
            if *val_ref != 0 {
                size += 1usize + ::micropb::size::sizeof_int32(*val_ref as _);
            }
        }
        {
            let val_ref = &self.r#event_id;
            if *val_ref != 0 {
                size += 1usize + ::micropb::size::sizeof_int32(*val_ref as _);
            }
        }
        size
    }
}
#[derive(Debug, Default, PartialEq, Clone)]
pub struct Rpc_Event_ESPInit {
    pub r#init_data: ::micropb::heapless::Vec<u8, 16>,
}
impl Rpc_Event_ESPInit {
    ///Return a reference to `init_data`
    #[inline]
    pub fn r#init_data(&self) -> &::micropb::heapless::Vec<u8, 16> {
        &self.r#init_data
    }
    ///Return a mutable reference to `init_data`
    #[inline]
    pub fn mut_init_data(&mut self) -> &mut ::micropb::heapless::Vec<u8, 16> {
        &mut self.r#init_data
    }
    ///Set the value of `init_data`
    #[inline]
    pub fn set_init_data(&mut self, value: ::micropb::heapless::Vec<u8, 16>) -> &mut Self {
        self.r#init_data = value.into();
        self
    }
    ///Builder method that sets the value of `init_data`. Useful for initializing the message.
    #[inline]
    pub fn init_init_data(mut self, value: ::micropb::heapless::Vec<u8, 16>) -> Self {
        self.r#init_data = value.into();
        self
    }
}
impl ::micropb::MessageDecode for Rpc_Event_ESPInit {
    fn decode<IMPL_MICROPB_READ: ::micropb::PbRead>(
        &mut self,
        decoder: &mut ::micropb::PbDecoder<IMPL_MICROPB_READ>,
        len: usize,
    ) -> Result<(), ::micropb::DecodeError<IMPL_MICROPB_READ::Error>> {
        use ::micropb::{FieldDecode, PbBytes, PbMap, PbString, PbVec};
        let before = decoder.bytes_read();
        while decoder.bytes_read() - before < len {
            let tag = decoder.decode_tag()?;
            match tag.field_num() {
                0 => return Err(::micropb::DecodeError::ZeroField),
                1u32 => {
                    let mut_ref = &mut self.r#init_data;
                    {
                        decoder.decode_bytes(mut_ref, ::micropb::Presence::Implicit)?;
                    };
                }
                _ => {
                    decoder.skip_wire_value(tag.wire_type())?;
                }
            }
        }
        Ok(())
    }
}
impl ::micropb::MessageEncode for Rpc_Event_ESPInit {
    const MAX_SIZE: ::core::option::Option<usize> = 'msg: {
        let mut max_size = 0;
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(17usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        ::core::option::Option::Some(max_size)
    };
    fn encode<IMPL_MICROPB_WRITE: ::micropb::PbWrite>(
        &self,
        encoder: &mut ::micropb::PbEncoder<IMPL_MICROPB_WRITE>,
    ) -> Result<(), IMPL_MICROPB_WRITE::Error> {
        use ::micropb::{FieldEncode, PbMap};
        {
            let val_ref = &self.r#init_data;
            if !val_ref.is_empty() {
                encoder.encode_varint32(10u32)?;
                encoder.encode_bytes(val_ref)?;
            }
        }
        Ok(())
    }
    fn compute_size(&self) -> usize {
        use ::micropb::{FieldEncode, PbMap};
        let mut size = 0;
        {
            let val_ref = &self.r#init_data;
            if !val_ref.is_empty() {
                size += 1usize + ::micropb::size::sizeof_len_record(val_ref.len());
            }
        }
        size
    }
}
#[derive(Debug, Default, PartialEq, Clone)]
pub struct Rpc_Event_Heartbeat {
    pub r#hb_num: i32,
}
impl Rpc_Event_Heartbeat {
    ///Return a reference to `hb_num`
    #[inline]
    pub fn r#hb_num(&self) -> &i32 {
        &self.r#hb_num
    }
    ///Return a mutable reference to `hb_num`
    #[inline]
    pub fn mut_hb_num(&mut self) -> &mut i32 {
        &mut self.r#hb_num
    }
    ///Set the value of `hb_num`
    #[inline]
    pub fn set_hb_num(&mut self, value: i32) -> &mut Self {
        self.r#hb_num = value.into();
        self
    }
    ///Builder method that sets the value of `hb_num`. Useful for initializing the message.
    #[inline]
    pub fn init_hb_num(mut self, value: i32) -> Self {
        self.r#hb_num = value.into();
        self
    }
}
impl ::micropb::MessageDecode for Rpc_Event_Heartbeat {
    fn decode<IMPL_MICROPB_READ: ::micropb::PbRead>(
        &mut self,
        decoder: &mut ::micropb::PbDecoder<IMPL_MICROPB_READ>,
        len: usize,
    ) -> Result<(), ::micropb::DecodeError<IMPL_MICROPB_READ::Error>> {
        use ::micropb::{FieldDecode, PbBytes, PbMap, PbString, PbVec};
        let before = decoder.bytes_read();
        while decoder.bytes_read() - before < len {
            let tag = decoder.decode_tag()?;
            match tag.field_num() {
                0 => return Err(::micropb::DecodeError::ZeroField),
                1u32 => {
                    let mut_ref = &mut self.r#hb_num;
                    {
                        let val = decoder.decode_int32()?;
                        let val_ref = &val;
                        if *val_ref != 0 {
                            *mut_ref = val as _;
                        }
                    };
                }
                _ => {
                    decoder.skip_wire_value(tag.wire_type())?;
                }
            }
        }
        Ok(())
    }
}
impl ::micropb::MessageEncode for Rpc_Event_Heartbeat {
    const MAX_SIZE: ::core::option::Option<usize> = 'msg: {
        let mut max_size = 0;
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(10usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        ::core::option::Option::Some(max_size)
    };
    fn encode<IMPL_MICROPB_WRITE: ::micropb::PbWrite>(
        &self,
        encoder: &mut ::micropb::PbEncoder<IMPL_MICROPB_WRITE>,
    ) -> Result<(), IMPL_MICROPB_WRITE::Error> {
        use ::micropb::{FieldEncode, PbMap};
        {
            let val_ref = &self.r#hb_num;
            if *val_ref != 0 {
                encoder.encode_varint32(8u32)?;
                encoder.encode_int32(*val_ref as _)?;
            }
        }
        Ok(())
    }
    fn compute_size(&self) -> usize {
        use ::micropb::{FieldEncode, PbMap};
        let mut size = 0;
        {
            let val_ref = &self.r#hb_num;
            if *val_ref != 0 {
                size += 1usize + ::micropb::size::sizeof_int32(*val_ref as _);
            }
        }
        size
    }
}
#[derive(Debug, Default, PartialEq, Clone)]
pub struct Rpc_Event_AP_StaDisconnected {
    pub r#resp: i32,
    pub r#mac: ::micropb::heapless::Vec<u8, 6>,
    pub r#aid: u32,
    pub r#is_mesh_child: bool,
    pub r#reason: u32,
}
impl Rpc_Event_AP_StaDisconnected {
    ///Return a reference to `resp`
    #[inline]
    pub fn r#resp(&self) -> &i32 {
        &self.r#resp
    }
    ///Return a mutable reference to `resp`
    #[inline]
    pub fn mut_resp(&mut self) -> &mut i32 {
        &mut self.r#resp
    }
    ///Set the value of `resp`
    #[inline]
    pub fn set_resp(&mut self, value: i32) -> &mut Self {
        self.r#resp = value.into();
        self
    }
    ///Builder method that sets the value of `resp`. Useful for initializing the message.
    #[inline]
    pub fn init_resp(mut self, value: i32) -> Self {
        self.r#resp = value.into();
        self
    }
    ///Return a reference to `mac`
    #[inline]
    pub fn r#mac(&self) -> &::micropb::heapless::Vec<u8, 6> {
        &self.r#mac
    }
    ///Return a mutable reference to `mac`
    #[inline]
    pub fn mut_mac(&mut self) -> &mut ::micropb::heapless::Vec<u8, 6> {
        &mut self.r#mac
    }
    ///Set the value of `mac`
    #[inline]
    pub fn set_mac(&mut self, value: ::micropb::heapless::Vec<u8, 6>) -> &mut Self {
        self.r#mac = value.into();
        self
    }
    ///Builder method that sets the value of `mac`. Useful for initializing the message.
    #[inline]
    pub fn init_mac(mut self, value: ::micropb::heapless::Vec<u8, 6>) -> Self {
        self.r#mac = value.into();
        self
    }
    ///Return a reference to `aid`
    #[inline]
    pub fn r#aid(&self) -> &u32 {
        &self.r#aid
    }
    ///Return a mutable reference to `aid`
    #[inline]
    pub fn mut_aid(&mut self) -> &mut u32 {
        &mut self.r#aid
    }
    ///Set the value of `aid`
    #[inline]
    pub fn set_aid(&mut self, value: u32) -> &mut Self {
        self.r#aid = value.into();
        self
    }
    ///Builder method that sets the value of `aid`. Useful for initializing the message.
    #[inline]
    pub fn init_aid(mut self, value: u32) -> Self {
        self.r#aid = value.into();
        self
    }
    ///Return a reference to `is_mesh_child`
    #[inline]
    pub fn r#is_mesh_child(&self) -> &bool {
        &self.r#is_mesh_child
    }
    ///Return a mutable reference to `is_mesh_child`
    #[inline]
    pub fn mut_is_mesh_child(&mut self) -> &mut bool {
        &mut self.r#is_mesh_child
    }
    ///Set the value of `is_mesh_child`
    #[inline]
    pub fn set_is_mesh_child(&mut self, value: bool) -> &mut Self {
        self.r#is_mesh_child = value.into();
        self
    }
    ///Builder method that sets the value of `is_mesh_child`. Useful for initializing the message.
    #[inline]
    pub fn init_is_mesh_child(mut self, value: bool) -> Self {
        self.r#is_mesh_child = value.into();
        self
    }
    ///Return a reference to `reason`
    #[inline]
    pub fn r#reason(&self) -> &u32 {
        &self.r#reason
    }
    ///Return a mutable reference to `reason`
    #[inline]
    pub fn mut_reason(&mut self) -> &mut u32 {
        &mut self.r#reason
    }
    ///Set the value of `reason`
    #[inline]
    pub fn set_reason(&mut self, value: u32) -> &mut Self {
        self.r#reason = value.into();
        self
    }
    ///Builder method that sets the value of `reason`. Useful for initializing the message.
    #[inline]
    pub fn init_reason(mut self, value: u32) -> Self {
        self.r#reason = value.into();
        self
    }
}
impl ::micropb::MessageDecode for Rpc_Event_AP_StaDisconnected {
    fn decode<IMPL_MICROPB_READ: ::micropb::PbRead>(
        &mut self,
        decoder: &mut ::micropb::PbDecoder<IMPL_MICROPB_READ>,
        len: usize,
    ) -> Result<(), ::micropb::DecodeError<IMPL_MICROPB_READ::Error>> {
        use ::micropb::{FieldDecode, PbBytes, PbMap, PbString, PbVec};
        let before = decoder.bytes_read();
        while decoder.bytes_read() - before < len {
            let tag = decoder.decode_tag()?;
            match tag.field_num() {
                0 => return Err(::micropb::DecodeError::ZeroField),
                1u32 => {
                    let mut_ref = &mut self.r#resp;
                    {
                        let val = decoder.decode_int32()?;
                        let val_ref = &val;
                        if *val_ref != 0 {
                            *mut_ref = val as _;
                        }
                    };
                }
                2u32 => {
                    let mut_ref = &mut self.r#mac;
                    {
                        decoder.decode_bytes(mut_ref, ::micropb::Presence::Implicit)?;
                    };
                }
                3u32 => {
                    let mut_ref = &mut self.r#aid;
                    {
                        let val = decoder.decode_varint32()?;
                        let val_ref = &val;
                        if *val_ref != 0 {
                            *mut_ref = val as _;
                        }
                    };
                }
                4u32 => {
                    let mut_ref = &mut self.r#is_mesh_child;
                    {
                        let val = decoder.decode_bool()?;
                        let val_ref = &val;
                        if *val_ref {
                            *mut_ref = val as _;
                        }
                    };
                }
                5u32 => {
                    let mut_ref = &mut self.r#reason;
                    {
                        let val = decoder.decode_varint32()?;
                        let val_ref = &val;
                        if *val_ref != 0 {
                            *mut_ref = val as _;
                        }
                    };
                }
                _ => {
                    decoder.skip_wire_value(tag.wire_type())?;
                }
            }
        }
        Ok(())
    }
}
impl ::micropb::MessageEncode for Rpc_Event_AP_StaDisconnected {
    const MAX_SIZE: ::core::option::Option<usize> = 'msg: {
        let mut max_size = 0;
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(10usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(7usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(5usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(1usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(5usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        ::core::option::Option::Some(max_size)
    };
    fn encode<IMPL_MICROPB_WRITE: ::micropb::PbWrite>(
        &self,
        encoder: &mut ::micropb::PbEncoder<IMPL_MICROPB_WRITE>,
    ) -> Result<(), IMPL_MICROPB_WRITE::Error> {
        use ::micropb::{FieldEncode, PbMap};
        {
            let val_ref = &self.r#resp;
            if *val_ref != 0 {
                encoder.encode_varint32(8u32)?;
                encoder.encode_int32(*val_ref as _)?;
            }
        }
        {
            let val_ref = &self.r#mac;
            if !val_ref.is_empty() {
                encoder.encode_varint32(18u32)?;
                encoder.encode_bytes(val_ref)?;
            }
        }
        {
            let val_ref = &self.r#aid;
            if *val_ref != 0 {
                encoder.encode_varint32(24u32)?;
                encoder.encode_varint32(*val_ref as _)?;
            }
        }
        {
            let val_ref = &self.r#is_mesh_child;
            if *val_ref {
                encoder.encode_varint32(32u32)?;
                encoder.encode_bool(*val_ref)?;
            }
        }
        {
            let val_ref = &self.r#reason;
            if *val_ref != 0 {
                encoder.encode_varint32(40u32)?;
                encoder.encode_varint32(*val_ref as _)?;
            }
        }
        Ok(())
    }
    fn compute_size(&self) -> usize {
        use ::micropb::{FieldEncode, PbMap};
        let mut size = 0;
        {
            let val_ref = &self.r#resp;
            if *val_ref != 0 {
                size += 1usize + ::micropb::size::sizeof_int32(*val_ref as _);
            }
        }
        {
            let val_ref = &self.r#mac;
            if !val_ref.is_empty() {
                size += 1usize + ::micropb::size::sizeof_len_record(val_ref.len());
            }
        }
        {
            let val_ref = &self.r#aid;
            if *val_ref != 0 {
                size += 1usize + ::micropb::size::sizeof_varint32(*val_ref as _);
            }
        }
        {
            let val_ref = &self.r#is_mesh_child;
            if *val_ref {
                size += 1usize + 1;
            }
        }
        {
            let val_ref = &self.r#reason;
            if *val_ref != 0 {
                size += 1usize + ::micropb::size::sizeof_varint32(*val_ref as _);
            }
        }
        size
    }
}
#[derive(Debug, Default, PartialEq, Clone)]
pub struct Rpc_Event_AP_StaConnected {
    pub r#resp: i32,
    pub r#mac: ::micropb::heapless::Vec<u8, 6>,
    pub r#aid: u32,
    pub r#is_mesh_child: bool,
}
impl Rpc_Event_AP_StaConnected {
    ///Return a reference to `resp`
    #[inline]
    pub fn r#resp(&self) -> &i32 {
        &self.r#resp
    }
    ///Return a mutable reference to `resp`
    #[inline]
    pub fn mut_resp(&mut self) -> &mut i32 {
        &mut self.r#resp
    }
    ///Set the value of `resp`
    #[inline]
    pub fn set_resp(&mut self, value: i32) -> &mut Self {
        self.r#resp = value.into();
        self
    }
    ///Builder method that sets the value of `resp`. Useful for initializing the message.
    #[inline]
    pub fn init_resp(mut self, value: i32) -> Self {
        self.r#resp = value.into();
        self
    }
    ///Return a reference to `mac`
    #[inline]
    pub fn r#mac(&self) -> &::micropb::heapless::Vec<u8, 6> {
        &self.r#mac
    }
    ///Return a mutable reference to `mac`
    #[inline]
    pub fn mut_mac(&mut self) -> &mut ::micropb::heapless::Vec<u8, 6> {
        &mut self.r#mac
    }
    ///Set the value of `mac`
    #[inline]
    pub fn set_mac(&mut self, value: ::micropb::heapless::Vec<u8, 6>) -> &mut Self {
        self.r#mac = value.into();
        self
    }
    ///Builder method that sets the value of `mac`. Useful for initializing the message.
    #[inline]
    pub fn init_mac(mut self, value: ::micropb::heapless::Vec<u8, 6>) -> Self {
        self.r#mac = value.into();
        self
    }
    ///Return a reference to `aid`
    #[inline]
    pub fn r#aid(&self) -> &u32 {
        &self.r#aid
    }
    ///Return a mutable reference to `aid`
    #[inline]
    pub fn mut_aid(&mut self) -> &mut u32 {
        &mut self.r#aid
    }
    ///Set the value of `aid`
    #[inline]
    pub fn set_aid(&mut self, value: u32) -> &mut Self {
        self.r#aid = value.into();
        self
    }
    ///Builder method that sets the value of `aid`. Useful for initializing the message.
    #[inline]
    pub fn init_aid(mut self, value: u32) -> Self {
        self.r#aid = value.into();
        self
    }
    ///Return a reference to `is_mesh_child`
    #[inline]
    pub fn r#is_mesh_child(&self) -> &bool {
        &self.r#is_mesh_child
    }
    ///Return a mutable reference to `is_mesh_child`
    #[inline]
    pub fn mut_is_mesh_child(&mut self) -> &mut bool {
        &mut self.r#is_mesh_child
    }
    ///Set the value of `is_mesh_child`
    #[inline]
    pub fn set_is_mesh_child(&mut self, value: bool) -> &mut Self {
        self.r#is_mesh_child = value.into();
        self
    }
    ///Builder method that sets the value of `is_mesh_child`. Useful for initializing the message.
    #[inline]
    pub fn init_is_mesh_child(mut self, value: bool) -> Self {
        self.r#is_mesh_child = value.into();
        self
    }
}
impl ::micropb::MessageDecode for Rpc_Event_AP_StaConnected {
    fn decode<IMPL_MICROPB_READ: ::micropb::PbRead>(
        &mut self,
        decoder: &mut ::micropb::PbDecoder<IMPL_MICROPB_READ>,
        len: usize,
    ) -> Result<(), ::micropb::DecodeError<IMPL_MICROPB_READ::Error>> {
        use ::micropb::{FieldDecode, PbBytes, PbMap, PbString, PbVec};
        let before = decoder.bytes_read();
        while decoder.bytes_read() - before < len {
            let tag = decoder.decode_tag()?;
            match tag.field_num() {
                0 => return Err(::micropb::DecodeError::ZeroField),
                1u32 => {
                    let mut_ref = &mut self.r#resp;
                    {
                        let val = decoder.decode_int32()?;
                        let val_ref = &val;
                        if *val_ref != 0 {
                            *mut_ref = val as _;
                        }
                    };
                }
                2u32 => {
                    let mut_ref = &mut self.r#mac;
                    {
                        decoder.decode_bytes(mut_ref, ::micropb::Presence::Implicit)?;
                    };
                }
                3u32 => {
                    let mut_ref = &mut self.r#aid;
                    {
                        let val = decoder.decode_varint32()?;
                        let val_ref = &val;
                        if *val_ref != 0 {
                            *mut_ref = val as _;
                        }
                    };
                }
                4u32 => {
                    let mut_ref = &mut self.r#is_mesh_child;
                    {
                        let val = decoder.decode_bool()?;
                        let val_ref = &val;
                        if *val_ref {
                            *mut_ref = val as _;
                        }
                    };
                }
                _ => {
                    decoder.skip_wire_value(tag.wire_type())?;
                }
            }
        }
        Ok(())
    }
}
impl ::micropb::MessageEncode for Rpc_Event_AP_StaConnected {
    const MAX_SIZE: ::core::option::Option<usize> = 'msg: {
        let mut max_size = 0;
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(10usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(7usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(5usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(1usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        ::core::option::Option::Some(max_size)
    };
    fn encode<IMPL_MICROPB_WRITE: ::micropb::PbWrite>(
        &self,
        encoder: &mut ::micropb::PbEncoder<IMPL_MICROPB_WRITE>,
    ) -> Result<(), IMPL_MICROPB_WRITE::Error> {
        use ::micropb::{FieldEncode, PbMap};
        {
            let val_ref = &self.r#resp;
            if *val_ref != 0 {
                encoder.encode_varint32(8u32)?;
                encoder.encode_int32(*val_ref as _)?;
            }
        }
        {
            let val_ref = &self.r#mac;
            if !val_ref.is_empty() {
                encoder.encode_varint32(18u32)?;
                encoder.encode_bytes(val_ref)?;
            }
        }
        {
            let val_ref = &self.r#aid;
            if *val_ref != 0 {
                encoder.encode_varint32(24u32)?;
                encoder.encode_varint32(*val_ref as _)?;
            }
        }
        {
            let val_ref = &self.r#is_mesh_child;
            if *val_ref {
                encoder.encode_varint32(32u32)?;
                encoder.encode_bool(*val_ref)?;
            }
        }
        Ok(())
    }
    fn compute_size(&self) -> usize {
        use ::micropb::{FieldEncode, PbMap};
        let mut size = 0;
        {
            let val_ref = &self.r#resp;
            if *val_ref != 0 {
                size += 1usize + ::micropb::size::sizeof_int32(*val_ref as _);
            }
        }
        {
            let val_ref = &self.r#mac;
            if !val_ref.is_empty() {
                size += 1usize + ::micropb::size::sizeof_len_record(val_ref.len());
            }
        }
        {
            let val_ref = &self.r#aid;
            if *val_ref != 0 {
                size += 1usize + ::micropb::size::sizeof_varint32(*val_ref as _);
            }
        }
        {
            let val_ref = &self.r#is_mesh_child;
            if *val_ref {
                size += 1usize + 1;
            }
        }
        size
    }
}
pub mod Rpc_Event_StaScanDone_ {
    #[derive(Debug, Default, PartialEq, Clone)]
    pub struct _Hazzer([u8; 1]);
    impl _Hazzer {
        ///New hazzer with all fields set to off
        #[inline]
        pub const fn _new() -> Self {
            Self([0; 1])
        }
        ///Query presence of `scan_done`
        #[inline]
        pub const fn r#scan_done(&self) -> bool {
            (self.0[0] & 1) != 0
        }
        ///Set presence of `scan_done`
        #[inline]
        pub const fn set_scan_done(&mut self) -> &mut Self {
            let elem = &mut self.0[0];
            *elem |= 1;
            self
        }
        ///Clear presence of `scan_done`
        #[inline]
        pub const fn clear_scan_done(&mut self) -> &mut Self {
            let elem = &mut self.0[0];
            *elem &= !1;
            self
        }
        ///Builder method that sets the presence of `scan_done`. Useful for initializing the Hazzer.
        #[inline]
        pub const fn init_scan_done(mut self) -> Self {
            self.set_scan_done();
            self
        }
    }
}
#[derive(Debug, Default, Clone)]
pub struct Rpc_Event_StaScanDone {
    pub r#resp: i32,
    pub r#scan_done: r#wifi_event_sta_scan_done,
    pub _has: Rpc_Event_StaScanDone_::_Hazzer,
}
impl ::core::cmp::PartialEq for Rpc_Event_StaScanDone {
    fn eq(&self, other: &Self) -> bool {
        let mut ret = true;
        ret &= (self.r#resp == other.r#resp);
        ret &= (self.r#scan_done() == other.r#scan_done());
        ret
    }
}
impl Rpc_Event_StaScanDone {
    ///Return a reference to `resp`
    #[inline]
    pub fn r#resp(&self) -> &i32 {
        &self.r#resp
    }
    ///Return a mutable reference to `resp`
    #[inline]
    pub fn mut_resp(&mut self) -> &mut i32 {
        &mut self.r#resp
    }
    ///Set the value of `resp`
    #[inline]
    pub fn set_resp(&mut self, value: i32) -> &mut Self {
        self.r#resp = value.into();
        self
    }
    ///Builder method that sets the value of `resp`. Useful for initializing the message.
    #[inline]
    pub fn init_resp(mut self, value: i32) -> Self {
        self.r#resp = value.into();
        self
    }
    ///Return a reference to `scan_done` as an `Option`
    #[inline]
    pub fn r#scan_done(&self) -> ::core::option::Option<&r#wifi_event_sta_scan_done> {
        self._has.r#scan_done().then_some(&self.r#scan_done)
    }
    ///Set the value and presence of `scan_done`
    #[inline]
    pub fn set_scan_done(&mut self, value: r#wifi_event_sta_scan_done) -> &mut Self {
        self._has.set_scan_done();
        self.r#scan_done = value.into();
        self
    }
    ///Return a mutable reference to `scan_done` as an `Option`
    #[inline]
    pub fn mut_scan_done(&mut self) -> ::core::option::Option<&mut r#wifi_event_sta_scan_done> {
        self._has.r#scan_done().then_some(&mut self.r#scan_done)
    }
    ///Clear the presence of `scan_done`
    #[inline]
    pub fn clear_scan_done(&mut self) -> &mut Self {
        self._has.clear_scan_done();
        self
    }
    ///Take the value of `scan_done` and clear its presence
    #[inline]
    pub fn take_scan_done(&mut self) -> ::core::option::Option<r#wifi_event_sta_scan_done> {
        let val = self
            ._has
            .r#scan_done()
            .then(|| ::core::mem::take(&mut self.r#scan_done));
        self._has.clear_scan_done();
        val
    }
    ///Builder method that sets the value of `scan_done`. Useful for initializing the message.
    #[inline]
    pub fn init_scan_done(mut self, value: r#wifi_event_sta_scan_done) -> Self {
        self.set_scan_done(value);
        self
    }
}
impl ::micropb::MessageDecode for Rpc_Event_StaScanDone {
    fn decode<IMPL_MICROPB_READ: ::micropb::PbRead>(
        &mut self,
        decoder: &mut ::micropb::PbDecoder<IMPL_MICROPB_READ>,
        len: usize,
    ) -> Result<(), ::micropb::DecodeError<IMPL_MICROPB_READ::Error>> {
        use ::micropb::{FieldDecode, PbBytes, PbMap, PbString, PbVec};
        let before = decoder.bytes_read();
        while decoder.bytes_read() - before < len {
            let tag = decoder.decode_tag()?;
            match tag.field_num() {
                0 => return Err(::micropb::DecodeError::ZeroField),
                1u32 => {
                    let mut_ref = &mut self.r#resp;
                    {
                        let val = decoder.decode_int32()?;
                        let val_ref = &val;
                        if *val_ref != 0 {
                            *mut_ref = val as _;
                        }
                    };
                }
                2u32 => {
                    let mut_ref = &mut self.r#scan_done;
                    {
                        mut_ref.decode_len_delimited(decoder)?;
                    };
                    self._has.set_scan_done();
                }
                _ => {
                    decoder.skip_wire_value(tag.wire_type())?;
                }
            }
        }
        Ok(())
    }
}
impl ::micropb::MessageEncode for Rpc_Event_StaScanDone {
    const MAX_SIZE: ::core::option::Option<usize> = 'msg: {
        let mut max_size = 0;
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(10usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        if let ::core::option::Option::Some(size) = ::micropb::const_map!(
            ::micropb::const_map!(
                <r#wifi_event_sta_scan_done as ::micropb::MessageEncode>::MAX_SIZE,
                |size| ::micropb::size::sizeof_len_record(size)
            ),
            |size| size + 1usize
        ) {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        ::core::option::Option::Some(max_size)
    };
    fn encode<IMPL_MICROPB_WRITE: ::micropb::PbWrite>(
        &self,
        encoder: &mut ::micropb::PbEncoder<IMPL_MICROPB_WRITE>,
    ) -> Result<(), IMPL_MICROPB_WRITE::Error> {
        use ::micropb::{FieldEncode, PbMap};
        {
            let val_ref = &self.r#resp;
            if *val_ref != 0 {
                encoder.encode_varint32(8u32)?;
                encoder.encode_int32(*val_ref as _)?;
            }
        }
        {
            if let ::core::option::Option::Some(val_ref) = self.r#scan_done() {
                encoder.encode_varint32(18u32)?;
                val_ref.encode_len_delimited(encoder)?;
            }
        }
        Ok(())
    }
    fn compute_size(&self) -> usize {
        use ::micropb::{FieldEncode, PbMap};
        let mut size = 0;
        {
            let val_ref = &self.r#resp;
            if *val_ref != 0 {
                size += 1usize + ::micropb::size::sizeof_int32(*val_ref as _);
            }
        }
        {
            if let ::core::option::Option::Some(val_ref) = self.r#scan_done() {
                size += 1usize + ::micropb::size::sizeof_len_record(val_ref.compute_size());
            }
        }
        size
    }
}
pub mod Rpc_Event_StaConnected_ {
    #[derive(Debug, Default, PartialEq, Clone)]
    pub struct _Hazzer([u8; 1]);
    impl _Hazzer {
        ///New hazzer with all fields set to off
        #[inline]
        pub const fn _new() -> Self {
            Self([0; 1])
        }
        ///Query presence of `sta_connected`
        #[inline]
        pub const fn r#sta_connected(&self) -> bool {
            (self.0[0] & 1) != 0
        }
        ///Set presence of `sta_connected`
        #[inline]
        pub const fn set_sta_connected(&mut self) -> &mut Self {
            let elem = &mut self.0[0];
            *elem |= 1;
            self
        }
        ///Clear presence of `sta_connected`
        #[inline]
        pub const fn clear_sta_connected(&mut self) -> &mut Self {
            let elem = &mut self.0[0];
            *elem &= !1;
            self
        }
        ///Builder method that sets the presence of `sta_connected`. Useful for initializing the Hazzer.
        #[inline]
        pub const fn init_sta_connected(mut self) -> Self {
            self.set_sta_connected();
            self
        }
    }
}
#[derive(Debug, Default, Clone)]
pub struct Rpc_Event_StaConnected {
    pub r#resp: i32,
    pub r#sta_connected: r#wifi_event_sta_connected,
    pub _has: Rpc_Event_StaConnected_::_Hazzer,
}
impl ::core::cmp::PartialEq for Rpc_Event_StaConnected {
    fn eq(&self, other: &Self) -> bool {
        let mut ret = true;
        ret &= (self.r#resp == other.r#resp);
        ret &= (self.r#sta_connected() == other.r#sta_connected());
        ret
    }
}
impl Rpc_Event_StaConnected {
    ///Return a reference to `resp`
    #[inline]
    pub fn r#resp(&self) -> &i32 {
        &self.r#resp
    }
    ///Return a mutable reference to `resp`
    #[inline]
    pub fn mut_resp(&mut self) -> &mut i32 {
        &mut self.r#resp
    }
    ///Set the value of `resp`
    #[inline]
    pub fn set_resp(&mut self, value: i32) -> &mut Self {
        self.r#resp = value.into();
        self
    }
    ///Builder method that sets the value of `resp`. Useful for initializing the message.
    #[inline]
    pub fn init_resp(mut self, value: i32) -> Self {
        self.r#resp = value.into();
        self
    }
    ///Return a reference to `sta_connected` as an `Option`
    #[inline]
    pub fn r#sta_connected(&self) -> ::core::option::Option<&r#wifi_event_sta_connected> {
        self._has.r#sta_connected().then_some(&self.r#sta_connected)
    }
    ///Set the value and presence of `sta_connected`
    #[inline]
    pub fn set_sta_connected(&mut self, value: r#wifi_event_sta_connected) -> &mut Self {
        self._has.set_sta_connected();
        self.r#sta_connected = value.into();
        self
    }
    ///Return a mutable reference to `sta_connected` as an `Option`
    #[inline]
    pub fn mut_sta_connected(&mut self) -> ::core::option::Option<&mut r#wifi_event_sta_connected> {
        self._has
            .r#sta_connected()
            .then_some(&mut self.r#sta_connected)
    }
    ///Clear the presence of `sta_connected`
    #[inline]
    pub fn clear_sta_connected(&mut self) -> &mut Self {
        self._has.clear_sta_connected();
        self
    }
    ///Take the value of `sta_connected` and clear its presence
    #[inline]
    pub fn take_sta_connected(&mut self) -> ::core::option::Option<r#wifi_event_sta_connected> {
        let val = self
            ._has
            .r#sta_connected()
            .then(|| ::core::mem::take(&mut self.r#sta_connected));
        self._has.clear_sta_connected();
        val
    }
    ///Builder method that sets the value of `sta_connected`. Useful for initializing the message.
    #[inline]
    pub fn init_sta_connected(mut self, value: r#wifi_event_sta_connected) -> Self {
        self.set_sta_connected(value);
        self
    }
}
impl ::micropb::MessageDecode for Rpc_Event_StaConnected {
    fn decode<IMPL_MICROPB_READ: ::micropb::PbRead>(
        &mut self,
        decoder: &mut ::micropb::PbDecoder<IMPL_MICROPB_READ>,
        len: usize,
    ) -> Result<(), ::micropb::DecodeError<IMPL_MICROPB_READ::Error>> {
        use ::micropb::{FieldDecode, PbBytes, PbMap, PbString, PbVec};
        let before = decoder.bytes_read();
        while decoder.bytes_read() - before < len {
            let tag = decoder.decode_tag()?;
            match tag.field_num() {
                0 => return Err(::micropb::DecodeError::ZeroField),
                1u32 => {
                    let mut_ref = &mut self.r#resp;
                    {
                        let val = decoder.decode_int32()?;
                        let val_ref = &val;
                        if *val_ref != 0 {
                            *mut_ref = val as _;
                        }
                    };
                }
                2u32 => {
                    let mut_ref = &mut self.r#sta_connected;
                    {
                        mut_ref.decode_len_delimited(decoder)?;
                    };
                    self._has.set_sta_connected();
                }
                _ => {
                    decoder.skip_wire_value(tag.wire_type())?;
                }
            }
        }
        Ok(())
    }
}
impl ::micropb::MessageEncode for Rpc_Event_StaConnected {
    const MAX_SIZE: ::core::option::Option<usize> = 'msg: {
        let mut max_size = 0;
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(10usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        if let ::core::option::Option::Some(size) = ::micropb::const_map!(
            ::micropb::const_map!(
                <r#wifi_event_sta_connected as ::micropb::MessageEncode>::MAX_SIZE,
                |size| ::micropb::size::sizeof_len_record(size)
            ),
            |size| size + 1usize
        ) {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        ::core::option::Option::Some(max_size)
    };
    fn encode<IMPL_MICROPB_WRITE: ::micropb::PbWrite>(
        &self,
        encoder: &mut ::micropb::PbEncoder<IMPL_MICROPB_WRITE>,
    ) -> Result<(), IMPL_MICROPB_WRITE::Error> {
        use ::micropb::{FieldEncode, PbMap};
        {
            let val_ref = &self.r#resp;
            if *val_ref != 0 {
                encoder.encode_varint32(8u32)?;
                encoder.encode_int32(*val_ref as _)?;
            }
        }
        {
            if let ::core::option::Option::Some(val_ref) = self.r#sta_connected() {
                encoder.encode_varint32(18u32)?;
                val_ref.encode_len_delimited(encoder)?;
            }
        }
        Ok(())
    }
    fn compute_size(&self) -> usize {
        use ::micropb::{FieldEncode, PbMap};
        let mut size = 0;
        {
            let val_ref = &self.r#resp;
            if *val_ref != 0 {
                size += 1usize + ::micropb::size::sizeof_int32(*val_ref as _);
            }
        }
        {
            if let ::core::option::Option::Some(val_ref) = self.r#sta_connected() {
                size += 1usize + ::micropb::size::sizeof_len_record(val_ref.compute_size());
            }
        }
        size
    }
}
pub mod Rpc_Event_StaDisconnected_ {
    #[derive(Debug, Default, PartialEq, Clone)]
    pub struct _Hazzer([u8; 1]);
    impl _Hazzer {
        ///New hazzer with all fields set to off
        #[inline]
        pub const fn _new() -> Self {
            Self([0; 1])
        }
        ///Query presence of `sta_disconnected`
        #[inline]
        pub const fn r#sta_disconnected(&self) -> bool {
            (self.0[0] & 1) != 0
        }
        ///Set presence of `sta_disconnected`
        #[inline]
        pub const fn set_sta_disconnected(&mut self) -> &mut Self {
            let elem = &mut self.0[0];
            *elem |= 1;
            self
        }
        ///Clear presence of `sta_disconnected`
        #[inline]
        pub const fn clear_sta_disconnected(&mut self) -> &mut Self {
            let elem = &mut self.0[0];
            *elem &= !1;
            self
        }
        ///Builder method that sets the presence of `sta_disconnected`. Useful for initializing the Hazzer.
        #[inline]
        pub const fn init_sta_disconnected(mut self) -> Self {
            self.set_sta_disconnected();
            self
        }
    }
}
#[derive(Debug, Default, Clone)]
pub struct Rpc_Event_StaDisconnected {
    pub r#resp: i32,
    pub r#sta_disconnected: r#wifi_event_sta_disconnected,
    pub _has: Rpc_Event_StaDisconnected_::_Hazzer,
}
impl ::core::cmp::PartialEq for Rpc_Event_StaDisconnected {
    fn eq(&self, other: &Self) -> bool {
        let mut ret = true;
        ret &= (self.r#resp == other.r#resp);
        ret &= (self.r#sta_disconnected() == other.r#sta_disconnected());
        ret
    }
}
impl Rpc_Event_StaDisconnected {
    ///Return a reference to `resp`
    #[inline]
    pub fn r#resp(&self) -> &i32 {
        &self.r#resp
    }
    ///Return a mutable reference to `resp`
    #[inline]
    pub fn mut_resp(&mut self) -> &mut i32 {
        &mut self.r#resp
    }
    ///Set the value of `resp`
    #[inline]
    pub fn set_resp(&mut self, value: i32) -> &mut Self {
        self.r#resp = value.into();
        self
    }
    ///Builder method that sets the value of `resp`. Useful for initializing the message.
    #[inline]
    pub fn init_resp(mut self, value: i32) -> Self {
        self.r#resp = value.into();
        self
    }
    ///Return a reference to `sta_disconnected` as an `Option`
    #[inline]
    pub fn r#sta_disconnected(&self) -> ::core::option::Option<&r#wifi_event_sta_disconnected> {
        self._has
            .r#sta_disconnected()
            .then_some(&self.r#sta_disconnected)
    }
    ///Set the value and presence of `sta_disconnected`
    #[inline]
    pub fn set_sta_disconnected(&mut self, value: r#wifi_event_sta_disconnected) -> &mut Self {
        self._has.set_sta_disconnected();
        self.r#sta_disconnected = value.into();
        self
    }
    ///Return a mutable reference to `sta_disconnected` as an `Option`
    #[inline]
    pub fn mut_sta_disconnected(
        &mut self,
    ) -> ::core::option::Option<&mut r#wifi_event_sta_disconnected> {
        self._has
            .r#sta_disconnected()
            .then_some(&mut self.r#sta_disconnected)
    }
    ///Clear the presence of `sta_disconnected`
    #[inline]
    pub fn clear_sta_disconnected(&mut self) -> &mut Self {
        self._has.clear_sta_disconnected();
        self
    }
    ///Take the value of `sta_disconnected` and clear its presence
    #[inline]
    pub fn take_sta_disconnected(
        &mut self,
    ) -> ::core::option::Option<r#wifi_event_sta_disconnected> {
        let val = self
            ._has
            .r#sta_disconnected()
            .then(|| ::core::mem::take(&mut self.r#sta_disconnected));
        self._has.clear_sta_disconnected();
        val
    }
    ///Builder method that sets the value of `sta_disconnected`. Useful for initializing the message.
    #[inline]
    pub fn init_sta_disconnected(mut self, value: r#wifi_event_sta_disconnected) -> Self {
        self.set_sta_disconnected(value);
        self
    }
}
impl ::micropb::MessageDecode for Rpc_Event_StaDisconnected {
    fn decode<IMPL_MICROPB_READ: ::micropb::PbRead>(
        &mut self,
        decoder: &mut ::micropb::PbDecoder<IMPL_MICROPB_READ>,
        len: usize,
    ) -> Result<(), ::micropb::DecodeError<IMPL_MICROPB_READ::Error>> {
        use ::micropb::{FieldDecode, PbBytes, PbMap, PbString, PbVec};
        let before = decoder.bytes_read();
        while decoder.bytes_read() - before < len {
            let tag = decoder.decode_tag()?;
            match tag.field_num() {
                0 => return Err(::micropb::DecodeError::ZeroField),
                1u32 => {
                    let mut_ref = &mut self.r#resp;
                    {
                        let val = decoder.decode_int32()?;
                        let val_ref = &val;
                        if *val_ref != 0 {
                            *mut_ref = val as _;
                        }
                    };
                }
                2u32 => {
                    let mut_ref = &mut self.r#sta_disconnected;
                    {
                        mut_ref.decode_len_delimited(decoder)?;
                    };
                    self._has.set_sta_disconnected();
                }
                _ => {
                    decoder.skip_wire_value(tag.wire_type())?;
                }
            }
        }
        Ok(())
    }
}
impl ::micropb::MessageEncode for Rpc_Event_StaDisconnected {
    const MAX_SIZE: ::core::option::Option<usize> = 'msg: {
        let mut max_size = 0;
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(10usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        if let ::core::option::Option::Some(size) = ::micropb::const_map!(
            ::micropb::const_map!(
                <r#wifi_event_sta_disconnected as ::micropb::MessageEncode>::MAX_SIZE,
                |size| ::micropb::size::sizeof_len_record(size)
            ),
            |size| size + 1usize
        ) {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        ::core::option::Option::Some(max_size)
    };
    fn encode<IMPL_MICROPB_WRITE: ::micropb::PbWrite>(
        &self,
        encoder: &mut ::micropb::PbEncoder<IMPL_MICROPB_WRITE>,
    ) -> Result<(), IMPL_MICROPB_WRITE::Error> {
        use ::micropb::{FieldEncode, PbMap};
        {
            let val_ref = &self.r#resp;
            if *val_ref != 0 {
                encoder.encode_varint32(8u32)?;
                encoder.encode_int32(*val_ref as _)?;
            }
        }
        {
            if let ::core::option::Option::Some(val_ref) = self.r#sta_disconnected() {
                encoder.encode_varint32(18u32)?;
                val_ref.encode_len_delimited(encoder)?;
            }
        }
        Ok(())
    }
    fn compute_size(&self) -> usize {
        use ::micropb::{FieldEncode, PbMap};
        let mut size = 0;
        {
            let val_ref = &self.r#resp;
            if *val_ref != 0 {
                size += 1usize + ::micropb::size::sizeof_int32(*val_ref as _);
            }
        }
        {
            if let ::core::option::Option::Some(val_ref) = self.r#sta_disconnected() {
                size += 1usize + ::micropb::size::sizeof_len_record(val_ref.compute_size());
            }
        }
        size
    }
}
pub mod Rpc_ {
    #[derive(Debug, PartialEq, Clone)]
    pub enum Payload {
        ReqGetMacAddress(super::Rpc_Req_GetMacAddress),
        ReqSetMacAddress(super::Rpc_Req_SetMacAddress),
        ReqGetWifiMode(super::Rpc_Req_GetMode),
        ReqSetWifiMode(super::Rpc_Req_SetMode),
        ReqWifiSetPs(super::Rpc_Req_SetPs),
        ReqWifiGetPs(super::Rpc_Req_GetPs),
        ReqOtaBegin(super::Rpc_Req_OTABegin),
        ReqOtaWrite(super::Rpc_Req_OTAWrite),
        ReqOtaEnd(super::Rpc_Req_OTAEnd),
        ReqSetWifiMaxTxPower(super::Rpc_Req_WifiSetMaxTxPower),
        ReqGetWifiMaxTxPower(super::Rpc_Req_WifiGetMaxTxPower),
        ReqConfigHeartbeat(super::Rpc_Req_ConfigHeartbeat),
        ReqWifiInit(super::Rpc_Req_WifiInit),
        ReqWifiDeinit(super::Rpc_Req_WifiDeinit),
        ReqWifiStart(super::Rpc_Req_WifiStart),
        ReqWifiStop(super::Rpc_Req_WifiStop),
        ReqWifiConnect(super::Rpc_Req_WifiConnect),
        ReqWifiDisconnect(super::Rpc_Req_WifiDisconnect),
        ReqWifiSetConfig(super::Rpc_Req_WifiSetConfig),
        ReqWifiGetConfig(super::Rpc_Req_WifiGetConfig),
        ReqWifiScanStart(super::Rpc_Req_WifiScanStart),
        ReqWifiScanStop(super::Rpc_Req_WifiScanStop),
        ReqWifiScanGetApNum(super::Rpc_Req_WifiScanGetApNum),
        ReqWifiScanGetApRecords(super::Rpc_Req_WifiScanGetApRecords),
        ReqWifiClearApList(super::Rpc_Req_WifiClearApList),
        ReqWifiRestore(super::Rpc_Req_WifiRestore),
        ReqWifiClearFastConnect(super::Rpc_Req_WifiClearFastConnect),
        ReqWifiDeauthSta(super::Rpc_Req_WifiDeauthSta),
        ReqWifiStaGetApInfo(super::Rpc_Req_WifiStaGetApInfo),
        ReqWifiSetProtocol(super::Rpc_Req_WifiSetProtocol),
        ReqWifiGetProtocol(super::Rpc_Req_WifiGetProtocol),
        ReqWifiSetBandwidth(super::Rpc_Req_WifiSetBandwidth),
        ReqWifiGetBandwidth(super::Rpc_Req_WifiGetBandwidth),
        ReqWifiSetChannel(super::Rpc_Req_WifiSetChannel),
        ReqWifiGetChannel(super::Rpc_Req_WifiGetChannel),
        ReqWifiSetCountry(super::Rpc_Req_WifiSetCountry),
        ReqWifiGetCountry(super::Rpc_Req_WifiGetCountry),
        ReqWifiApGetStaList(super::Rpc_Req_WifiApGetStaList),
        ReqWifiApGetStaAid(super::Rpc_Req_WifiApGetStaAid),
        ReqWifiSetStorage(super::Rpc_Req_WifiSetStorage),
        ReqWifiSetCountryCode(super::Rpc_Req_WifiSetCountryCode),
        ReqWifiGetCountryCode(super::Rpc_Req_WifiGetCountryCode),
        ReqWifiStaGetAid(super::Rpc_Req_WifiStaGetAid),
        ReqWifiStaGetNegotiatedPhymode(super::Rpc_Req_WifiStaGetNegotiatedPhymode),
        ReqWifiStaGetRssi(super::Rpc_Req_WifiStaGetRssi),
        ReqWifiSetProtocols(super::Rpc_Req_WifiSetProtocols),
        ReqWifiGetProtocols(super::Rpc_Req_WifiGetProtocols),
        ReqWifiSetBandwidths(super::Rpc_Req_WifiSetBandwidths),
        ReqWifiGetBandwidths(super::Rpc_Req_WifiGetBandwidths),
        ReqWifiSetBand(super::Rpc_Req_WifiSetBand),
        ReqWifiGetBand(super::Rpc_Req_WifiGetBand),
        ReqWifiSetBandmode(super::Rpc_Req_WifiSetBandMode),
        ReqWifiGetBandmode(super::Rpc_Req_WifiGetBandMode),
        ReqGetCoprocessorFwversion(super::Rpc_Req_GetCoprocessorFwVersion),
        ReqWifiScanGetApRecord(super::Rpc_Req_WifiScanGetApRecord),
        RespGetMacAddress(super::Rpc_Resp_GetMacAddress),
        RespSetMacAddress(super::Rpc_Resp_SetMacAddress),
        RespGetWifiMode(super::Rpc_Resp_GetMode),
        RespSetWifiMode(super::Rpc_Resp_SetMode),
        RespWifiSetPs(super::Rpc_Resp_SetPs),
        RespWifiGetPs(super::Rpc_Resp_GetPs),
        RespOtaBegin(super::Rpc_Resp_OTABegin),
        RespOtaWrite(super::Rpc_Resp_OTAWrite),
        RespOtaEnd(super::Rpc_Resp_OTAEnd),
        RespSetWifiMaxTxPower(super::Rpc_Resp_WifiSetMaxTxPower),
        RespGetWifiMaxTxPower(super::Rpc_Resp_WifiGetMaxTxPower),
        RespConfigHeartbeat(super::Rpc_Resp_ConfigHeartbeat),
        RespWifiInit(super::Rpc_Resp_WifiInit),
        RespWifiDeinit(super::Rpc_Resp_WifiDeinit),
        RespWifiStart(super::Rpc_Resp_WifiStart),
        RespWifiStop(super::Rpc_Resp_WifiStop),
        RespWifiConnect(super::Rpc_Resp_WifiConnect),
        RespWifiDisconnect(super::Rpc_Resp_WifiDisconnect),
        RespWifiSetConfig(super::Rpc_Resp_WifiSetConfig),
        RespWifiGetConfig(super::Rpc_Resp_WifiGetConfig),
        RespWifiScanStart(super::Rpc_Resp_WifiScanStart),
        RespWifiScanStop(super::Rpc_Resp_WifiScanStop),
        RespWifiScanGetApNum(super::Rpc_Resp_WifiScanGetApNum),
        RespWifiScanGetApRecords(super::Rpc_Resp_WifiScanGetApRecords),
        RespWifiClearApList(super::Rpc_Resp_WifiClearApList),
        RespWifiRestore(super::Rpc_Resp_WifiRestore),
        RespWifiClearFastConnect(super::Rpc_Resp_WifiClearFastConnect),
        RespWifiDeauthSta(super::Rpc_Resp_WifiDeauthSta),
        RespWifiStaGetApInfo(super::Rpc_Resp_WifiStaGetApInfo),
        RespWifiSetProtocol(super::Rpc_Resp_WifiSetProtocol),
        RespWifiGetProtocol(super::Rpc_Resp_WifiGetProtocol),
        RespWifiSetBandwidth(super::Rpc_Resp_WifiSetBandwidth),
        RespWifiGetBandwidth(super::Rpc_Resp_WifiGetBandwidth),
        RespWifiSetChannel(super::Rpc_Resp_WifiSetChannel),
        RespWifiGetChannel(super::Rpc_Resp_WifiGetChannel),
        RespWifiSetCountry(super::Rpc_Resp_WifiSetCountry),
        RespWifiGetCountry(super::Rpc_Resp_WifiGetCountry),
        RespWifiApGetStaList(super::Rpc_Resp_WifiApGetStaList),
        RespWifiApGetStaAid(super::Rpc_Resp_WifiApGetStaAid),
        RespWifiSetStorage(super::Rpc_Resp_WifiSetStorage),
        RespWifiSetCountryCode(super::Rpc_Resp_WifiSetCountryCode),
        RespWifiGetCountryCode(super::Rpc_Resp_WifiGetCountryCode),
        RespWifiStaGetAid(super::Rpc_Resp_WifiStaGetAid),
        RespWifiStaGetNegotiatedPhymode(super::Rpc_Resp_WifiStaGetNegotiatedPhymode),
        RespWifiStaGetRssi(super::Rpc_Resp_WifiStaGetRssi),
        RespWifiSetProtocols(super::Rpc_Resp_WifiSetProtocols),
        RespWifiGetProtocols(super::Rpc_Resp_WifiGetProtocols),
        RespWifiSetBandwidths(super::Rpc_Resp_WifiSetBandwidths),
        RespWifiGetBandwidths(super::Rpc_Resp_WifiGetBandwidths),
        RespWifiSetBand(super::Rpc_Resp_WifiSetBand),
        RespWifiGetBand(super::Rpc_Resp_WifiGetBand),
        RespWifiSetBandmode(super::Rpc_Resp_WifiSetBandMode),
        RespWifiGetBandmode(super::Rpc_Resp_WifiGetBandMode),
        RespGetCoprocessorFwversion(super::Rpc_Resp_GetCoprocessorFwVersion),
        RespWifiScanGetApRecord(super::Rpc_Resp_WifiScanGetApRecord),
        EventEspInit(super::Rpc_Event_ESPInit),
        EventHeartbeat(super::Rpc_Event_Heartbeat),
        EventApStaConnected(super::Rpc_Event_AP_StaConnected),
        EventApStaDisconnected(super::Rpc_Event_AP_StaDisconnected),
        EventWifiEventNoArgs(super::Rpc_Event_WifiEventNoArgs),
        EventStaScanDone(super::Rpc_Event_StaScanDone),
        EventStaConnected(super::Rpc_Event_StaConnected),
        EventStaDisconnected(super::Rpc_Event_StaDisconnected),
    }
}
#[derive(Debug, Default, PartialEq, Clone)]
pub struct Rpc {
    pub r#msg_type: RpcType,
    pub r#msg_id: RpcId,
    pub r#uid: u32,
    pub r#payload: ::core::option::Option<Rpc_::Payload>,
}
impl Rpc {
    ///Return a reference to `msg_type`
    #[inline]
    pub fn r#msg_type(&self) -> &RpcType {
        &self.r#msg_type
    }
    ///Return a mutable reference to `msg_type`
    #[inline]
    pub fn mut_msg_type(&mut self) -> &mut RpcType {
        &mut self.r#msg_type
    }
    ///Set the value of `msg_type`
    #[inline]
    pub fn set_msg_type(&mut self, value: RpcType) -> &mut Self {
        self.r#msg_type = value.into();
        self
    }
    ///Builder method that sets the value of `msg_type`. Useful for initializing the message.
    #[inline]
    pub fn init_msg_type(mut self, value: RpcType) -> Self {
        self.r#msg_type = value.into();
        self
    }
    ///Return a reference to `msg_id`
    #[inline]
    pub fn r#msg_id(&self) -> &RpcId {
        &self.r#msg_id
    }
    ///Return a mutable reference to `msg_id`
    #[inline]
    pub fn mut_msg_id(&mut self) -> &mut RpcId {
        &mut self.r#msg_id
    }
    ///Set the value of `msg_id`
    #[inline]
    pub fn set_msg_id(&mut self, value: RpcId) -> &mut Self {
        self.r#msg_id = value.into();
        self
    }
    ///Builder method that sets the value of `msg_id`. Useful for initializing the message.
    #[inline]
    pub fn init_msg_id(mut self, value: RpcId) -> Self {
        self.r#msg_id = value.into();
        self
    }
    ///Return a reference to `uid`
    #[inline]
    pub fn r#uid(&self) -> &u32 {
        &self.r#uid
    }
    ///Return a mutable reference to `uid`
    #[inline]
    pub fn mut_uid(&mut self) -> &mut u32 {
        &mut self.r#uid
    }
    ///Set the value of `uid`
    #[inline]
    pub fn set_uid(&mut self, value: u32) -> &mut Self {
        self.r#uid = value.into();
        self
    }
    ///Builder method that sets the value of `uid`. Useful for initializing the message.
    #[inline]
    pub fn init_uid(mut self, value: u32) -> Self {
        self.r#uid = value.into();
        self
    }
}
impl ::micropb::MessageDecode for Rpc {
    fn decode<IMPL_MICROPB_READ: ::micropb::PbRead>(
        &mut self,
        decoder: &mut ::micropb::PbDecoder<IMPL_MICROPB_READ>,
        len: usize,
    ) -> Result<(), ::micropb::DecodeError<IMPL_MICROPB_READ::Error>> {
        use ::micropb::{FieldDecode, PbBytes, PbMap, PbString, PbVec};
        let before = decoder.bytes_read();
        while decoder.bytes_read() - before < len {
            let tag = decoder.decode_tag()?;
            match tag.field_num() {
                0 => return Err(::micropb::DecodeError::ZeroField),
                1u32 => {
                    let mut_ref = &mut self.r#msg_type;
                    {
                        let val = decoder.decode_int32().map(|n| RpcType(n as _))?;
                        let val_ref = &val;
                        if val_ref.0 != 0 {
                            *mut_ref = val as _;
                        }
                    };
                }
                2u32 => {
                    let mut_ref = &mut self.r#msg_id;
                    {
                        let val = decoder.decode_int32().map(|n| RpcId(n as _))?;
                        let val_ref = &val;
                        if val_ref.0 != 0 {
                            *mut_ref = val as _;
                        }
                    };
                }
                3u32 => {
                    let mut_ref = &mut self.r#uid;
                    {
                        let val = decoder.decode_varint32()?;
                        let val_ref = &val;
                        if *val_ref != 0 {
                            *mut_ref = val as _;
                        }
                    };
                }
                257u32 => {
                    let mut_ref = loop {
                        if let ::core::option::Option::Some(variant) = &mut self.r#payload {
                            if let Rpc_::Payload::ReqGetMacAddress(variant) = &mut *variant {
                                break &mut *variant;
                            }
                        }
                        self.r#payload = ::core::option::Option::Some(
                            Rpc_::Payload::ReqGetMacAddress(::core::default::Default::default()),
                        );
                    };
                    mut_ref.decode_len_delimited(decoder)?;
                }
                258u32 => {
                    let mut_ref = loop {
                        if let ::core::option::Option::Some(variant) = &mut self.r#payload {
                            if let Rpc_::Payload::ReqSetMacAddress(variant) = &mut *variant {
                                break &mut *variant;
                            }
                        }
                        self.r#payload = ::core::option::Option::Some(
                            Rpc_::Payload::ReqSetMacAddress(::core::default::Default::default()),
                        );
                    };
                    mut_ref.decode_len_delimited(decoder)?;
                }
                259u32 => {
                    let mut_ref = loop {
                        if let ::core::option::Option::Some(variant) = &mut self.r#payload {
                            if let Rpc_::Payload::ReqGetWifiMode(variant) = &mut *variant {
                                break &mut *variant;
                            }
                        }
                        self.r#payload = ::core::option::Option::Some(
                            Rpc_::Payload::ReqGetWifiMode(::core::default::Default::default()),
                        );
                    };
                    mut_ref.decode_len_delimited(decoder)?;
                }
                260u32 => {
                    let mut_ref = loop {
                        if let ::core::option::Option::Some(variant) = &mut self.r#payload {
                            if let Rpc_::Payload::ReqSetWifiMode(variant) = &mut *variant {
                                break &mut *variant;
                            }
                        }
                        self.r#payload = ::core::option::Option::Some(
                            Rpc_::Payload::ReqSetWifiMode(::core::default::Default::default()),
                        );
                    };
                    mut_ref.decode_len_delimited(decoder)?;
                }
                270u32 => {
                    let mut_ref = loop {
                        if let ::core::option::Option::Some(variant) = &mut self.r#payload {
                            if let Rpc_::Payload::ReqWifiSetPs(variant) = &mut *variant {
                                break &mut *variant;
                            }
                        }
                        self.r#payload = ::core::option::Option::Some(Rpc_::Payload::ReqWifiSetPs(
                            ::core::default::Default::default(),
                        ));
                    };
                    mut_ref.decode_len_delimited(decoder)?;
                }
                271u32 => {
                    let mut_ref = loop {
                        if let ::core::option::Option::Some(variant) = &mut self.r#payload {
                            if let Rpc_::Payload::ReqWifiGetPs(variant) = &mut *variant {
                                break &mut *variant;
                            }
                        }
                        self.r#payload = ::core::option::Option::Some(Rpc_::Payload::ReqWifiGetPs(
                            ::core::default::Default::default(),
                        ));
                    };
                    mut_ref.decode_len_delimited(decoder)?;
                }
                272u32 => {
                    let mut_ref = loop {
                        if let ::core::option::Option::Some(variant) = &mut self.r#payload {
                            if let Rpc_::Payload::ReqOtaBegin(variant) = &mut *variant {
                                break &mut *variant;
                            }
                        }
                        self.r#payload = ::core::option::Option::Some(Rpc_::Payload::ReqOtaBegin(
                            ::core::default::Default::default(),
                        ));
                    };
                    mut_ref.decode_len_delimited(decoder)?;
                }
                273u32 => {
                    let mut_ref = loop {
                        if let ::core::option::Option::Some(variant) = &mut self.r#payload {
                            if let Rpc_::Payload::ReqOtaWrite(variant) = &mut *variant {
                                break &mut *variant;
                            }
                        }
                        self.r#payload = ::core::option::Option::Some(Rpc_::Payload::ReqOtaWrite(
                            ::core::default::Default::default(),
                        ));
                    };
                    mut_ref.decode_len_delimited(decoder)?;
                }
                274u32 => {
                    let mut_ref = loop {
                        if let ::core::option::Option::Some(variant) = &mut self.r#payload {
                            if let Rpc_::Payload::ReqOtaEnd(variant) = &mut *variant {
                                break &mut *variant;
                            }
                        }
                        self.r#payload = ::core::option::Option::Some(Rpc_::Payload::ReqOtaEnd(
                            ::core::default::Default::default(),
                        ));
                    };
                    mut_ref.decode_len_delimited(decoder)?;
                }
                275u32 => {
                    let mut_ref = loop {
                        if let ::core::option::Option::Some(variant) = &mut self.r#payload {
                            if let Rpc_::Payload::ReqSetWifiMaxTxPower(variant) = &mut *variant {
                                break &mut *variant;
                            }
                        }
                        self.r#payload = ::core::option::Option::Some(
                            Rpc_::Payload::ReqSetWifiMaxTxPower(::core::default::Default::default()),
                        );
                    };
                    mut_ref.decode_len_delimited(decoder)?;
                }
                276u32 => {
                    let mut_ref = loop {
                        if let ::core::option::Option::Some(variant) = &mut self.r#payload {
                            if let Rpc_::Payload::ReqGetWifiMaxTxPower(variant) = &mut *variant {
                                break &mut *variant;
                            }
                        }
                        self.r#payload = ::core::option::Option::Some(
                            Rpc_::Payload::ReqGetWifiMaxTxPower(::core::default::Default::default()),
                        );
                    };
                    mut_ref.decode_len_delimited(decoder)?;
                }
                277u32 => {
                    let mut_ref = loop {
                        if let ::core::option::Option::Some(variant) = &mut self.r#payload {
                            if let Rpc_::Payload::ReqConfigHeartbeat(variant) = &mut *variant {
                                break &mut *variant;
                            }
                        }
                        self.r#payload = ::core::option::Option::Some(
                            Rpc_::Payload::ReqConfigHeartbeat(::core::default::Default::default()),
                        );
                    };
                    mut_ref.decode_len_delimited(decoder)?;
                }
                278u32 => {
                    let mut_ref = loop {
                        if let ::core::option::Option::Some(variant) = &mut self.r#payload {
                            if let Rpc_::Payload::ReqWifiInit(variant) = &mut *variant {
                                break &mut *variant;
                            }
                        }
                        self.r#payload = ::core::option::Option::Some(Rpc_::Payload::ReqWifiInit(
                            ::core::default::Default::default(),
                        ));
                    };
                    mut_ref.decode_len_delimited(decoder)?;
                }
                279u32 => {
                    let mut_ref = loop {
                        if let ::core::option::Option::Some(variant) = &mut self.r#payload {
                            if let Rpc_::Payload::ReqWifiDeinit(variant) = &mut *variant {
                                break &mut *variant;
                            }
                        }
                        self.r#payload = ::core::option::Option::Some(
                            Rpc_::Payload::ReqWifiDeinit(::core::default::Default::default()),
                        );
                    };
                    mut_ref.decode_len_delimited(decoder)?;
                }
                280u32 => {
                    let mut_ref = loop {
                        if let ::core::option::Option::Some(variant) = &mut self.r#payload {
                            if let Rpc_::Payload::ReqWifiStart(variant) = &mut *variant {
                                break &mut *variant;
                            }
                        }
                        self.r#payload = ::core::option::Option::Some(Rpc_::Payload::ReqWifiStart(
                            ::core::default::Default::default(),
                        ));
                    };
                    mut_ref.decode_len_delimited(decoder)?;
                }
                281u32 => {
                    let mut_ref = loop {
                        if let ::core::option::Option::Some(variant) = &mut self.r#payload {
                            if let Rpc_::Payload::ReqWifiStop(variant) = &mut *variant {
                                break &mut *variant;
                            }
                        }
                        self.r#payload = ::core::option::Option::Some(Rpc_::Payload::ReqWifiStop(
                            ::core::default::Default::default(),
                        ));
                    };
                    mut_ref.decode_len_delimited(decoder)?;
                }
                282u32 => {
                    let mut_ref = loop {
                        if let ::core::option::Option::Some(variant) = &mut self.r#payload {
                            if let Rpc_::Payload::ReqWifiConnect(variant) = &mut *variant {
                                break &mut *variant;
                            }
                        }
                        self.r#payload = ::core::option::Option::Some(
                            Rpc_::Payload::ReqWifiConnect(::core::default::Default::default()),
                        );
                    };
                    mut_ref.decode_len_delimited(decoder)?;
                }
                283u32 => {
                    let mut_ref = loop {
                        if let ::core::option::Option::Some(variant) = &mut self.r#payload {
                            if let Rpc_::Payload::ReqWifiDisconnect(variant) = &mut *variant {
                                break &mut *variant;
                            }
                        }
                        self.r#payload = ::core::option::Option::Some(
                            Rpc_::Payload::ReqWifiDisconnect(::core::default::Default::default()),
                        );
                    };
                    mut_ref.decode_len_delimited(decoder)?;
                }
                284u32 => {
                    let mut_ref = loop {
                        if let ::core::option::Option::Some(variant) = &mut self.r#payload {
                            if let Rpc_::Payload::ReqWifiSetConfig(variant) = &mut *variant {
                                break &mut *variant;
                            }
                        }
                        self.r#payload = ::core::option::Option::Some(
                            Rpc_::Payload::ReqWifiSetConfig(::core::default::Default::default()),
                        );
                    };
                    mut_ref.decode_len_delimited(decoder)?;
                }
                285u32 => {
                    let mut_ref = loop {
                        if let ::core::option::Option::Some(variant) = &mut self.r#payload {
                            if let Rpc_::Payload::ReqWifiGetConfig(variant) = &mut *variant {
                                break &mut *variant;
                            }
                        }
                        self.r#payload = ::core::option::Option::Some(
                            Rpc_::Payload::ReqWifiGetConfig(::core::default::Default::default()),
                        );
                    };
                    mut_ref.decode_len_delimited(decoder)?;
                }
                286u32 => {
                    let mut_ref = loop {
                        if let ::core::option::Option::Some(variant) = &mut self.r#payload {
                            if let Rpc_::Payload::ReqWifiScanStart(variant) = &mut *variant {
                                break &mut *variant;
                            }
                        }
                        self.r#payload = ::core::option::Option::Some(
                            Rpc_::Payload::ReqWifiScanStart(::core::default::Default::default()),
                        );
                    };
                    mut_ref.decode_len_delimited(decoder)?;
                }
                287u32 => {
                    let mut_ref = loop {
                        if let ::core::option::Option::Some(variant) = &mut self.r#payload {
                            if let Rpc_::Payload::ReqWifiScanStop(variant) = &mut *variant {
                                break &mut *variant;
                            }
                        }
                        self.r#payload = ::core::option::Option::Some(
                            Rpc_::Payload::ReqWifiScanStop(::core::default::Default::default()),
                        );
                    };
                    mut_ref.decode_len_delimited(decoder)?;
                }
                288u32 => {
                    let mut_ref = loop {
                        if let ::core::option::Option::Some(variant) = &mut self.r#payload {
                            if let Rpc_::Payload::ReqWifiScanGetApNum(variant) = &mut *variant {
                                break &mut *variant;
                            }
                        }
                        self.r#payload = ::core::option::Option::Some(
                            Rpc_::Payload::ReqWifiScanGetApNum(::core::default::Default::default()),
                        );
                    };
                    mut_ref.decode_len_delimited(decoder)?;
                }
                289u32 => {
                    let mut_ref = loop {
                        if let ::core::option::Option::Some(variant) = &mut self.r#payload {
                            if let Rpc_::Payload::ReqWifiScanGetApRecords(variant) = &mut *variant {
                                break &mut *variant;
                            }
                        }
                        self.r#payload =
                            ::core::option::Option::Some(Rpc_::Payload::ReqWifiScanGetApRecords(
                                ::core::default::Default::default(),
                            ));
                    };
                    mut_ref.decode_len_delimited(decoder)?;
                }
                290u32 => {
                    let mut_ref = loop {
                        if let ::core::option::Option::Some(variant) = &mut self.r#payload {
                            if let Rpc_::Payload::ReqWifiClearApList(variant) = &mut *variant {
                                break &mut *variant;
                            }
                        }
                        self.r#payload = ::core::option::Option::Some(
                            Rpc_::Payload::ReqWifiClearApList(::core::default::Default::default()),
                        );
                    };
                    mut_ref.decode_len_delimited(decoder)?;
                }
                291u32 => {
                    let mut_ref = loop {
                        if let ::core::option::Option::Some(variant) = &mut self.r#payload {
                            if let Rpc_::Payload::ReqWifiRestore(variant) = &mut *variant {
                                break &mut *variant;
                            }
                        }
                        self.r#payload = ::core::option::Option::Some(
                            Rpc_::Payload::ReqWifiRestore(::core::default::Default::default()),
                        );
                    };
                    mut_ref.decode_len_delimited(decoder)?;
                }
                292u32 => {
                    let mut_ref = loop {
                        if let ::core::option::Option::Some(variant) = &mut self.r#payload {
                            if let Rpc_::Payload::ReqWifiClearFastConnect(variant) = &mut *variant {
                                break &mut *variant;
                            }
                        }
                        self.r#payload =
                            ::core::option::Option::Some(Rpc_::Payload::ReqWifiClearFastConnect(
                                ::core::default::Default::default(),
                            ));
                    };
                    mut_ref.decode_len_delimited(decoder)?;
                }
                293u32 => {
                    let mut_ref = loop {
                        if let ::core::option::Option::Some(variant) = &mut self.r#payload {
                            if let Rpc_::Payload::ReqWifiDeauthSta(variant) = &mut *variant {
                                break &mut *variant;
                            }
                        }
                        self.r#payload = ::core::option::Option::Some(
                            Rpc_::Payload::ReqWifiDeauthSta(::core::default::Default::default()),
                        );
                    };
                    mut_ref.decode_len_delimited(decoder)?;
                }
                294u32 => {
                    let mut_ref = loop {
                        if let ::core::option::Option::Some(variant) = &mut self.r#payload {
                            if let Rpc_::Payload::ReqWifiStaGetApInfo(variant) = &mut *variant {
                                break &mut *variant;
                            }
                        }
                        self.r#payload = ::core::option::Option::Some(
                            Rpc_::Payload::ReqWifiStaGetApInfo(::core::default::Default::default()),
                        );
                    };
                    mut_ref.decode_len_delimited(decoder)?;
                }
                297u32 => {
                    let mut_ref = loop {
                        if let ::core::option::Option::Some(variant) = &mut self.r#payload {
                            if let Rpc_::Payload::ReqWifiSetProtocol(variant) = &mut *variant {
                                break &mut *variant;
                            }
                        }
                        self.r#payload = ::core::option::Option::Some(
                            Rpc_::Payload::ReqWifiSetProtocol(::core::default::Default::default()),
                        );
                    };
                    mut_ref.decode_len_delimited(decoder)?;
                }
                298u32 => {
                    let mut_ref = loop {
                        if let ::core::option::Option::Some(variant) = &mut self.r#payload {
                            if let Rpc_::Payload::ReqWifiGetProtocol(variant) = &mut *variant {
                                break &mut *variant;
                            }
                        }
                        self.r#payload = ::core::option::Option::Some(
                            Rpc_::Payload::ReqWifiGetProtocol(::core::default::Default::default()),
                        );
                    };
                    mut_ref.decode_len_delimited(decoder)?;
                }
                299u32 => {
                    let mut_ref = loop {
                        if let ::core::option::Option::Some(variant) = &mut self.r#payload {
                            if let Rpc_::Payload::ReqWifiSetBandwidth(variant) = &mut *variant {
                                break &mut *variant;
                            }
                        }
                        self.r#payload = ::core::option::Option::Some(
                            Rpc_::Payload::ReqWifiSetBandwidth(::core::default::Default::default()),
                        );
                    };
                    mut_ref.decode_len_delimited(decoder)?;
                }
                300u32 => {
                    let mut_ref = loop {
                        if let ::core::option::Option::Some(variant) = &mut self.r#payload {
                            if let Rpc_::Payload::ReqWifiGetBandwidth(variant) = &mut *variant {
                                break &mut *variant;
                            }
                        }
                        self.r#payload = ::core::option::Option::Some(
                            Rpc_::Payload::ReqWifiGetBandwidth(::core::default::Default::default()),
                        );
                    };
                    mut_ref.decode_len_delimited(decoder)?;
                }
                301u32 => {
                    let mut_ref = loop {
                        if let ::core::option::Option::Some(variant) = &mut self.r#payload {
                            if let Rpc_::Payload::ReqWifiSetChannel(variant) = &mut *variant {
                                break &mut *variant;
                            }
                        }
                        self.r#payload = ::core::option::Option::Some(
                            Rpc_::Payload::ReqWifiSetChannel(::core::default::Default::default()),
                        );
                    };
                    mut_ref.decode_len_delimited(decoder)?;
                }
                302u32 => {
                    let mut_ref = loop {
                        if let ::core::option::Option::Some(variant) = &mut self.r#payload {
                            if let Rpc_::Payload::ReqWifiGetChannel(variant) = &mut *variant {
                                break &mut *variant;
                            }
                        }
                        self.r#payload = ::core::option::Option::Some(
                            Rpc_::Payload::ReqWifiGetChannel(::core::default::Default::default()),
                        );
                    };
                    mut_ref.decode_len_delimited(decoder)?;
                }
                303u32 => {
                    let mut_ref = loop {
                        if let ::core::option::Option::Some(variant) = &mut self.r#payload {
                            if let Rpc_::Payload::ReqWifiSetCountry(variant) = &mut *variant {
                                break &mut *variant;
                            }
                        }
                        self.r#payload = ::core::option::Option::Some(
                            Rpc_::Payload::ReqWifiSetCountry(::core::default::Default::default()),
                        );
                    };
                    mut_ref.decode_len_delimited(decoder)?;
                }
                304u32 => {
                    let mut_ref = loop {
                        if let ::core::option::Option::Some(variant) = &mut self.r#payload {
                            if let Rpc_::Payload::ReqWifiGetCountry(variant) = &mut *variant {
                                break &mut *variant;
                            }
                        }
                        self.r#payload = ::core::option::Option::Some(
                            Rpc_::Payload::ReqWifiGetCountry(::core::default::Default::default()),
                        );
                    };
                    mut_ref.decode_len_delimited(decoder)?;
                }
                311u32 => {
                    let mut_ref = loop {
                        if let ::core::option::Option::Some(variant) = &mut self.r#payload {
                            if let Rpc_::Payload::ReqWifiApGetStaList(variant) = &mut *variant {
                                break &mut *variant;
                            }
                        }
                        self.r#payload = ::core::option::Option::Some(
                            Rpc_::Payload::ReqWifiApGetStaList(::core::default::Default::default()),
                        );
                    };
                    mut_ref.decode_len_delimited(decoder)?;
                }
                312u32 => {
                    let mut_ref = loop {
                        if let ::core::option::Option::Some(variant) = &mut self.r#payload {
                            if let Rpc_::Payload::ReqWifiApGetStaAid(variant) = &mut *variant {
                                break &mut *variant;
                            }
                        }
                        self.r#payload = ::core::option::Option::Some(
                            Rpc_::Payload::ReqWifiApGetStaAid(::core::default::Default::default()),
                        );
                    };
                    mut_ref.decode_len_delimited(decoder)?;
                }
                313u32 => {
                    let mut_ref = loop {
                        if let ::core::option::Option::Some(variant) = &mut self.r#payload {
                            if let Rpc_::Payload::ReqWifiSetStorage(variant) = &mut *variant {
                                break &mut *variant;
                            }
                        }
                        self.r#payload = ::core::option::Option::Some(
                            Rpc_::Payload::ReqWifiSetStorage(::core::default::Default::default()),
                        );
                    };
                    mut_ref.decode_len_delimited(decoder)?;
                }
                334u32 => {
                    let mut_ref = loop {
                        if let ::core::option::Option::Some(variant) = &mut self.r#payload {
                            if let Rpc_::Payload::ReqWifiSetCountryCode(variant) = &mut *variant {
                                break &mut *variant;
                            }
                        }
                        self.r#payload =
                            ::core::option::Option::Some(Rpc_::Payload::ReqWifiSetCountryCode(
                                ::core::default::Default::default(),
                            ));
                    };
                    mut_ref.decode_len_delimited(decoder)?;
                }
                335u32 => {
                    let mut_ref = loop {
                        if let ::core::option::Option::Some(variant) = &mut self.r#payload {
                            if let Rpc_::Payload::ReqWifiGetCountryCode(variant) = &mut *variant {
                                break &mut *variant;
                            }
                        }
                        self.r#payload =
                            ::core::option::Option::Some(Rpc_::Payload::ReqWifiGetCountryCode(
                                ::core::default::Default::default(),
                            ));
                    };
                    mut_ref.decode_len_delimited(decoder)?;
                }
                338u32 => {
                    let mut_ref = loop {
                        if let ::core::option::Option::Some(variant) = &mut self.r#payload {
                            if let Rpc_::Payload::ReqWifiStaGetAid(variant) = &mut *variant {
                                break &mut *variant;
                            }
                        }
                        self.r#payload = ::core::option::Option::Some(
                            Rpc_::Payload::ReqWifiStaGetAid(::core::default::Default::default()),
                        );
                    };
                    mut_ref.decode_len_delimited(decoder)?;
                }
                339u32 => {
                    let mut_ref = loop {
                        if let ::core::option::Option::Some(variant) = &mut self.r#payload {
                            if let Rpc_::Payload::ReqWifiStaGetNegotiatedPhymode(variant) =
                                &mut *variant
                            {
                                break &mut *variant;
                            }
                        }
                        self.r#payload = ::core::option::Option::Some(
                            Rpc_::Payload::ReqWifiStaGetNegotiatedPhymode(
                                ::core::default::Default::default(),
                            ),
                        );
                    };
                    mut_ref.decode_len_delimited(decoder)?;
                }
                341u32 => {
                    let mut_ref = loop {
                        if let ::core::option::Option::Some(variant) = &mut self.r#payload {
                            if let Rpc_::Payload::ReqWifiStaGetRssi(variant) = &mut *variant {
                                break &mut *variant;
                            }
                        }
                        self.r#payload = ::core::option::Option::Some(
                            Rpc_::Payload::ReqWifiStaGetRssi(::core::default::Default::default()),
                        );
                    };
                    mut_ref.decode_len_delimited(decoder)?;
                }
                342u32 => {
                    let mut_ref = loop {
                        if let ::core::option::Option::Some(variant) = &mut self.r#payload {
                            if let Rpc_::Payload::ReqWifiSetProtocols(variant) = &mut *variant {
                                break &mut *variant;
                            }
                        }
                        self.r#payload = ::core::option::Option::Some(
                            Rpc_::Payload::ReqWifiSetProtocols(::core::default::Default::default()),
                        );
                    };
                    mut_ref.decode_len_delimited(decoder)?;
                }
                343u32 => {
                    let mut_ref = loop {
                        if let ::core::option::Option::Some(variant) = &mut self.r#payload {
                            if let Rpc_::Payload::ReqWifiGetProtocols(variant) = &mut *variant {
                                break &mut *variant;
                            }
                        }
                        self.r#payload = ::core::option::Option::Some(
                            Rpc_::Payload::ReqWifiGetProtocols(::core::default::Default::default()),
                        );
                    };
                    mut_ref.decode_len_delimited(decoder)?;
                }
                344u32 => {
                    let mut_ref = loop {
                        if let ::core::option::Option::Some(variant) = &mut self.r#payload {
                            if let Rpc_::Payload::ReqWifiSetBandwidths(variant) = &mut *variant {
                                break &mut *variant;
                            }
                        }
                        self.r#payload = ::core::option::Option::Some(
                            Rpc_::Payload::ReqWifiSetBandwidths(::core::default::Default::default()),
                        );
                    };
                    mut_ref.decode_len_delimited(decoder)?;
                }
                345u32 => {
                    let mut_ref = loop {
                        if let ::core::option::Option::Some(variant) = &mut self.r#payload {
                            if let Rpc_::Payload::ReqWifiGetBandwidths(variant) = &mut *variant {
                                break &mut *variant;
                            }
                        }
                        self.r#payload = ::core::option::Option::Some(
                            Rpc_::Payload::ReqWifiGetBandwidths(::core::default::Default::default()),
                        );
                    };
                    mut_ref.decode_len_delimited(decoder)?;
                }
                346u32 => {
                    let mut_ref = loop {
                        if let ::core::option::Option::Some(variant) = &mut self.r#payload {
                            if let Rpc_::Payload::ReqWifiSetBand(variant) = &mut *variant {
                                break &mut *variant;
                            }
                        }
                        self.r#payload = ::core::option::Option::Some(
                            Rpc_::Payload::ReqWifiSetBand(::core::default::Default::default()),
                        );
                    };
                    mut_ref.decode_len_delimited(decoder)?;
                }
                347u32 => {
                    let mut_ref = loop {
                        if let ::core::option::Option::Some(variant) = &mut self.r#payload {
                            if let Rpc_::Payload::ReqWifiGetBand(variant) = &mut *variant {
                                break &mut *variant;
                            }
                        }
                        self.r#payload = ::core::option::Option::Some(
                            Rpc_::Payload::ReqWifiGetBand(::core::default::Default::default()),
                        );
                    };
                    mut_ref.decode_len_delimited(decoder)?;
                }
                348u32 => {
                    let mut_ref = loop {
                        if let ::core::option::Option::Some(variant) = &mut self.r#payload {
                            if let Rpc_::Payload::ReqWifiSetBandmode(variant) = &mut *variant {
                                break &mut *variant;
                            }
                        }
                        self.r#payload = ::core::option::Option::Some(
                            Rpc_::Payload::ReqWifiSetBandmode(::core::default::Default::default()),
                        );
                    };
                    mut_ref.decode_len_delimited(decoder)?;
                }
                349u32 => {
                    let mut_ref = loop {
                        if let ::core::option::Option::Some(variant) = &mut self.r#payload {
                            if let Rpc_::Payload::ReqWifiGetBandmode(variant) = &mut *variant {
                                break &mut *variant;
                            }
                        }
                        self.r#payload = ::core::option::Option::Some(
                            Rpc_::Payload::ReqWifiGetBandmode(::core::default::Default::default()),
                        );
                    };
                    mut_ref.decode_len_delimited(decoder)?;
                }
                350u32 => {
                    let mut_ref = loop {
                        if let ::core::option::Option::Some(variant) = &mut self.r#payload {
                            if let Rpc_::Payload::ReqGetCoprocessorFwversion(variant) =
                                &mut *variant
                            {
                                break &mut *variant;
                            }
                        }
                        self.r#payload = ::core::option::Option::Some(
                            Rpc_::Payload::ReqGetCoprocessorFwversion(
                                ::core::default::Default::default(),
                            ),
                        );
                    };
                    mut_ref.decode_len_delimited(decoder)?;
                }
                351u32 => {
                    let mut_ref = loop {
                        if let ::core::option::Option::Some(variant) = &mut self.r#payload {
                            if let Rpc_::Payload::ReqWifiScanGetApRecord(variant) = &mut *variant {
                                break &mut *variant;
                            }
                        }
                        self.r#payload =
                            ::core::option::Option::Some(Rpc_::Payload::ReqWifiScanGetApRecord(
                                ::core::default::Default::default(),
                            ));
                    };
                    mut_ref.decode_len_delimited(decoder)?;
                }
                513u32 => {
                    let mut_ref = loop {
                        if let ::core::option::Option::Some(variant) = &mut self.r#payload {
                            if let Rpc_::Payload::RespGetMacAddress(variant) = &mut *variant {
                                break &mut *variant;
                            }
                        }
                        self.r#payload = ::core::option::Option::Some(
                            Rpc_::Payload::RespGetMacAddress(::core::default::Default::default()),
                        );
                    };
                    mut_ref.decode_len_delimited(decoder)?;
                }
                514u32 => {
                    let mut_ref = loop {
                        if let ::core::option::Option::Some(variant) = &mut self.r#payload {
                            if let Rpc_::Payload::RespSetMacAddress(variant) = &mut *variant {
                                break &mut *variant;
                            }
                        }
                        self.r#payload = ::core::option::Option::Some(
                            Rpc_::Payload::RespSetMacAddress(::core::default::Default::default()),
                        );
                    };
                    mut_ref.decode_len_delimited(decoder)?;
                }
                515u32 => {
                    let mut_ref = loop {
                        if let ::core::option::Option::Some(variant) = &mut self.r#payload {
                            if let Rpc_::Payload::RespGetWifiMode(variant) = &mut *variant {
                                break &mut *variant;
                            }
                        }
                        self.r#payload = ::core::option::Option::Some(
                            Rpc_::Payload::RespGetWifiMode(::core::default::Default::default()),
                        );
                    };
                    mut_ref.decode_len_delimited(decoder)?;
                }
                516u32 => {
                    let mut_ref = loop {
                        if let ::core::option::Option::Some(variant) = &mut self.r#payload {
                            if let Rpc_::Payload::RespSetWifiMode(variant) = &mut *variant {
                                break &mut *variant;
                            }
                        }
                        self.r#payload = ::core::option::Option::Some(
                            Rpc_::Payload::RespSetWifiMode(::core::default::Default::default()),
                        );
                    };
                    mut_ref.decode_len_delimited(decoder)?;
                }
                526u32 => {
                    let mut_ref = loop {
                        if let ::core::option::Option::Some(variant) = &mut self.r#payload {
                            if let Rpc_::Payload::RespWifiSetPs(variant) = &mut *variant {
                                break &mut *variant;
                            }
                        }
                        self.r#payload = ::core::option::Option::Some(
                            Rpc_::Payload::RespWifiSetPs(::core::default::Default::default()),
                        );
                    };
                    mut_ref.decode_len_delimited(decoder)?;
                }
                527u32 => {
                    let mut_ref = loop {
                        if let ::core::option::Option::Some(variant) = &mut self.r#payload {
                            if let Rpc_::Payload::RespWifiGetPs(variant) = &mut *variant {
                                break &mut *variant;
                            }
                        }
                        self.r#payload = ::core::option::Option::Some(
                            Rpc_::Payload::RespWifiGetPs(::core::default::Default::default()),
                        );
                    };
                    mut_ref.decode_len_delimited(decoder)?;
                }
                528u32 => {
                    let mut_ref = loop {
                        if let ::core::option::Option::Some(variant) = &mut self.r#payload {
                            if let Rpc_::Payload::RespOtaBegin(variant) = &mut *variant {
                                break &mut *variant;
                            }
                        }
                        self.r#payload = ::core::option::Option::Some(Rpc_::Payload::RespOtaBegin(
                            ::core::default::Default::default(),
                        ));
                    };
                    mut_ref.decode_len_delimited(decoder)?;
                }
                529u32 => {
                    let mut_ref = loop {
                        if let ::core::option::Option::Some(variant) = &mut self.r#payload {
                            if let Rpc_::Payload::RespOtaWrite(variant) = &mut *variant {
                                break &mut *variant;
                            }
                        }
                        self.r#payload = ::core::option::Option::Some(Rpc_::Payload::RespOtaWrite(
                            ::core::default::Default::default(),
                        ));
                    };
                    mut_ref.decode_len_delimited(decoder)?;
                }
                530u32 => {
                    let mut_ref = loop {
                        if let ::core::option::Option::Some(variant) = &mut self.r#payload {
                            if let Rpc_::Payload::RespOtaEnd(variant) = &mut *variant {
                                break &mut *variant;
                            }
                        }
                        self.r#payload = ::core::option::Option::Some(Rpc_::Payload::RespOtaEnd(
                            ::core::default::Default::default(),
                        ));
                    };
                    mut_ref.decode_len_delimited(decoder)?;
                }
                531u32 => {
                    let mut_ref = loop {
                        if let ::core::option::Option::Some(variant) = &mut self.r#payload {
                            if let Rpc_::Payload::RespSetWifiMaxTxPower(variant) = &mut *variant {
                                break &mut *variant;
                            }
                        }
                        self.r#payload =
                            ::core::option::Option::Some(Rpc_::Payload::RespSetWifiMaxTxPower(
                                ::core::default::Default::default(),
                            ));
                    };
                    mut_ref.decode_len_delimited(decoder)?;
                }
                532u32 => {
                    let mut_ref = loop {
                        if let ::core::option::Option::Some(variant) = &mut self.r#payload {
                            if let Rpc_::Payload::RespGetWifiMaxTxPower(variant) = &mut *variant {
                                break &mut *variant;
                            }
                        }
                        self.r#payload =
                            ::core::option::Option::Some(Rpc_::Payload::RespGetWifiMaxTxPower(
                                ::core::default::Default::default(),
                            ));
                    };
                    mut_ref.decode_len_delimited(decoder)?;
                }
                533u32 => {
                    let mut_ref = loop {
                        if let ::core::option::Option::Some(variant) = &mut self.r#payload {
                            if let Rpc_::Payload::RespConfigHeartbeat(variant) = &mut *variant {
                                break &mut *variant;
                            }
                        }
                        self.r#payload = ::core::option::Option::Some(
                            Rpc_::Payload::RespConfigHeartbeat(::core::default::Default::default()),
                        );
                    };
                    mut_ref.decode_len_delimited(decoder)?;
                }
                534u32 => {
                    let mut_ref = loop {
                        if let ::core::option::Option::Some(variant) = &mut self.r#payload {
                            if let Rpc_::Payload::RespWifiInit(variant) = &mut *variant {
                                break &mut *variant;
                            }
                        }
                        self.r#payload = ::core::option::Option::Some(Rpc_::Payload::RespWifiInit(
                            ::core::default::Default::default(),
                        ));
                    };
                    mut_ref.decode_len_delimited(decoder)?;
                }
                535u32 => {
                    let mut_ref = loop {
                        if let ::core::option::Option::Some(variant) = &mut self.r#payload {
                            if let Rpc_::Payload::RespWifiDeinit(variant) = &mut *variant {
                                break &mut *variant;
                            }
                        }
                        self.r#payload = ::core::option::Option::Some(
                            Rpc_::Payload::RespWifiDeinit(::core::default::Default::default()),
                        );
                    };
                    mut_ref.decode_len_delimited(decoder)?;
                }
                536u32 => {
                    let mut_ref = loop {
                        if let ::core::option::Option::Some(variant) = &mut self.r#payload {
                            if let Rpc_::Payload::RespWifiStart(variant) = &mut *variant {
                                break &mut *variant;
                            }
                        }
                        self.r#payload = ::core::option::Option::Some(
                            Rpc_::Payload::RespWifiStart(::core::default::Default::default()),
                        );
                    };
                    mut_ref.decode_len_delimited(decoder)?;
                }
                537u32 => {
                    let mut_ref = loop {
                        if let ::core::option::Option::Some(variant) = &mut self.r#payload {
                            if let Rpc_::Payload::RespWifiStop(variant) = &mut *variant {
                                break &mut *variant;
                            }
                        }
                        self.r#payload = ::core::option::Option::Some(Rpc_::Payload::RespWifiStop(
                            ::core::default::Default::default(),
                        ));
                    };
                    mut_ref.decode_len_delimited(decoder)?;
                }
                538u32 => {
                    let mut_ref = loop {
                        if let ::core::option::Option::Some(variant) = &mut self.r#payload {
                            if let Rpc_::Payload::RespWifiConnect(variant) = &mut *variant {
                                break &mut *variant;
                            }
                        }
                        self.r#payload = ::core::option::Option::Some(
                            Rpc_::Payload::RespWifiConnect(::core::default::Default::default()),
                        );
                    };
                    mut_ref.decode_len_delimited(decoder)?;
                }
                539u32 => {
                    let mut_ref = loop {
                        if let ::core::option::Option::Some(variant) = &mut self.r#payload {
                            if let Rpc_::Payload::RespWifiDisconnect(variant) = &mut *variant {
                                break &mut *variant;
                            }
                        }
                        self.r#payload = ::core::option::Option::Some(
                            Rpc_::Payload::RespWifiDisconnect(::core::default::Default::default()),
                        );
                    };
                    mut_ref.decode_len_delimited(decoder)?;
                }
                540u32 => {
                    let mut_ref = loop {
                        if let ::core::option::Option::Some(variant) = &mut self.r#payload {
                            if let Rpc_::Payload::RespWifiSetConfig(variant) = &mut *variant {
                                break &mut *variant;
                            }
                        }
                        self.r#payload = ::core::option::Option::Some(
                            Rpc_::Payload::RespWifiSetConfig(::core::default::Default::default()),
                        );
                    };
                    mut_ref.decode_len_delimited(decoder)?;
                }
                541u32 => {
                    let mut_ref = loop {
                        if let ::core::option::Option::Some(variant) = &mut self.r#payload {
                            if let Rpc_::Payload::RespWifiGetConfig(variant) = &mut *variant {
                                break &mut *variant;
                            }
                        }
                        self.r#payload = ::core::option::Option::Some(
                            Rpc_::Payload::RespWifiGetConfig(::core::default::Default::default()),
                        );
                    };
                    mut_ref.decode_len_delimited(decoder)?;
                }
                542u32 => {
                    let mut_ref = loop {
                        if let ::core::option::Option::Some(variant) = &mut self.r#payload {
                            if let Rpc_::Payload::RespWifiScanStart(variant) = &mut *variant {
                                break &mut *variant;
                            }
                        }
                        self.r#payload = ::core::option::Option::Some(
                            Rpc_::Payload::RespWifiScanStart(::core::default::Default::default()),
                        );
                    };
                    mut_ref.decode_len_delimited(decoder)?;
                }
                543u32 => {
                    let mut_ref = loop {
                        if let ::core::option::Option::Some(variant) = &mut self.r#payload {
                            if let Rpc_::Payload::RespWifiScanStop(variant) = &mut *variant {
                                break &mut *variant;
                            }
                        }
                        self.r#payload = ::core::option::Option::Some(
                            Rpc_::Payload::RespWifiScanStop(::core::default::Default::default()),
                        );
                    };
                    mut_ref.decode_len_delimited(decoder)?;
                }
                544u32 => {
                    let mut_ref = loop {
                        if let ::core::option::Option::Some(variant) = &mut self.r#payload {
                            if let Rpc_::Payload::RespWifiScanGetApNum(variant) = &mut *variant {
                                break &mut *variant;
                            }
                        }
                        self.r#payload = ::core::option::Option::Some(
                            Rpc_::Payload::RespWifiScanGetApNum(::core::default::Default::default()),
                        );
                    };
                    mut_ref.decode_len_delimited(decoder)?;
                }
                545u32 => {
                    let mut_ref = loop {
                        if let ::core::option::Option::Some(variant) = &mut self.r#payload {
                            if let Rpc_::Payload::RespWifiScanGetApRecords(variant) = &mut *variant
                            {
                                break &mut *variant;
                            }
                        }
                        self.r#payload =
                            ::core::option::Option::Some(Rpc_::Payload::RespWifiScanGetApRecords(
                                ::core::default::Default::default(),
                            ));
                    };
                    mut_ref.decode_len_delimited(decoder)?;
                }
                546u32 => {
                    let mut_ref = loop {
                        if let ::core::option::Option::Some(variant) = &mut self.r#payload {
                            if let Rpc_::Payload::RespWifiClearApList(variant) = &mut *variant {
                                break &mut *variant;
                            }
                        }
                        self.r#payload = ::core::option::Option::Some(
                            Rpc_::Payload::RespWifiClearApList(::core::default::Default::default()),
                        );
                    };
                    mut_ref.decode_len_delimited(decoder)?;
                }
                547u32 => {
                    let mut_ref = loop {
                        if let ::core::option::Option::Some(variant) = &mut self.r#payload {
                            if let Rpc_::Payload::RespWifiRestore(variant) = &mut *variant {
                                break &mut *variant;
                            }
                        }
                        self.r#payload = ::core::option::Option::Some(
                            Rpc_::Payload::RespWifiRestore(::core::default::Default::default()),
                        );
                    };
                    mut_ref.decode_len_delimited(decoder)?;
                }
                548u32 => {
                    let mut_ref = loop {
                        if let ::core::option::Option::Some(variant) = &mut self.r#payload {
                            if let Rpc_::Payload::RespWifiClearFastConnect(variant) = &mut *variant
                            {
                                break &mut *variant;
                            }
                        }
                        self.r#payload =
                            ::core::option::Option::Some(Rpc_::Payload::RespWifiClearFastConnect(
                                ::core::default::Default::default(),
                            ));
                    };
                    mut_ref.decode_len_delimited(decoder)?;
                }
                549u32 => {
                    let mut_ref = loop {
                        if let ::core::option::Option::Some(variant) = &mut self.r#payload {
                            if let Rpc_::Payload::RespWifiDeauthSta(variant) = &mut *variant {
                                break &mut *variant;
                            }
                        }
                        self.r#payload = ::core::option::Option::Some(
                            Rpc_::Payload::RespWifiDeauthSta(::core::default::Default::default()),
                        );
                    };
                    mut_ref.decode_len_delimited(decoder)?;
                }
                550u32 => {
                    let mut_ref = loop {
                        if let ::core::option::Option::Some(variant) = &mut self.r#payload {
                            if let Rpc_::Payload::RespWifiStaGetApInfo(variant) = &mut *variant {
                                break &mut *variant;
                            }
                        }
                        self.r#payload = ::core::option::Option::Some(
                            Rpc_::Payload::RespWifiStaGetApInfo(::core::default::Default::default()),
                        );
                    };
                    mut_ref.decode_len_delimited(decoder)?;
                }
                553u32 => {
                    let mut_ref = loop {
                        if let ::core::option::Option::Some(variant) = &mut self.r#payload {
                            if let Rpc_::Payload::RespWifiSetProtocol(variant) = &mut *variant {
                                break &mut *variant;
                            }
                        }
                        self.r#payload = ::core::option::Option::Some(
                            Rpc_::Payload::RespWifiSetProtocol(::core::default::Default::default()),
                        );
                    };
                    mut_ref.decode_len_delimited(decoder)?;
                }
                554u32 => {
                    let mut_ref = loop {
                        if let ::core::option::Option::Some(variant) = &mut self.r#payload {
                            if let Rpc_::Payload::RespWifiGetProtocol(variant) = &mut *variant {
                                break &mut *variant;
                            }
                        }
                        self.r#payload = ::core::option::Option::Some(
                            Rpc_::Payload::RespWifiGetProtocol(::core::default::Default::default()),
                        );
                    };
                    mut_ref.decode_len_delimited(decoder)?;
                }
                555u32 => {
                    let mut_ref = loop {
                        if let ::core::option::Option::Some(variant) = &mut self.r#payload {
                            if let Rpc_::Payload::RespWifiSetBandwidth(variant) = &mut *variant {
                                break &mut *variant;
                            }
                        }
                        self.r#payload = ::core::option::Option::Some(
                            Rpc_::Payload::RespWifiSetBandwidth(::core::default::Default::default()),
                        );
                    };
                    mut_ref.decode_len_delimited(decoder)?;
                }
                556u32 => {
                    let mut_ref = loop {
                        if let ::core::option::Option::Some(variant) = &mut self.r#payload {
                            if let Rpc_::Payload::RespWifiGetBandwidth(variant) = &mut *variant {
                                break &mut *variant;
                            }
                        }
                        self.r#payload = ::core::option::Option::Some(
                            Rpc_::Payload::RespWifiGetBandwidth(::core::default::Default::default()),
                        );
                    };
                    mut_ref.decode_len_delimited(decoder)?;
                }
                557u32 => {
                    let mut_ref = loop {
                        if let ::core::option::Option::Some(variant) = &mut self.r#payload {
                            if let Rpc_::Payload::RespWifiSetChannel(variant) = &mut *variant {
                                break &mut *variant;
                            }
                        }
                        self.r#payload = ::core::option::Option::Some(
                            Rpc_::Payload::RespWifiSetChannel(::core::default::Default::default()),
                        );
                    };
                    mut_ref.decode_len_delimited(decoder)?;
                }
                558u32 => {
                    let mut_ref = loop {
                        if let ::core::option::Option::Some(variant) = &mut self.r#payload {
                            if let Rpc_::Payload::RespWifiGetChannel(variant) = &mut *variant {
                                break &mut *variant;
                            }
                        }
                        self.r#payload = ::core::option::Option::Some(
                            Rpc_::Payload::RespWifiGetChannel(::core::default::Default::default()),
                        );
                    };
                    mut_ref.decode_len_delimited(decoder)?;
                }
                559u32 => {
                    let mut_ref = loop {
                        if let ::core::option::Option::Some(variant) = &mut self.r#payload {
                            if let Rpc_::Payload::RespWifiSetCountry(variant) = &mut *variant {
                                break &mut *variant;
                            }
                        }
                        self.r#payload = ::core::option::Option::Some(
                            Rpc_::Payload::RespWifiSetCountry(::core::default::Default::default()),
                        );
                    };
                    mut_ref.decode_len_delimited(decoder)?;
                }
                560u32 => {
                    let mut_ref = loop {
                        if let ::core::option::Option::Some(variant) = &mut self.r#payload {
                            if let Rpc_::Payload::RespWifiGetCountry(variant) = &mut *variant {
                                break &mut *variant;
                            }
                        }
                        self.r#payload = ::core::option::Option::Some(
                            Rpc_::Payload::RespWifiGetCountry(::core::default::Default::default()),
                        );
                    };
                    mut_ref.decode_len_delimited(decoder)?;
                }
                567u32 => {
                    let mut_ref = loop {
                        if let ::core::option::Option::Some(variant) = &mut self.r#payload {
                            if let Rpc_::Payload::RespWifiApGetStaList(variant) = &mut *variant {
                                break &mut *variant;
                            }
                        }
                        self.r#payload = ::core::option::Option::Some(
                            Rpc_::Payload::RespWifiApGetStaList(::core::default::Default::default()),
                        );
                    };
                    mut_ref.decode_len_delimited(decoder)?;
                }
                568u32 => {
                    let mut_ref = loop {
                        if let ::core::option::Option::Some(variant) = &mut self.r#payload {
                            if let Rpc_::Payload::RespWifiApGetStaAid(variant) = &mut *variant {
                                break &mut *variant;
                            }
                        }
                        self.r#payload = ::core::option::Option::Some(
                            Rpc_::Payload::RespWifiApGetStaAid(::core::default::Default::default()),
                        );
                    };
                    mut_ref.decode_len_delimited(decoder)?;
                }
                569u32 => {
                    let mut_ref = loop {
                        if let ::core::option::Option::Some(variant) = &mut self.r#payload {
                            if let Rpc_::Payload::RespWifiSetStorage(variant) = &mut *variant {
                                break &mut *variant;
                            }
                        }
                        self.r#payload = ::core::option::Option::Some(
                            Rpc_::Payload::RespWifiSetStorage(::core::default::Default::default()),
                        );
                    };
                    mut_ref.decode_len_delimited(decoder)?;
                }
                590u32 => {
                    let mut_ref = loop {
                        if let ::core::option::Option::Some(variant) = &mut self.r#payload {
                            if let Rpc_::Payload::RespWifiSetCountryCode(variant) = &mut *variant {
                                break &mut *variant;
                            }
                        }
                        self.r#payload =
                            ::core::option::Option::Some(Rpc_::Payload::RespWifiSetCountryCode(
                                ::core::default::Default::default(),
                            ));
                    };
                    mut_ref.decode_len_delimited(decoder)?;
                }
                591u32 => {
                    let mut_ref = loop {
                        if let ::core::option::Option::Some(variant) = &mut self.r#payload {
                            if let Rpc_::Payload::RespWifiGetCountryCode(variant) = &mut *variant {
                                break &mut *variant;
                            }
                        }
                        self.r#payload =
                            ::core::option::Option::Some(Rpc_::Payload::RespWifiGetCountryCode(
                                ::core::default::Default::default(),
                            ));
                    };
                    mut_ref.decode_len_delimited(decoder)?;
                }
                594u32 => {
                    let mut_ref = loop {
                        if let ::core::option::Option::Some(variant) = &mut self.r#payload {
                            if let Rpc_::Payload::RespWifiStaGetAid(variant) = &mut *variant {
                                break &mut *variant;
                            }
                        }
                        self.r#payload = ::core::option::Option::Some(
                            Rpc_::Payload::RespWifiStaGetAid(::core::default::Default::default()),
                        );
                    };
                    mut_ref.decode_len_delimited(decoder)?;
                }
                595u32 => {
                    let mut_ref = loop {
                        if let ::core::option::Option::Some(variant) = &mut self.r#payload {
                            if let Rpc_::Payload::RespWifiStaGetNegotiatedPhymode(variant) =
                                &mut *variant
                            {
                                break &mut *variant;
                            }
                        }
                        self.r#payload = ::core::option::Option::Some(
                            Rpc_::Payload::RespWifiStaGetNegotiatedPhymode(
                                ::core::default::Default::default(),
                            ),
                        );
                    };
                    mut_ref.decode_len_delimited(decoder)?;
                }
                597u32 => {
                    let mut_ref = loop {
                        if let ::core::option::Option::Some(variant) = &mut self.r#payload {
                            if let Rpc_::Payload::RespWifiStaGetRssi(variant) = &mut *variant {
                                break &mut *variant;
                            }
                        }
                        self.r#payload = ::core::option::Option::Some(
                            Rpc_::Payload::RespWifiStaGetRssi(::core::default::Default::default()),
                        );
                    };
                    mut_ref.decode_len_delimited(decoder)?;
                }
                598u32 => {
                    let mut_ref = loop {
                        if let ::core::option::Option::Some(variant) = &mut self.r#payload {
                            if let Rpc_::Payload::RespWifiSetProtocols(variant) = &mut *variant {
                                break &mut *variant;
                            }
                        }
                        self.r#payload = ::core::option::Option::Some(
                            Rpc_::Payload::RespWifiSetProtocols(::core::default::Default::default()),
                        );
                    };
                    mut_ref.decode_len_delimited(decoder)?;
                }
                599u32 => {
                    let mut_ref = loop {
                        if let ::core::option::Option::Some(variant) = &mut self.r#payload {
                            if let Rpc_::Payload::RespWifiGetProtocols(variant) = &mut *variant {
                                break &mut *variant;
                            }
                        }
                        self.r#payload = ::core::option::Option::Some(
                            Rpc_::Payload::RespWifiGetProtocols(::core::default::Default::default()),
                        );
                    };
                    mut_ref.decode_len_delimited(decoder)?;
                }
                600u32 => {
                    let mut_ref = loop {
                        if let ::core::option::Option::Some(variant) = &mut self.r#payload {
                            if let Rpc_::Payload::RespWifiSetBandwidths(variant) = &mut *variant {
                                break &mut *variant;
                            }
                        }
                        self.r#payload =
                            ::core::option::Option::Some(Rpc_::Payload::RespWifiSetBandwidths(
                                ::core::default::Default::default(),
                            ));
                    };
                    mut_ref.decode_len_delimited(decoder)?;
                }
                601u32 => {
                    let mut_ref = loop {
                        if let ::core::option::Option::Some(variant) = &mut self.r#payload {
                            if let Rpc_::Payload::RespWifiGetBandwidths(variant) = &mut *variant {
                                break &mut *variant;
                            }
                        }
                        self.r#payload =
                            ::core::option::Option::Some(Rpc_::Payload::RespWifiGetBandwidths(
                                ::core::default::Default::default(),
                            ));
                    };
                    mut_ref.decode_len_delimited(decoder)?;
                }
                602u32 => {
                    let mut_ref = loop {
                        if let ::core::option::Option::Some(variant) = &mut self.r#payload {
                            if let Rpc_::Payload::RespWifiSetBand(variant) = &mut *variant {
                                break &mut *variant;
                            }
                        }
                        self.r#payload = ::core::option::Option::Some(
                            Rpc_::Payload::RespWifiSetBand(::core::default::Default::default()),
                        );
                    };
                    mut_ref.decode_len_delimited(decoder)?;
                }
                603u32 => {
                    let mut_ref = loop {
                        if let ::core::option::Option::Some(variant) = &mut self.r#payload {
                            if let Rpc_::Payload::RespWifiGetBand(variant) = &mut *variant {
                                break &mut *variant;
                            }
                        }
                        self.r#payload = ::core::option::Option::Some(
                            Rpc_::Payload::RespWifiGetBand(::core::default::Default::default()),
                        );
                    };
                    mut_ref.decode_len_delimited(decoder)?;
                }
                604u32 => {
                    let mut_ref = loop {
                        if let ::core::option::Option::Some(variant) = &mut self.r#payload {
                            if let Rpc_::Payload::RespWifiSetBandmode(variant) = &mut *variant {
                                break &mut *variant;
                            }
                        }
                        self.r#payload = ::core::option::Option::Some(
                            Rpc_::Payload::RespWifiSetBandmode(::core::default::Default::default()),
                        );
                    };
                    mut_ref.decode_len_delimited(decoder)?;
                }
                605u32 => {
                    let mut_ref = loop {
                        if let ::core::option::Option::Some(variant) = &mut self.r#payload {
                            if let Rpc_::Payload::RespWifiGetBandmode(variant) = &mut *variant {
                                break &mut *variant;
                            }
                        }
                        self.r#payload = ::core::option::Option::Some(
                            Rpc_::Payload::RespWifiGetBandmode(::core::default::Default::default()),
                        );
                    };
                    mut_ref.decode_len_delimited(decoder)?;
                }
                606u32 => {
                    let mut_ref = loop {
                        if let ::core::option::Option::Some(variant) = &mut self.r#payload {
                            if let Rpc_::Payload::RespGetCoprocessorFwversion(variant) =
                                &mut *variant
                            {
                                break &mut *variant;
                            }
                        }
                        self.r#payload = ::core::option::Option::Some(
                            Rpc_::Payload::RespGetCoprocessorFwversion(
                                ::core::default::Default::default(),
                            ),
                        );
                    };
                    mut_ref.decode_len_delimited(decoder)?;
                }
                607u32 => {
                    let mut_ref = loop {
                        if let ::core::option::Option::Some(variant) = &mut self.r#payload {
                            if let Rpc_::Payload::RespWifiScanGetApRecord(variant) = &mut *variant {
                                break &mut *variant;
                            }
                        }
                        self.r#payload =
                            ::core::option::Option::Some(Rpc_::Payload::RespWifiScanGetApRecord(
                                ::core::default::Default::default(),
                            ));
                    };
                    mut_ref.decode_len_delimited(decoder)?;
                }
                769u32 => {
                    let mut_ref = loop {
                        if let ::core::option::Option::Some(variant) = &mut self.r#payload {
                            if let Rpc_::Payload::EventEspInit(variant) = &mut *variant {
                                break &mut *variant;
                            }
                        }
                        self.r#payload = ::core::option::Option::Some(Rpc_::Payload::EventEspInit(
                            ::core::default::Default::default(),
                        ));
                    };
                    mut_ref.decode_len_delimited(decoder)?;
                }
                770u32 => {
                    let mut_ref = loop {
                        if let ::core::option::Option::Some(variant) = &mut self.r#payload {
                            if let Rpc_::Payload::EventHeartbeat(variant) = &mut *variant {
                                break &mut *variant;
                            }
                        }
                        self.r#payload = ::core::option::Option::Some(
                            Rpc_::Payload::EventHeartbeat(::core::default::Default::default()),
                        );
                    };
                    mut_ref.decode_len_delimited(decoder)?;
                }
                771u32 => {
                    let mut_ref = loop {
                        if let ::core::option::Option::Some(variant) = &mut self.r#payload {
                            if let Rpc_::Payload::EventApStaConnected(variant) = &mut *variant {
                                break &mut *variant;
                            }
                        }
                        self.r#payload = ::core::option::Option::Some(
                            Rpc_::Payload::EventApStaConnected(::core::default::Default::default()),
                        );
                    };
                    mut_ref.decode_len_delimited(decoder)?;
                }
                772u32 => {
                    let mut_ref = loop {
                        if let ::core::option::Option::Some(variant) = &mut self.r#payload {
                            if let Rpc_::Payload::EventApStaDisconnected(variant) = &mut *variant {
                                break &mut *variant;
                            }
                        }
                        self.r#payload =
                            ::core::option::Option::Some(Rpc_::Payload::EventApStaDisconnected(
                                ::core::default::Default::default(),
                            ));
                    };
                    mut_ref.decode_len_delimited(decoder)?;
                }
                773u32 => {
                    let mut_ref = loop {
                        if let ::core::option::Option::Some(variant) = &mut self.r#payload {
                            if let Rpc_::Payload::EventWifiEventNoArgs(variant) = &mut *variant {
                                break &mut *variant;
                            }
                        }
                        self.r#payload = ::core::option::Option::Some(
                            Rpc_::Payload::EventWifiEventNoArgs(::core::default::Default::default()),
                        );
                    };
                    mut_ref.decode_len_delimited(decoder)?;
                }
                774u32 => {
                    let mut_ref = loop {
                        if let ::core::option::Option::Some(variant) = &mut self.r#payload {
                            if let Rpc_::Payload::EventStaScanDone(variant) = &mut *variant {
                                break &mut *variant;
                            }
                        }
                        self.r#payload = ::core::option::Option::Some(
                            Rpc_::Payload::EventStaScanDone(::core::default::Default::default()),
                        );
                    };
                    mut_ref.decode_len_delimited(decoder)?;
                }
                775u32 => {
                    let mut_ref = loop {
                        if let ::core::option::Option::Some(variant) = &mut self.r#payload {
                            if let Rpc_::Payload::EventStaConnected(variant) = &mut *variant {
                                break &mut *variant;
                            }
                        }
                        self.r#payload = ::core::option::Option::Some(
                            Rpc_::Payload::EventStaConnected(::core::default::Default::default()),
                        );
                    };
                    mut_ref.decode_len_delimited(decoder)?;
                }
                776u32 => {
                    let mut_ref = loop {
                        if let ::core::option::Option::Some(variant) = &mut self.r#payload {
                            if let Rpc_::Payload::EventStaDisconnected(variant) = &mut *variant {
                                break &mut *variant;
                            }
                        }
                        self.r#payload = ::core::option::Option::Some(
                            Rpc_::Payload::EventStaDisconnected(::core::default::Default::default()),
                        );
                    };
                    mut_ref.decode_len_delimited(decoder)?;
                }
                _ => {
                    decoder.skip_wire_value(tag.wire_type())?;
                }
            }
        }
        Ok(())
    }
}
impl ::micropb::MessageEncode for Rpc {
    const MAX_SIZE: ::core::option::Option<usize> = 'msg: {
        let mut max_size = 0;
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(10usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(10usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        if let ::core::option::Option::Some(size) =
            ::micropb::const_map!(::core::option::Option::Some(5usize), |size| size + 1usize)
        {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        if let ::core::option::Option::Some(size) = 'oneof: {
            let mut max_size = 0;
            if let ::core::option::Option::Some(size) = ::micropb::const_map!(
                ::micropb::const_map!(
                    <Rpc_Req_GetMacAddress as ::micropb::MessageEncode>::MAX_SIZE,
                    |size| ::micropb::size::sizeof_len_record(size)
                ),
                |size| size + 2usize
            ) {
                if size > max_size {
                    max_size = size;
                }
            } else {
                break 'oneof (::core::option::Option::<usize>::None);
            }
            if let ::core::option::Option::Some(size) = ::micropb::const_map!(
                ::micropb::const_map!(
                    <Rpc_Req_SetMacAddress as ::micropb::MessageEncode>::MAX_SIZE,
                    |size| ::micropb::size::sizeof_len_record(size)
                ),
                |size| size + 2usize
            ) {
                if size > max_size {
                    max_size = size;
                }
            } else {
                break 'oneof (::core::option::Option::<usize>::None);
            }
            if let ::core::option::Option::Some(size) = ::micropb::const_map!(
                ::micropb::const_map!(
                    <Rpc_Req_GetMode as ::micropb::MessageEncode>::MAX_SIZE,
                    |size| ::micropb::size::sizeof_len_record(size)
                ),
                |size| size + 2usize
            ) {
                if size > max_size {
                    max_size = size;
                }
            } else {
                break 'oneof (::core::option::Option::<usize>::None);
            }
            if let ::core::option::Option::Some(size) = ::micropb::const_map!(
                ::micropb::const_map!(
                    <Rpc_Req_SetMode as ::micropb::MessageEncode>::MAX_SIZE,
                    |size| ::micropb::size::sizeof_len_record(size)
                ),
                |size| size + 2usize
            ) {
                if size > max_size {
                    max_size = size;
                }
            } else {
                break 'oneof (::core::option::Option::<usize>::None);
            }
            if let ::core::option::Option::Some(size) = ::micropb::const_map!(
                ::micropb::const_map!(
                    <Rpc_Req_SetPs as ::micropb::MessageEncode>::MAX_SIZE,
                    |size| ::micropb::size::sizeof_len_record(size)
                ),
                |size| size + 2usize
            ) {
                if size > max_size {
                    max_size = size;
                }
            } else {
                break 'oneof (::core::option::Option::<usize>::None);
            }
            if let ::core::option::Option::Some(size) = ::micropb::const_map!(
                ::micropb::const_map!(
                    <Rpc_Req_GetPs as ::micropb::MessageEncode>::MAX_SIZE,
                    |size| ::micropb::size::sizeof_len_record(size)
                ),
                |size| size + 2usize
            ) {
                if size > max_size {
                    max_size = size;
                }
            } else {
                break 'oneof (::core::option::Option::<usize>::None);
            }
            if let ::core::option::Option::Some(size) = ::micropb::const_map!(
                ::micropb::const_map!(
                    <Rpc_Req_OTABegin as ::micropb::MessageEncode>::MAX_SIZE,
                    |size| ::micropb::size::sizeof_len_record(size)
                ),
                |size| size + 2usize
            ) {
                if size > max_size {
                    max_size = size;
                }
            } else {
                break 'oneof (::core::option::Option::<usize>::None);
            }
            if let ::core::option::Option::Some(size) = ::micropb::const_map!(
                ::micropb::const_map!(
                    <Rpc_Req_OTAWrite as ::micropb::MessageEncode>::MAX_SIZE,
                    |size| ::micropb::size::sizeof_len_record(size)
                ),
                |size| size + 2usize
            ) {
                if size > max_size {
                    max_size = size;
                }
            } else {
                break 'oneof (::core::option::Option::<usize>::None);
            }
            if let ::core::option::Option::Some(size) = ::micropb::const_map!(
                ::micropb::const_map!(
                    <Rpc_Req_OTAEnd as ::micropb::MessageEncode>::MAX_SIZE,
                    |size| ::micropb::size::sizeof_len_record(size)
                ),
                |size| size + 2usize
            ) {
                if size > max_size {
                    max_size = size;
                }
            } else {
                break 'oneof (::core::option::Option::<usize>::None);
            }
            if let ::core::option::Option::Some(size) = ::micropb::const_map!(
                ::micropb::const_map!(
                    <Rpc_Req_WifiSetMaxTxPower as ::micropb::MessageEncode>::MAX_SIZE,
                    |size| ::micropb::size::sizeof_len_record(size)
                ),
                |size| size + 2usize
            ) {
                if size > max_size {
                    max_size = size;
                }
            } else {
                break 'oneof (::core::option::Option::<usize>::None);
            }
            if let ::core::option::Option::Some(size) = ::micropb::const_map!(
                ::micropb::const_map!(
                    <Rpc_Req_WifiGetMaxTxPower as ::micropb::MessageEncode>::MAX_SIZE,
                    |size| ::micropb::size::sizeof_len_record(size)
                ),
                |size| size + 2usize
            ) {
                if size > max_size {
                    max_size = size;
                }
            } else {
                break 'oneof (::core::option::Option::<usize>::None);
            }
            if let ::core::option::Option::Some(size) = ::micropb::const_map!(
                ::micropb::const_map!(
                    <Rpc_Req_ConfigHeartbeat as ::micropb::MessageEncode>::MAX_SIZE,
                    |size| ::micropb::size::sizeof_len_record(size)
                ),
                |size| size + 2usize
            ) {
                if size > max_size {
                    max_size = size;
                }
            } else {
                break 'oneof (::core::option::Option::<usize>::None);
            }
            if let ::core::option::Option::Some(size) = ::micropb::const_map!(
                ::micropb::const_map!(
                    <Rpc_Req_WifiInit as ::micropb::MessageEncode>::MAX_SIZE,
                    |size| ::micropb::size::sizeof_len_record(size)
                ),
                |size| size + 2usize
            ) {
                if size > max_size {
                    max_size = size;
                }
            } else {
                break 'oneof (::core::option::Option::<usize>::None);
            }
            if let ::core::option::Option::Some(size) = ::micropb::const_map!(
                ::micropb::const_map!(
                    <Rpc_Req_WifiDeinit as ::micropb::MessageEncode>::MAX_SIZE,
                    |size| ::micropb::size::sizeof_len_record(size)
                ),
                |size| size + 2usize
            ) {
                if size > max_size {
                    max_size = size;
                }
            } else {
                break 'oneof (::core::option::Option::<usize>::None);
            }
            if let ::core::option::Option::Some(size) = ::micropb::const_map!(
                ::micropb::const_map!(
                    <Rpc_Req_WifiStart as ::micropb::MessageEncode>::MAX_SIZE,
                    |size| ::micropb::size::sizeof_len_record(size)
                ),
                |size| size + 2usize
            ) {
                if size > max_size {
                    max_size = size;
                }
            } else {
                break 'oneof (::core::option::Option::<usize>::None);
            }
            if let ::core::option::Option::Some(size) = ::micropb::const_map!(
                ::micropb::const_map!(
                    <Rpc_Req_WifiStop as ::micropb::MessageEncode>::MAX_SIZE,
                    |size| ::micropb::size::sizeof_len_record(size)
                ),
                |size| size + 2usize
            ) {
                if size > max_size {
                    max_size = size;
                }
            } else {
                break 'oneof (::core::option::Option::<usize>::None);
            }
            if let ::core::option::Option::Some(size) = ::micropb::const_map!(
                ::micropb::const_map!(
                    <Rpc_Req_WifiConnect as ::micropb::MessageEncode>::MAX_SIZE,
                    |size| ::micropb::size::sizeof_len_record(size)
                ),
                |size| size + 2usize
            ) {
                if size > max_size {
                    max_size = size;
                }
            } else {
                break 'oneof (::core::option::Option::<usize>::None);
            }
            if let ::core::option::Option::Some(size) = ::micropb::const_map!(
                ::micropb::const_map!(
                    <Rpc_Req_WifiDisconnect as ::micropb::MessageEncode>::MAX_SIZE,
                    |size| ::micropb::size::sizeof_len_record(size)
                ),
                |size| size + 2usize
            ) {
                if size > max_size {
                    max_size = size;
                }
            } else {
                break 'oneof (::core::option::Option::<usize>::None);
            }
            if let ::core::option::Option::Some(size) = ::micropb::const_map!(
                ::micropb::const_map!(
                    <Rpc_Req_WifiSetConfig as ::micropb::MessageEncode>::MAX_SIZE,
                    |size| ::micropb::size::sizeof_len_record(size)
                ),
                |size| size + 2usize
            ) {
                if size > max_size {
                    max_size = size;
                }
            } else {
                break 'oneof (::core::option::Option::<usize>::None);
            }
            if let ::core::option::Option::Some(size) = ::micropb::const_map!(
                ::micropb::const_map!(
                    <Rpc_Req_WifiGetConfig as ::micropb::MessageEncode>::MAX_SIZE,
                    |size| ::micropb::size::sizeof_len_record(size)
                ),
                |size| size + 2usize
            ) {
                if size > max_size {
                    max_size = size;
                }
            } else {
                break 'oneof (::core::option::Option::<usize>::None);
            }
            if let ::core::option::Option::Some(size) = ::micropb::const_map!(
                ::micropb::const_map!(
                    <Rpc_Req_WifiScanStart as ::micropb::MessageEncode>::MAX_SIZE,
                    |size| ::micropb::size::sizeof_len_record(size)
                ),
                |size| size + 2usize
            ) {
                if size > max_size {
                    max_size = size;
                }
            } else {
                break 'oneof (::core::option::Option::<usize>::None);
            }
            if let ::core::option::Option::Some(size) = ::micropb::const_map!(
                ::micropb::const_map!(
                    <Rpc_Req_WifiScanStop as ::micropb::MessageEncode>::MAX_SIZE,
                    |size| ::micropb::size::sizeof_len_record(size)
                ),
                |size| size + 2usize
            ) {
                if size > max_size {
                    max_size = size;
                }
            } else {
                break 'oneof (::core::option::Option::<usize>::None);
            }
            if let ::core::option::Option::Some(size) = ::micropb::const_map!(
                ::micropb::const_map!(
                    <Rpc_Req_WifiScanGetApNum as ::micropb::MessageEncode>::MAX_SIZE,
                    |size| ::micropb::size::sizeof_len_record(size)
                ),
                |size| size + 2usize
            ) {
                if size > max_size {
                    max_size = size;
                }
            } else {
                break 'oneof (::core::option::Option::<usize>::None);
            }
            if let ::core::option::Option::Some(size) = ::micropb::const_map!(
                ::micropb::const_map!(
                    <Rpc_Req_WifiScanGetApRecords as ::micropb::MessageEncode>::MAX_SIZE,
                    |size| ::micropb::size::sizeof_len_record(size)
                ),
                |size| size + 2usize
            ) {
                if size > max_size {
                    max_size = size;
                }
            } else {
                break 'oneof (::core::option::Option::<usize>::None);
            }
            if let ::core::option::Option::Some(size) = ::micropb::const_map!(
                ::micropb::const_map!(
                    <Rpc_Req_WifiClearApList as ::micropb::MessageEncode>::MAX_SIZE,
                    |size| ::micropb::size::sizeof_len_record(size)
                ),
                |size| size + 2usize
            ) {
                if size > max_size {
                    max_size = size;
                }
            } else {
                break 'oneof (::core::option::Option::<usize>::None);
            }
            if let ::core::option::Option::Some(size) = ::micropb::const_map!(
                ::micropb::const_map!(
                    <Rpc_Req_WifiRestore as ::micropb::MessageEncode>::MAX_SIZE,
                    |size| ::micropb::size::sizeof_len_record(size)
                ),
                |size| size + 2usize
            ) {
                if size > max_size {
                    max_size = size;
                }
            } else {
                break 'oneof (::core::option::Option::<usize>::None);
            }
            if let ::core::option::Option::Some(size) = ::micropb::const_map!(
                ::micropb::const_map!(
                    <Rpc_Req_WifiClearFastConnect as ::micropb::MessageEncode>::MAX_SIZE,
                    |size| ::micropb::size::sizeof_len_record(size)
                ),
                |size| size + 2usize
            ) {
                if size > max_size {
                    max_size = size;
                }
            } else {
                break 'oneof (::core::option::Option::<usize>::None);
            }
            if let ::core::option::Option::Some(size) = ::micropb::const_map!(
                ::micropb::const_map!(
                    <Rpc_Req_WifiDeauthSta as ::micropb::MessageEncode>::MAX_SIZE,
                    |size| ::micropb::size::sizeof_len_record(size)
                ),
                |size| size + 2usize
            ) {
                if size > max_size {
                    max_size = size;
                }
            } else {
                break 'oneof (::core::option::Option::<usize>::None);
            }
            if let ::core::option::Option::Some(size) = ::micropb::const_map!(
                ::micropb::const_map!(
                    <Rpc_Req_WifiStaGetApInfo as ::micropb::MessageEncode>::MAX_SIZE,
                    |size| ::micropb::size::sizeof_len_record(size)
                ),
                |size| size + 2usize
            ) {
                if size > max_size {
                    max_size = size;
                }
            } else {
                break 'oneof (::core::option::Option::<usize>::None);
            }
            if let ::core::option::Option::Some(size) = ::micropb::const_map!(
                ::micropb::const_map!(
                    <Rpc_Req_WifiSetProtocol as ::micropb::MessageEncode>::MAX_SIZE,
                    |size| ::micropb::size::sizeof_len_record(size)
                ),
                |size| size + 2usize
            ) {
                if size > max_size {
                    max_size = size;
                }
            } else {
                break 'oneof (::core::option::Option::<usize>::None);
            }
            if let ::core::option::Option::Some(size) = ::micropb::const_map!(
                ::micropb::const_map!(
                    <Rpc_Req_WifiGetProtocol as ::micropb::MessageEncode>::MAX_SIZE,
                    |size| ::micropb::size::sizeof_len_record(size)
                ),
                |size| size + 2usize
            ) {
                if size > max_size {
                    max_size = size;
                }
            } else {
                break 'oneof (::core::option::Option::<usize>::None);
            }
            if let ::core::option::Option::Some(size) = ::micropb::const_map!(
                ::micropb::const_map!(
                    <Rpc_Req_WifiSetBandwidth as ::micropb::MessageEncode>::MAX_SIZE,
                    |size| ::micropb::size::sizeof_len_record(size)
                ),
                |size| size + 2usize
            ) {
                if size > max_size {
                    max_size = size;
                }
            } else {
                break 'oneof (::core::option::Option::<usize>::None);
            }
            if let ::core::option::Option::Some(size) = ::micropb::const_map!(
                ::micropb::const_map!(
                    <Rpc_Req_WifiGetBandwidth as ::micropb::MessageEncode>::MAX_SIZE,
                    |size| ::micropb::size::sizeof_len_record(size)
                ),
                |size| size + 2usize
            ) {
                if size > max_size {
                    max_size = size;
                }
            } else {
                break 'oneof (::core::option::Option::<usize>::None);
            }
            if let ::core::option::Option::Some(size) = ::micropb::const_map!(
                ::micropb::const_map!(
                    <Rpc_Req_WifiSetChannel as ::micropb::MessageEncode>::MAX_SIZE,
                    |size| ::micropb::size::sizeof_len_record(size)
                ),
                |size| size + 2usize
            ) {
                if size > max_size {
                    max_size = size;
                }
            } else {
                break 'oneof (::core::option::Option::<usize>::None);
            }
            if let ::core::option::Option::Some(size) = ::micropb::const_map!(
                ::micropb::const_map!(
                    <Rpc_Req_WifiGetChannel as ::micropb::MessageEncode>::MAX_SIZE,
                    |size| ::micropb::size::sizeof_len_record(size)
                ),
                |size| size + 2usize
            ) {
                if size > max_size {
                    max_size = size;
                }
            } else {
                break 'oneof (::core::option::Option::<usize>::None);
            }
            if let ::core::option::Option::Some(size) = ::micropb::const_map!(
                ::micropb::const_map!(
                    <Rpc_Req_WifiSetCountry as ::micropb::MessageEncode>::MAX_SIZE,
                    |size| ::micropb::size::sizeof_len_record(size)
                ),
                |size| size + 2usize
            ) {
                if size > max_size {
                    max_size = size;
                }
            } else {
                break 'oneof (::core::option::Option::<usize>::None);
            }
            if let ::core::option::Option::Some(size) = ::micropb::const_map!(
                ::micropb::const_map!(
                    <Rpc_Req_WifiGetCountry as ::micropb::MessageEncode>::MAX_SIZE,
                    |size| ::micropb::size::sizeof_len_record(size)
                ),
                |size| size + 2usize
            ) {
                if size > max_size {
                    max_size = size;
                }
            } else {
                break 'oneof (::core::option::Option::<usize>::None);
            }
            if let ::core::option::Option::Some(size) = ::micropb::const_map!(
                ::micropb::const_map!(
                    <Rpc_Req_WifiApGetStaList as ::micropb::MessageEncode>::MAX_SIZE,
                    |size| ::micropb::size::sizeof_len_record(size)
                ),
                |size| size + 2usize
            ) {
                if size > max_size {
                    max_size = size;
                }
            } else {
                break 'oneof (::core::option::Option::<usize>::None);
            }
            if let ::core::option::Option::Some(size) = ::micropb::const_map!(
                ::micropb::const_map!(
                    <Rpc_Req_WifiApGetStaAid as ::micropb::MessageEncode>::MAX_SIZE,
                    |size| ::micropb::size::sizeof_len_record(size)
                ),
                |size| size + 2usize
            ) {
                if size > max_size {
                    max_size = size;
                }
            } else {
                break 'oneof (::core::option::Option::<usize>::None);
            }
            if let ::core::option::Option::Some(size) = ::micropb::const_map!(
                ::micropb::const_map!(
                    <Rpc_Req_WifiSetStorage as ::micropb::MessageEncode>::MAX_SIZE,
                    |size| ::micropb::size::sizeof_len_record(size)
                ),
                |size| size + 2usize
            ) {
                if size > max_size {
                    max_size = size;
                }
            } else {
                break 'oneof (::core::option::Option::<usize>::None);
            }
            if let ::core::option::Option::Some(size) = ::micropb::const_map!(
                ::micropb::const_map!(
                    <Rpc_Req_WifiSetCountryCode as ::micropb::MessageEncode>::MAX_SIZE,
                    |size| ::micropb::size::sizeof_len_record(size)
                ),
                |size| size + 2usize
            ) {
                if size > max_size {
                    max_size = size;
                }
            } else {
                break 'oneof (::core::option::Option::<usize>::None);
            }
            if let ::core::option::Option::Some(size) = ::micropb::const_map!(
                ::micropb::const_map!(
                    <Rpc_Req_WifiGetCountryCode as ::micropb::MessageEncode>::MAX_SIZE,
                    |size| ::micropb::size::sizeof_len_record(size)
                ),
                |size| size + 2usize
            ) {
                if size > max_size {
                    max_size = size;
                }
            } else {
                break 'oneof (::core::option::Option::<usize>::None);
            }
            if let ::core::option::Option::Some(size) = ::micropb::const_map!(
                ::micropb::const_map!(
                    <Rpc_Req_WifiStaGetAid as ::micropb::MessageEncode>::MAX_SIZE,
                    |size| ::micropb::size::sizeof_len_record(size)
                ),
                |size| size + 2usize
            ) {
                if size > max_size {
                    max_size = size;
                }
            } else {
                break 'oneof (::core::option::Option::<usize>::None);
            }
            if let ::core::option::Option::Some(size) = ::micropb::const_map!(
                ::micropb::const_map!(
                    <Rpc_Req_WifiStaGetNegotiatedPhymode as ::micropb::MessageEncode>::MAX_SIZE,
                    |size| ::micropb::size::sizeof_len_record(size)
                ),
                |size| size + 2usize
            ) {
                if size > max_size {
                    max_size = size;
                }
            } else {
                break 'oneof (::core::option::Option::<usize>::None);
            }
            if let ::core::option::Option::Some(size) = ::micropb::const_map!(
                ::micropb::const_map!(
                    <Rpc_Req_WifiStaGetRssi as ::micropb::MessageEncode>::MAX_SIZE,
                    |size| ::micropb::size::sizeof_len_record(size)
                ),
                |size| size + 2usize
            ) {
                if size > max_size {
                    max_size = size;
                }
            } else {
                break 'oneof (::core::option::Option::<usize>::None);
            }
            if let ::core::option::Option::Some(size) = ::micropb::const_map!(
                ::micropb::const_map!(
                    <Rpc_Req_WifiSetProtocols as ::micropb::MessageEncode>::MAX_SIZE,
                    |size| ::micropb::size::sizeof_len_record(size)
                ),
                |size| size + 2usize
            ) {
                if size > max_size {
                    max_size = size;
                }
            } else {
                break 'oneof (::core::option::Option::<usize>::None);
            }
            if let ::core::option::Option::Some(size) = ::micropb::const_map!(
                ::micropb::const_map!(
                    <Rpc_Req_WifiGetProtocols as ::micropb::MessageEncode>::MAX_SIZE,
                    |size| ::micropb::size::sizeof_len_record(size)
                ),
                |size| size + 2usize
            ) {
                if size > max_size {
                    max_size = size;
                }
            } else {
                break 'oneof (::core::option::Option::<usize>::None);
            }
            if let ::core::option::Option::Some(size) = ::micropb::const_map!(
                ::micropb::const_map!(
                    <Rpc_Req_WifiSetBandwidths as ::micropb::MessageEncode>::MAX_SIZE,
                    |size| ::micropb::size::sizeof_len_record(size)
                ),
                |size| size + 2usize
            ) {
                if size > max_size {
                    max_size = size;
                }
            } else {
                break 'oneof (::core::option::Option::<usize>::None);
            }
            if let ::core::option::Option::Some(size) = ::micropb::const_map!(
                ::micropb::const_map!(
                    <Rpc_Req_WifiGetBandwidths as ::micropb::MessageEncode>::MAX_SIZE,
                    |size| ::micropb::size::sizeof_len_record(size)
                ),
                |size| size + 2usize
            ) {
                if size > max_size {
                    max_size = size;
                }
            } else {
                break 'oneof (::core::option::Option::<usize>::None);
            }
            if let ::core::option::Option::Some(size) = ::micropb::const_map!(
                ::micropb::const_map!(
                    <Rpc_Req_WifiSetBand as ::micropb::MessageEncode>::MAX_SIZE,
                    |size| ::micropb::size::sizeof_len_record(size)
                ),
                |size| size + 2usize
            ) {
                if size > max_size {
                    max_size = size;
                }
            } else {
                break 'oneof (::core::option::Option::<usize>::None);
            }
            if let ::core::option::Option::Some(size) = ::micropb::const_map!(
                ::micropb::const_map!(
                    <Rpc_Req_WifiGetBand as ::micropb::MessageEncode>::MAX_SIZE,
                    |size| ::micropb::size::sizeof_len_record(size)
                ),
                |size| size + 2usize
            ) {
                if size > max_size {
                    max_size = size;
                }
            } else {
                break 'oneof (::core::option::Option::<usize>::None);
            }
            if let ::core::option::Option::Some(size) = ::micropb::const_map!(
                ::micropb::const_map!(
                    <Rpc_Req_WifiSetBandMode as ::micropb::MessageEncode>::MAX_SIZE,
                    |size| ::micropb::size::sizeof_len_record(size)
                ),
                |size| size + 2usize
            ) {
                if size > max_size {
                    max_size = size;
                }
            } else {
                break 'oneof (::core::option::Option::<usize>::None);
            }
            if let ::core::option::Option::Some(size) = ::micropb::const_map!(
                ::micropb::const_map!(
                    <Rpc_Req_WifiGetBandMode as ::micropb::MessageEncode>::MAX_SIZE,
                    |size| ::micropb::size::sizeof_len_record(size)
                ),
                |size| size + 2usize
            ) {
                if size > max_size {
                    max_size = size;
                }
            } else {
                break 'oneof (::core::option::Option::<usize>::None);
            }
            if let ::core::option::Option::Some(size) = ::micropb::const_map!(
                ::micropb::const_map!(
                    <Rpc_Req_GetCoprocessorFwVersion as ::micropb::MessageEncode>::MAX_SIZE,
                    |size| ::micropb::size::sizeof_len_record(size)
                ),
                |size| size + 2usize
            ) {
                if size > max_size {
                    max_size = size;
                }
            } else {
                break 'oneof (::core::option::Option::<usize>::None);
            }
            if let ::core::option::Option::Some(size) = ::micropb::const_map!(
                ::micropb::const_map!(
                    <Rpc_Req_WifiScanGetApRecord as ::micropb::MessageEncode>::MAX_SIZE,
                    |size| ::micropb::size::sizeof_len_record(size)
                ),
                |size| size + 2usize
            ) {
                if size > max_size {
                    max_size = size;
                }
            } else {
                break 'oneof (::core::option::Option::<usize>::None);
            }
            if let ::core::option::Option::Some(size) = ::micropb::const_map!(
                ::micropb::const_map!(
                    <Rpc_Resp_GetMacAddress as ::micropb::MessageEncode>::MAX_SIZE,
                    |size| ::micropb::size::sizeof_len_record(size)
                ),
                |size| size + 2usize
            ) {
                if size > max_size {
                    max_size = size;
                }
            } else {
                break 'oneof (::core::option::Option::<usize>::None);
            }
            if let ::core::option::Option::Some(size) = ::micropb::const_map!(
                ::micropb::const_map!(
                    <Rpc_Resp_SetMacAddress as ::micropb::MessageEncode>::MAX_SIZE,
                    |size| ::micropb::size::sizeof_len_record(size)
                ),
                |size| size + 2usize
            ) {
                if size > max_size {
                    max_size = size;
                }
            } else {
                break 'oneof (::core::option::Option::<usize>::None);
            }
            if let ::core::option::Option::Some(size) = ::micropb::const_map!(
                ::micropb::const_map!(
                    <Rpc_Resp_GetMode as ::micropb::MessageEncode>::MAX_SIZE,
                    |size| ::micropb::size::sizeof_len_record(size)
                ),
                |size| size + 2usize
            ) {
                if size > max_size {
                    max_size = size;
                }
            } else {
                break 'oneof (::core::option::Option::<usize>::None);
            }
            if let ::core::option::Option::Some(size) = ::micropb::const_map!(
                ::micropb::const_map!(
                    <Rpc_Resp_SetMode as ::micropb::MessageEncode>::MAX_SIZE,
                    |size| ::micropb::size::sizeof_len_record(size)
                ),
                |size| size + 2usize
            ) {
                if size > max_size {
                    max_size = size;
                }
            } else {
                break 'oneof (::core::option::Option::<usize>::None);
            }
            if let ::core::option::Option::Some(size) = ::micropb::const_map!(
                ::micropb::const_map!(
                    <Rpc_Resp_SetPs as ::micropb::MessageEncode>::MAX_SIZE,
                    |size| ::micropb::size::sizeof_len_record(size)
                ),
                |size| size + 2usize
            ) {
                if size > max_size {
                    max_size = size;
                }
            } else {
                break 'oneof (::core::option::Option::<usize>::None);
            }
            if let ::core::option::Option::Some(size) = ::micropb::const_map!(
                ::micropb::const_map!(
                    <Rpc_Resp_GetPs as ::micropb::MessageEncode>::MAX_SIZE,
                    |size| ::micropb::size::sizeof_len_record(size)
                ),
                |size| size + 2usize
            ) {
                if size > max_size {
                    max_size = size;
                }
            } else {
                break 'oneof (::core::option::Option::<usize>::None);
            }
            if let ::core::option::Option::Some(size) = ::micropb::const_map!(
                ::micropb::const_map!(
                    <Rpc_Resp_OTABegin as ::micropb::MessageEncode>::MAX_SIZE,
                    |size| ::micropb::size::sizeof_len_record(size)
                ),
                |size| size + 2usize
            ) {
                if size > max_size {
                    max_size = size;
                }
            } else {
                break 'oneof (::core::option::Option::<usize>::None);
            }
            if let ::core::option::Option::Some(size) = ::micropb::const_map!(
                ::micropb::const_map!(
                    <Rpc_Resp_OTAWrite as ::micropb::MessageEncode>::MAX_SIZE,
                    |size| ::micropb::size::sizeof_len_record(size)
                ),
                |size| size + 2usize
            ) {
                if size > max_size {
                    max_size = size;
                }
            } else {
                break 'oneof (::core::option::Option::<usize>::None);
            }
            if let ::core::option::Option::Some(size) = ::micropb::const_map!(
                ::micropb::const_map!(
                    <Rpc_Resp_OTAEnd as ::micropb::MessageEncode>::MAX_SIZE,
                    |size| ::micropb::size::sizeof_len_record(size)
                ),
                |size| size + 2usize
            ) {
                if size > max_size {
                    max_size = size;
                }
            } else {
                break 'oneof (::core::option::Option::<usize>::None);
            }
            if let ::core::option::Option::Some(size) = ::micropb::const_map!(
                ::micropb::const_map!(
                    <Rpc_Resp_WifiSetMaxTxPower as ::micropb::MessageEncode>::MAX_SIZE,
                    |size| ::micropb::size::sizeof_len_record(size)
                ),
                |size| size + 2usize
            ) {
                if size > max_size {
                    max_size = size;
                }
            } else {
                break 'oneof (::core::option::Option::<usize>::None);
            }
            if let ::core::option::Option::Some(size) = ::micropb::const_map!(
                ::micropb::const_map!(
                    <Rpc_Resp_WifiGetMaxTxPower as ::micropb::MessageEncode>::MAX_SIZE,
                    |size| ::micropb::size::sizeof_len_record(size)
                ),
                |size| size + 2usize
            ) {
                if size > max_size {
                    max_size = size;
                }
            } else {
                break 'oneof (::core::option::Option::<usize>::None);
            }
            if let ::core::option::Option::Some(size) = ::micropb::const_map!(
                ::micropb::const_map!(
                    <Rpc_Resp_ConfigHeartbeat as ::micropb::MessageEncode>::MAX_SIZE,
                    |size| ::micropb::size::sizeof_len_record(size)
                ),
                |size| size + 2usize
            ) {
                if size > max_size {
                    max_size = size;
                }
            } else {
                break 'oneof (::core::option::Option::<usize>::None);
            }
            if let ::core::option::Option::Some(size) = ::micropb::const_map!(
                ::micropb::const_map!(
                    <Rpc_Resp_WifiInit as ::micropb::MessageEncode>::MAX_SIZE,
                    |size| ::micropb::size::sizeof_len_record(size)
                ),
                |size| size + 2usize
            ) {
                if size > max_size {
                    max_size = size;
                }
            } else {
                break 'oneof (::core::option::Option::<usize>::None);
            }
            if let ::core::option::Option::Some(size) = ::micropb::const_map!(
                ::micropb::const_map!(
                    <Rpc_Resp_WifiDeinit as ::micropb::MessageEncode>::MAX_SIZE,
                    |size| ::micropb::size::sizeof_len_record(size)
                ),
                |size| size + 2usize
            ) {
                if size > max_size {
                    max_size = size;
                }
            } else {
                break 'oneof (::core::option::Option::<usize>::None);
            }
            if let ::core::option::Option::Some(size) = ::micropb::const_map!(
                ::micropb::const_map!(
                    <Rpc_Resp_WifiStart as ::micropb::MessageEncode>::MAX_SIZE,
                    |size| ::micropb::size::sizeof_len_record(size)
                ),
                |size| size + 2usize
            ) {
                if size > max_size {
                    max_size = size;
                }
            } else {
                break 'oneof (::core::option::Option::<usize>::None);
            }
            if let ::core::option::Option::Some(size) = ::micropb::const_map!(
                ::micropb::const_map!(
                    <Rpc_Resp_WifiStop as ::micropb::MessageEncode>::MAX_SIZE,
                    |size| ::micropb::size::sizeof_len_record(size)
                ),
                |size| size + 2usize
            ) {
                if size > max_size {
                    max_size = size;
                }
            } else {
                break 'oneof (::core::option::Option::<usize>::None);
            }
            if let ::core::option::Option::Some(size) = ::micropb::const_map!(
                ::micropb::const_map!(
                    <Rpc_Resp_WifiConnect as ::micropb::MessageEncode>::MAX_SIZE,
                    |size| ::micropb::size::sizeof_len_record(size)
                ),
                |size| size + 2usize
            ) {
                if size > max_size {
                    max_size = size;
                }
            } else {
                break 'oneof (::core::option::Option::<usize>::None);
            }
            if let ::core::option::Option::Some(size) = ::micropb::const_map!(
                ::micropb::const_map!(
                    <Rpc_Resp_WifiDisconnect as ::micropb::MessageEncode>::MAX_SIZE,
                    |size| ::micropb::size::sizeof_len_record(size)
                ),
                |size| size + 2usize
            ) {
                if size > max_size {
                    max_size = size;
                }
            } else {
                break 'oneof (::core::option::Option::<usize>::None);
            }
            if let ::core::option::Option::Some(size) = ::micropb::const_map!(
                ::micropb::const_map!(
                    <Rpc_Resp_WifiSetConfig as ::micropb::MessageEncode>::MAX_SIZE,
                    |size| ::micropb::size::sizeof_len_record(size)
                ),
                |size| size + 2usize
            ) {
                if size > max_size {
                    max_size = size;
                }
            } else {
                break 'oneof (::core::option::Option::<usize>::None);
            }
            if let ::core::option::Option::Some(size) = ::micropb::const_map!(
                ::micropb::const_map!(
                    <Rpc_Resp_WifiGetConfig as ::micropb::MessageEncode>::MAX_SIZE,
                    |size| ::micropb::size::sizeof_len_record(size)
                ),
                |size| size + 2usize
            ) {
                if size > max_size {
                    max_size = size;
                }
            } else {
                break 'oneof (::core::option::Option::<usize>::None);
            }
            if let ::core::option::Option::Some(size) = ::micropb::const_map!(
                ::micropb::const_map!(
                    <Rpc_Resp_WifiScanStart as ::micropb::MessageEncode>::MAX_SIZE,
                    |size| ::micropb::size::sizeof_len_record(size)
                ),
                |size| size + 2usize
            ) {
                if size > max_size {
                    max_size = size;
                }
            } else {
                break 'oneof (::core::option::Option::<usize>::None);
            }
            if let ::core::option::Option::Some(size) = ::micropb::const_map!(
                ::micropb::const_map!(
                    <Rpc_Resp_WifiScanStop as ::micropb::MessageEncode>::MAX_SIZE,
                    |size| ::micropb::size::sizeof_len_record(size)
                ),
                |size| size + 2usize
            ) {
                if size > max_size {
                    max_size = size;
                }
            } else {
                break 'oneof (::core::option::Option::<usize>::None);
            }
            if let ::core::option::Option::Some(size) = ::micropb::const_map!(
                ::micropb::const_map!(
                    <Rpc_Resp_WifiScanGetApNum as ::micropb::MessageEncode>::MAX_SIZE,
                    |size| ::micropb::size::sizeof_len_record(size)
                ),
                |size| size + 2usize
            ) {
                if size > max_size {
                    max_size = size;
                }
            } else {
                break 'oneof (::core::option::Option::<usize>::None);
            }
            if let ::core::option::Option::Some(size) = ::micropb::const_map!(
                ::micropb::const_map!(
                    <Rpc_Resp_WifiScanGetApRecords as ::micropb::MessageEncode>::MAX_SIZE,
                    |size| ::micropb::size::sizeof_len_record(size)
                ),
                |size| size + 2usize
            ) {
                if size > max_size {
                    max_size = size;
                }
            } else {
                break 'oneof (::core::option::Option::<usize>::None);
            }
            if let ::core::option::Option::Some(size) = ::micropb::const_map!(
                ::micropb::const_map!(
                    <Rpc_Resp_WifiClearApList as ::micropb::MessageEncode>::MAX_SIZE,
                    |size| ::micropb::size::sizeof_len_record(size)
                ),
                |size| size + 2usize
            ) {
                if size > max_size {
                    max_size = size;
                }
            } else {
                break 'oneof (::core::option::Option::<usize>::None);
            }
            if let ::core::option::Option::Some(size) = ::micropb::const_map!(
                ::micropb::const_map!(
                    <Rpc_Resp_WifiRestore as ::micropb::MessageEncode>::MAX_SIZE,
                    |size| ::micropb::size::sizeof_len_record(size)
                ),
                |size| size + 2usize
            ) {
                if size > max_size {
                    max_size = size;
                }
            } else {
                break 'oneof (::core::option::Option::<usize>::None);
            }
            if let ::core::option::Option::Some(size) = ::micropb::const_map!(
                ::micropb::const_map!(
                    <Rpc_Resp_WifiClearFastConnect as ::micropb::MessageEncode>::MAX_SIZE,
                    |size| ::micropb::size::sizeof_len_record(size)
                ),
                |size| size + 2usize
            ) {
                if size > max_size {
                    max_size = size;
                }
            } else {
                break 'oneof (::core::option::Option::<usize>::None);
            }
            if let ::core::option::Option::Some(size) = ::micropb::const_map!(
                ::micropb::const_map!(
                    <Rpc_Resp_WifiDeauthSta as ::micropb::MessageEncode>::MAX_SIZE,
                    |size| ::micropb::size::sizeof_len_record(size)
                ),
                |size| size + 2usize
            ) {
                if size > max_size {
                    max_size = size;
                }
            } else {
                break 'oneof (::core::option::Option::<usize>::None);
            }
            if let ::core::option::Option::Some(size) = ::micropb::const_map!(
                ::micropb::const_map!(
                    <Rpc_Resp_WifiStaGetApInfo as ::micropb::MessageEncode>::MAX_SIZE,
                    |size| ::micropb::size::sizeof_len_record(size)
                ),
                |size| size + 2usize
            ) {
                if size > max_size {
                    max_size = size;
                }
            } else {
                break 'oneof (::core::option::Option::<usize>::None);
            }
            if let ::core::option::Option::Some(size) = ::micropb::const_map!(
                ::micropb::const_map!(
                    <Rpc_Resp_WifiSetProtocol as ::micropb::MessageEncode>::MAX_SIZE,
                    |size| ::micropb::size::sizeof_len_record(size)
                ),
                |size| size + 2usize
            ) {
                if size > max_size {
                    max_size = size;
                }
            } else {
                break 'oneof (::core::option::Option::<usize>::None);
            }
            if let ::core::option::Option::Some(size) = ::micropb::const_map!(
                ::micropb::const_map!(
                    <Rpc_Resp_WifiGetProtocol as ::micropb::MessageEncode>::MAX_SIZE,
                    |size| ::micropb::size::sizeof_len_record(size)
                ),
                |size| size + 2usize
            ) {
                if size > max_size {
                    max_size = size;
                }
            } else {
                break 'oneof (::core::option::Option::<usize>::None);
            }
            if let ::core::option::Option::Some(size) = ::micropb::const_map!(
                ::micropb::const_map!(
                    <Rpc_Resp_WifiSetBandwidth as ::micropb::MessageEncode>::MAX_SIZE,
                    |size| ::micropb::size::sizeof_len_record(size)
                ),
                |size| size + 2usize
            ) {
                if size > max_size {
                    max_size = size;
                }
            } else {
                break 'oneof (::core::option::Option::<usize>::None);
            }
            if let ::core::option::Option::Some(size) = ::micropb::const_map!(
                ::micropb::const_map!(
                    <Rpc_Resp_WifiGetBandwidth as ::micropb::MessageEncode>::MAX_SIZE,
                    |size| ::micropb::size::sizeof_len_record(size)
                ),
                |size| size + 2usize
            ) {
                if size > max_size {
                    max_size = size;
                }
            } else {
                break 'oneof (::core::option::Option::<usize>::None);
            }
            if let ::core::option::Option::Some(size) = ::micropb::const_map!(
                ::micropb::const_map!(
                    <Rpc_Resp_WifiSetChannel as ::micropb::MessageEncode>::MAX_SIZE,
                    |size| ::micropb::size::sizeof_len_record(size)
                ),
                |size| size + 2usize
            ) {
                if size > max_size {
                    max_size = size;
                }
            } else {
                break 'oneof (::core::option::Option::<usize>::None);
            }
            if let ::core::option::Option::Some(size) = ::micropb::const_map!(
                ::micropb::const_map!(
                    <Rpc_Resp_WifiGetChannel as ::micropb::MessageEncode>::MAX_SIZE,
                    |size| ::micropb::size::sizeof_len_record(size)
                ),
                |size| size + 2usize
            ) {
                if size > max_size {
                    max_size = size;
                }
            } else {
                break 'oneof (::core::option::Option::<usize>::None);
            }
            if let ::core::option::Option::Some(size) = ::micropb::const_map!(
                ::micropb::const_map!(
                    <Rpc_Resp_WifiSetCountry as ::micropb::MessageEncode>::MAX_SIZE,
                    |size| ::micropb::size::sizeof_len_record(size)
                ),
                |size| size + 2usize
            ) {
                if size > max_size {
                    max_size = size;
                }
            } else {
                break 'oneof (::core::option::Option::<usize>::None);
            }
            if let ::core::option::Option::Some(size) = ::micropb::const_map!(
                ::micropb::const_map!(
                    <Rpc_Resp_WifiGetCountry as ::micropb::MessageEncode>::MAX_SIZE,
                    |size| ::micropb::size::sizeof_len_record(size)
                ),
                |size| size + 2usize
            ) {
                if size > max_size {
                    max_size = size;
                }
            } else {
                break 'oneof (::core::option::Option::<usize>::None);
            }
            if let ::core::option::Option::Some(size) = ::micropb::const_map!(
                ::micropb::const_map!(
                    <Rpc_Resp_WifiApGetStaList as ::micropb::MessageEncode>::MAX_SIZE,
                    |size| ::micropb::size::sizeof_len_record(size)
                ),
                |size| size + 2usize
            ) {
                if size > max_size {
                    max_size = size;
                }
            } else {
                break 'oneof (::core::option::Option::<usize>::None);
            }
            if let ::core::option::Option::Some(size) = ::micropb::const_map!(
                ::micropb::const_map!(
                    <Rpc_Resp_WifiApGetStaAid as ::micropb::MessageEncode>::MAX_SIZE,
                    |size| ::micropb::size::sizeof_len_record(size)
                ),
                |size| size + 2usize
            ) {
                if size > max_size {
                    max_size = size;
                }
            } else {
                break 'oneof (::core::option::Option::<usize>::None);
            }
            if let ::core::option::Option::Some(size) = ::micropb::const_map!(
                ::micropb::const_map!(
                    <Rpc_Resp_WifiSetStorage as ::micropb::MessageEncode>::MAX_SIZE,
                    |size| ::micropb::size::sizeof_len_record(size)
                ),
                |size| size + 2usize
            ) {
                if size > max_size {
                    max_size = size;
                }
            } else {
                break 'oneof (::core::option::Option::<usize>::None);
            }
            if let ::core::option::Option::Some(size) = ::micropb::const_map!(
                ::micropb::const_map!(
                    <Rpc_Resp_WifiSetCountryCode as ::micropb::MessageEncode>::MAX_SIZE,
                    |size| ::micropb::size::sizeof_len_record(size)
                ),
                |size| size + 2usize
            ) {
                if size > max_size {
                    max_size = size;
                }
            } else {
                break 'oneof (::core::option::Option::<usize>::None);
            }
            if let ::core::option::Option::Some(size) = ::micropb::const_map!(
                ::micropb::const_map!(
                    <Rpc_Resp_WifiGetCountryCode as ::micropb::MessageEncode>::MAX_SIZE,
                    |size| ::micropb::size::sizeof_len_record(size)
                ),
                |size| size + 2usize
            ) {
                if size > max_size {
                    max_size = size;
                }
            } else {
                break 'oneof (::core::option::Option::<usize>::None);
            }
            if let ::core::option::Option::Some(size) = ::micropb::const_map!(
                ::micropb::const_map!(
                    <Rpc_Resp_WifiStaGetAid as ::micropb::MessageEncode>::MAX_SIZE,
                    |size| ::micropb::size::sizeof_len_record(size)
                ),
                |size| size + 2usize
            ) {
                if size > max_size {
                    max_size = size;
                }
            } else {
                break 'oneof (::core::option::Option::<usize>::None);
            }
            if let ::core::option::Option::Some(size) = ::micropb::const_map!(
                ::micropb::const_map!(
                    <Rpc_Resp_WifiStaGetNegotiatedPhymode as ::micropb::MessageEncode>::MAX_SIZE,
                    |size| ::micropb::size::sizeof_len_record(size)
                ),
                |size| size + 2usize
            ) {
                if size > max_size {
                    max_size = size;
                }
            } else {
                break 'oneof (::core::option::Option::<usize>::None);
            }
            if let ::core::option::Option::Some(size) = ::micropb::const_map!(
                ::micropb::const_map!(
                    <Rpc_Resp_WifiStaGetRssi as ::micropb::MessageEncode>::MAX_SIZE,
                    |size| ::micropb::size::sizeof_len_record(size)
                ),
                |size| size + 2usize
            ) {
                if size > max_size {
                    max_size = size;
                }
            } else {
                break 'oneof (::core::option::Option::<usize>::None);
            }
            if let ::core::option::Option::Some(size) = ::micropb::const_map!(
                ::micropb::const_map!(
                    <Rpc_Resp_WifiSetProtocols as ::micropb::MessageEncode>::MAX_SIZE,
                    |size| ::micropb::size::sizeof_len_record(size)
                ),
                |size| size + 2usize
            ) {
                if size > max_size {
                    max_size = size;
                }
            } else {
                break 'oneof (::core::option::Option::<usize>::None);
            }
            if let ::core::option::Option::Some(size) = ::micropb::const_map!(
                ::micropb::const_map!(
                    <Rpc_Resp_WifiGetProtocols as ::micropb::MessageEncode>::MAX_SIZE,
                    |size| ::micropb::size::sizeof_len_record(size)
                ),
                |size| size + 2usize
            ) {
                if size > max_size {
                    max_size = size;
                }
            } else {
                break 'oneof (::core::option::Option::<usize>::None);
            }
            if let ::core::option::Option::Some(size) = ::micropb::const_map!(
                ::micropb::const_map!(
                    <Rpc_Resp_WifiSetBandwidths as ::micropb::MessageEncode>::MAX_SIZE,
                    |size| ::micropb::size::sizeof_len_record(size)
                ),
                |size| size + 2usize
            ) {
                if size > max_size {
                    max_size = size;
                }
            } else {
                break 'oneof (::core::option::Option::<usize>::None);
            }
            if let ::core::option::Option::Some(size) = ::micropb::const_map!(
                ::micropb::const_map!(
                    <Rpc_Resp_WifiGetBandwidths as ::micropb::MessageEncode>::MAX_SIZE,
                    |size| ::micropb::size::sizeof_len_record(size)
                ),
                |size| size + 2usize
            ) {
                if size > max_size {
                    max_size = size;
                }
            } else {
                break 'oneof (::core::option::Option::<usize>::None);
            }
            if let ::core::option::Option::Some(size) = ::micropb::const_map!(
                ::micropb::const_map!(
                    <Rpc_Resp_WifiSetBand as ::micropb::MessageEncode>::MAX_SIZE,
                    |size| ::micropb::size::sizeof_len_record(size)
                ),
                |size| size + 2usize
            ) {
                if size > max_size {
                    max_size = size;
                }
            } else {
                break 'oneof (::core::option::Option::<usize>::None);
            }
            if let ::core::option::Option::Some(size) = ::micropb::const_map!(
                ::micropb::const_map!(
                    <Rpc_Resp_WifiGetBand as ::micropb::MessageEncode>::MAX_SIZE,
                    |size| ::micropb::size::sizeof_len_record(size)
                ),
                |size| size + 2usize
            ) {
                if size > max_size {
                    max_size = size;
                }
            } else {
                break 'oneof (::core::option::Option::<usize>::None);
            }
            if let ::core::option::Option::Some(size) = ::micropb::const_map!(
                ::micropb::const_map!(
                    <Rpc_Resp_WifiSetBandMode as ::micropb::MessageEncode>::MAX_SIZE,
                    |size| ::micropb::size::sizeof_len_record(size)
                ),
                |size| size + 2usize
            ) {
                if size > max_size {
                    max_size = size;
                }
            } else {
                break 'oneof (::core::option::Option::<usize>::None);
            }
            if let ::core::option::Option::Some(size) = ::micropb::const_map!(
                ::micropb::const_map!(
                    <Rpc_Resp_WifiGetBandMode as ::micropb::MessageEncode>::MAX_SIZE,
                    |size| ::micropb::size::sizeof_len_record(size)
                ),
                |size| size + 2usize
            ) {
                if size > max_size {
                    max_size = size;
                }
            } else {
                break 'oneof (::core::option::Option::<usize>::None);
            }
            if let ::core::option::Option::Some(size) = ::micropb::const_map!(
                ::micropb::const_map!(
                    <Rpc_Resp_GetCoprocessorFwVersion as ::micropb::MessageEncode>::MAX_SIZE,
                    |size| ::micropb::size::sizeof_len_record(size)
                ),
                |size| size + 2usize
            ) {
                if size > max_size {
                    max_size = size;
                }
            } else {
                break 'oneof (::core::option::Option::<usize>::None);
            }
            if let ::core::option::Option::Some(size) = ::micropb::const_map!(
                ::micropb::const_map!(
                    <Rpc_Resp_WifiScanGetApRecord as ::micropb::MessageEncode>::MAX_SIZE,
                    |size| ::micropb::size::sizeof_len_record(size)
                ),
                |size| size + 2usize
            ) {
                if size > max_size {
                    max_size = size;
                }
            } else {
                break 'oneof (::core::option::Option::<usize>::None);
            }
            if let ::core::option::Option::Some(size) = ::micropb::const_map!(
                ::micropb::const_map!(
                    <Rpc_Event_ESPInit as ::micropb::MessageEncode>::MAX_SIZE,
                    |size| ::micropb::size::sizeof_len_record(size)
                ),
                |size| size + 2usize
            ) {
                if size > max_size {
                    max_size = size;
                }
            } else {
                break 'oneof (::core::option::Option::<usize>::None);
            }
            if let ::core::option::Option::Some(size) = ::micropb::const_map!(
                ::micropb::const_map!(
                    <Rpc_Event_Heartbeat as ::micropb::MessageEncode>::MAX_SIZE,
                    |size| ::micropb::size::sizeof_len_record(size)
                ),
                |size| size + 2usize
            ) {
                if size > max_size {
                    max_size = size;
                }
            } else {
                break 'oneof (::core::option::Option::<usize>::None);
            }
            if let ::core::option::Option::Some(size) = ::micropb::const_map!(
                ::micropb::const_map!(
                    <Rpc_Event_AP_StaConnected as ::micropb::MessageEncode>::MAX_SIZE,
                    |size| ::micropb::size::sizeof_len_record(size)
                ),
                |size| size + 2usize
            ) {
                if size > max_size {
                    max_size = size;
                }
            } else {
                break 'oneof (::core::option::Option::<usize>::None);
            }
            if let ::core::option::Option::Some(size) = ::micropb::const_map!(
                ::micropb::const_map!(
                    <Rpc_Event_AP_StaDisconnected as ::micropb::MessageEncode>::MAX_SIZE,
                    |size| ::micropb::size::sizeof_len_record(size)
                ),
                |size| size + 2usize
            ) {
                if size > max_size {
                    max_size = size;
                }
            } else {
                break 'oneof (::core::option::Option::<usize>::None);
            }
            if let ::core::option::Option::Some(size) = ::micropb::const_map!(
                ::micropb::const_map!(
                    <Rpc_Event_WifiEventNoArgs as ::micropb::MessageEncode>::MAX_SIZE,
                    |size| ::micropb::size::sizeof_len_record(size)
                ),
                |size| size + 2usize
            ) {
                if size > max_size {
                    max_size = size;
                }
            } else {
                break 'oneof (::core::option::Option::<usize>::None);
            }
            if let ::core::option::Option::Some(size) = ::micropb::const_map!(
                ::micropb::const_map!(
                    <Rpc_Event_StaScanDone as ::micropb::MessageEncode>::MAX_SIZE,
                    |size| ::micropb::size::sizeof_len_record(size)
                ),
                |size| size + 2usize
            ) {
                if size > max_size {
                    max_size = size;
                }
            } else {
                break 'oneof (::core::option::Option::<usize>::None);
            }
            if let ::core::option::Option::Some(size) = ::micropb::const_map!(
                ::micropb::const_map!(
                    <Rpc_Event_StaConnected as ::micropb::MessageEncode>::MAX_SIZE,
                    |size| ::micropb::size::sizeof_len_record(size)
                ),
                |size| size + 2usize
            ) {
                if size > max_size {
                    max_size = size;
                }
            } else {
                break 'oneof (::core::option::Option::<usize>::None);
            }
            if let ::core::option::Option::Some(size) = ::micropb::const_map!(
                ::micropb::const_map!(
                    <Rpc_Event_StaDisconnected as ::micropb::MessageEncode>::MAX_SIZE,
                    |size| ::micropb::size::sizeof_len_record(size)
                ),
                |size| size + 2usize
            ) {
                if size > max_size {
                    max_size = size;
                }
            } else {
                break 'oneof (::core::option::Option::<usize>::None);
            }
            ::core::option::Option::Some(max_size)
        } {
            max_size += size;
        } else {
            break 'msg (::core::option::Option::<usize>::None);
        };
        ::core::option::Option::Some(max_size)
    };
    fn encode<IMPL_MICROPB_WRITE: ::micropb::PbWrite>(
        &self,
        encoder: &mut ::micropb::PbEncoder<IMPL_MICROPB_WRITE>,
    ) -> Result<(), IMPL_MICROPB_WRITE::Error> {
        use ::micropb::{FieldEncode, PbMap};
        {
            let val_ref = &self.r#msg_type;
            if val_ref.0 != 0 {
                encoder.encode_varint32(8u32)?;
                encoder.encode_int32(val_ref.0 as _)?;
            }
        }
        {
            let val_ref = &self.r#msg_id;
            if val_ref.0 != 0 {
                encoder.encode_varint32(16u32)?;
                encoder.encode_int32(val_ref.0 as _)?;
            }
        }
        {
            let val_ref = &self.r#uid;
            if *val_ref != 0 {
                encoder.encode_varint32(24u32)?;
                encoder.encode_varint32(*val_ref as _)?;
            }
        }
        if let Some(oneof) = &self.r#payload {
            match &*oneof {
                Rpc_::Payload::ReqGetMacAddress(val_ref) => {
                    let val_ref = &*val_ref;
                    encoder.encode_varint32(2058u32)?;
                    val_ref.encode_len_delimited(encoder)?;
                }
                Rpc_::Payload::ReqSetMacAddress(val_ref) => {
                    let val_ref = &*val_ref;
                    encoder.encode_varint32(2066u32)?;
                    val_ref.encode_len_delimited(encoder)?;
                }
                Rpc_::Payload::ReqGetWifiMode(val_ref) => {
                    let val_ref = &*val_ref;
                    encoder.encode_varint32(2074u32)?;
                    val_ref.encode_len_delimited(encoder)?;
                }
                Rpc_::Payload::ReqSetWifiMode(val_ref) => {
                    let val_ref = &*val_ref;
                    encoder.encode_varint32(2082u32)?;
                    val_ref.encode_len_delimited(encoder)?;
                }
                Rpc_::Payload::ReqWifiSetPs(val_ref) => {
                    let val_ref = &*val_ref;
                    encoder.encode_varint32(2162u32)?;
                    val_ref.encode_len_delimited(encoder)?;
                }
                Rpc_::Payload::ReqWifiGetPs(val_ref) => {
                    let val_ref = &*val_ref;
                    encoder.encode_varint32(2170u32)?;
                    val_ref.encode_len_delimited(encoder)?;
                }
                Rpc_::Payload::ReqOtaBegin(val_ref) => {
                    let val_ref = &*val_ref;
                    encoder.encode_varint32(2178u32)?;
                    val_ref.encode_len_delimited(encoder)?;
                }
                Rpc_::Payload::ReqOtaWrite(val_ref) => {
                    let val_ref = &*val_ref;
                    encoder.encode_varint32(2186u32)?;
                    val_ref.encode_len_delimited(encoder)?;
                }
                Rpc_::Payload::ReqOtaEnd(val_ref) => {
                    let val_ref = &*val_ref;
                    encoder.encode_varint32(2194u32)?;
                    val_ref.encode_len_delimited(encoder)?;
                }
                Rpc_::Payload::ReqSetWifiMaxTxPower(val_ref) => {
                    let val_ref = &*val_ref;
                    encoder.encode_varint32(2202u32)?;
                    val_ref.encode_len_delimited(encoder)?;
                }
                Rpc_::Payload::ReqGetWifiMaxTxPower(val_ref) => {
                    let val_ref = &*val_ref;
                    encoder.encode_varint32(2210u32)?;
                    val_ref.encode_len_delimited(encoder)?;
                }
                Rpc_::Payload::ReqConfigHeartbeat(val_ref) => {
                    let val_ref = &*val_ref;
                    encoder.encode_varint32(2218u32)?;
                    val_ref.encode_len_delimited(encoder)?;
                }
                Rpc_::Payload::ReqWifiInit(val_ref) => {
                    let val_ref = &*val_ref;
                    encoder.encode_varint32(2226u32)?;
                    val_ref.encode_len_delimited(encoder)?;
                }
                Rpc_::Payload::ReqWifiDeinit(val_ref) => {
                    let val_ref = &*val_ref;
                    encoder.encode_varint32(2234u32)?;
                    val_ref.encode_len_delimited(encoder)?;
                }
                Rpc_::Payload::ReqWifiStart(val_ref) => {
                    let val_ref = &*val_ref;
                    encoder.encode_varint32(2242u32)?;
                    val_ref.encode_len_delimited(encoder)?;
                }
                Rpc_::Payload::ReqWifiStop(val_ref) => {
                    let val_ref = &*val_ref;
                    encoder.encode_varint32(2250u32)?;
                    val_ref.encode_len_delimited(encoder)?;
                }
                Rpc_::Payload::ReqWifiConnect(val_ref) => {
                    let val_ref = &*val_ref;
                    encoder.encode_varint32(2258u32)?;
                    val_ref.encode_len_delimited(encoder)?;
                }
                Rpc_::Payload::ReqWifiDisconnect(val_ref) => {
                    let val_ref = &*val_ref;
                    encoder.encode_varint32(2266u32)?;
                    val_ref.encode_len_delimited(encoder)?;
                }
                Rpc_::Payload::ReqWifiSetConfig(val_ref) => {
                    let val_ref = &*val_ref;
                    encoder.encode_varint32(2274u32)?;
                    val_ref.encode_len_delimited(encoder)?;
                }
                Rpc_::Payload::ReqWifiGetConfig(val_ref) => {
                    let val_ref = &*val_ref;
                    encoder.encode_varint32(2282u32)?;
                    val_ref.encode_len_delimited(encoder)?;
                }
                Rpc_::Payload::ReqWifiScanStart(val_ref) => {
                    let val_ref = &*val_ref;
                    encoder.encode_varint32(2290u32)?;
                    val_ref.encode_len_delimited(encoder)?;
                }
                Rpc_::Payload::ReqWifiScanStop(val_ref) => {
                    let val_ref = &*val_ref;
                    encoder.encode_varint32(2298u32)?;
                    val_ref.encode_len_delimited(encoder)?;
                }
                Rpc_::Payload::ReqWifiScanGetApNum(val_ref) => {
                    let val_ref = &*val_ref;
                    encoder.encode_varint32(2306u32)?;
                    val_ref.encode_len_delimited(encoder)?;
                }
                Rpc_::Payload::ReqWifiScanGetApRecords(val_ref) => {
                    let val_ref = &*val_ref;
                    encoder.encode_varint32(2314u32)?;
                    val_ref.encode_len_delimited(encoder)?;
                }
                Rpc_::Payload::ReqWifiClearApList(val_ref) => {
                    let val_ref = &*val_ref;
                    encoder.encode_varint32(2322u32)?;
                    val_ref.encode_len_delimited(encoder)?;
                }
                Rpc_::Payload::ReqWifiRestore(val_ref) => {
                    let val_ref = &*val_ref;
                    encoder.encode_varint32(2330u32)?;
                    val_ref.encode_len_delimited(encoder)?;
                }
                Rpc_::Payload::ReqWifiClearFastConnect(val_ref) => {
                    let val_ref = &*val_ref;
                    encoder.encode_varint32(2338u32)?;
                    val_ref.encode_len_delimited(encoder)?;
                }
                Rpc_::Payload::ReqWifiDeauthSta(val_ref) => {
                    let val_ref = &*val_ref;
                    encoder.encode_varint32(2346u32)?;
                    val_ref.encode_len_delimited(encoder)?;
                }
                Rpc_::Payload::ReqWifiStaGetApInfo(val_ref) => {
                    let val_ref = &*val_ref;
                    encoder.encode_varint32(2354u32)?;
                    val_ref.encode_len_delimited(encoder)?;
                }
                Rpc_::Payload::ReqWifiSetProtocol(val_ref) => {
                    let val_ref = &*val_ref;
                    encoder.encode_varint32(2378u32)?;
                    val_ref.encode_len_delimited(encoder)?;
                }
                Rpc_::Payload::ReqWifiGetProtocol(val_ref) => {
                    let val_ref = &*val_ref;
                    encoder.encode_varint32(2386u32)?;
                    val_ref.encode_len_delimited(encoder)?;
                }
                Rpc_::Payload::ReqWifiSetBandwidth(val_ref) => {
                    let val_ref = &*val_ref;
                    encoder.encode_varint32(2394u32)?;
                    val_ref.encode_len_delimited(encoder)?;
                }
                Rpc_::Payload::ReqWifiGetBandwidth(val_ref) => {
                    let val_ref = &*val_ref;
                    encoder.encode_varint32(2402u32)?;
                    val_ref.encode_len_delimited(encoder)?;
                }
                Rpc_::Payload::ReqWifiSetChannel(val_ref) => {
                    let val_ref = &*val_ref;
                    encoder.encode_varint32(2410u32)?;
                    val_ref.encode_len_delimited(encoder)?;
                }
                Rpc_::Payload::ReqWifiGetChannel(val_ref) => {
                    let val_ref = &*val_ref;
                    encoder.encode_varint32(2418u32)?;
                    val_ref.encode_len_delimited(encoder)?;
                }
                Rpc_::Payload::ReqWifiSetCountry(val_ref) => {
                    let val_ref = &*val_ref;
                    encoder.encode_varint32(2426u32)?;
                    val_ref.encode_len_delimited(encoder)?;
                }
                Rpc_::Payload::ReqWifiGetCountry(val_ref) => {
                    let val_ref = &*val_ref;
                    encoder.encode_varint32(2434u32)?;
                    val_ref.encode_len_delimited(encoder)?;
                }
                Rpc_::Payload::ReqWifiApGetStaList(val_ref) => {
                    let val_ref = &*val_ref;
                    encoder.encode_varint32(2490u32)?;
                    val_ref.encode_len_delimited(encoder)?;
                }
                Rpc_::Payload::ReqWifiApGetStaAid(val_ref) => {
                    let val_ref = &*val_ref;
                    encoder.encode_varint32(2498u32)?;
                    val_ref.encode_len_delimited(encoder)?;
                }
                Rpc_::Payload::ReqWifiSetStorage(val_ref) => {
                    let val_ref = &*val_ref;
                    encoder.encode_varint32(2506u32)?;
                    val_ref.encode_len_delimited(encoder)?;
                }
                Rpc_::Payload::ReqWifiSetCountryCode(val_ref) => {
                    let val_ref = &*val_ref;
                    encoder.encode_varint32(2674u32)?;
                    val_ref.encode_len_delimited(encoder)?;
                }
                Rpc_::Payload::ReqWifiGetCountryCode(val_ref) => {
                    let val_ref = &*val_ref;
                    encoder.encode_varint32(2682u32)?;
                    val_ref.encode_len_delimited(encoder)?;
                }
                Rpc_::Payload::ReqWifiStaGetAid(val_ref) => {
                    let val_ref = &*val_ref;
                    encoder.encode_varint32(2706u32)?;
                    val_ref.encode_len_delimited(encoder)?;
                }
                Rpc_::Payload::ReqWifiStaGetNegotiatedPhymode(val_ref) => {
                    let val_ref = &*val_ref;
                    encoder.encode_varint32(2714u32)?;
                    val_ref.encode_len_delimited(encoder)?;
                }
                Rpc_::Payload::ReqWifiStaGetRssi(val_ref) => {
                    let val_ref = &*val_ref;
                    encoder.encode_varint32(2730u32)?;
                    val_ref.encode_len_delimited(encoder)?;
                }
                Rpc_::Payload::ReqWifiSetProtocols(val_ref) => {
                    let val_ref = &*val_ref;
                    encoder.encode_varint32(2738u32)?;
                    val_ref.encode_len_delimited(encoder)?;
                }
                Rpc_::Payload::ReqWifiGetProtocols(val_ref) => {
                    let val_ref = &*val_ref;
                    encoder.encode_varint32(2746u32)?;
                    val_ref.encode_len_delimited(encoder)?;
                }
                Rpc_::Payload::ReqWifiSetBandwidths(val_ref) => {
                    let val_ref = &*val_ref;
                    encoder.encode_varint32(2754u32)?;
                    val_ref.encode_len_delimited(encoder)?;
                }
                Rpc_::Payload::ReqWifiGetBandwidths(val_ref) => {
                    let val_ref = &*val_ref;
                    encoder.encode_varint32(2762u32)?;
                    val_ref.encode_len_delimited(encoder)?;
                }
                Rpc_::Payload::ReqWifiSetBand(val_ref) => {
                    let val_ref = &*val_ref;
                    encoder.encode_varint32(2770u32)?;
                    val_ref.encode_len_delimited(encoder)?;
                }
                Rpc_::Payload::ReqWifiGetBand(val_ref) => {
                    let val_ref = &*val_ref;
                    encoder.encode_varint32(2778u32)?;
                    val_ref.encode_len_delimited(encoder)?;
                }
                Rpc_::Payload::ReqWifiSetBandmode(val_ref) => {
                    let val_ref = &*val_ref;
                    encoder.encode_varint32(2786u32)?;
                    val_ref.encode_len_delimited(encoder)?;
                }
                Rpc_::Payload::ReqWifiGetBandmode(val_ref) => {
                    let val_ref = &*val_ref;
                    encoder.encode_varint32(2794u32)?;
                    val_ref.encode_len_delimited(encoder)?;
                }
                Rpc_::Payload::ReqGetCoprocessorFwversion(val_ref) => {
                    let val_ref = &*val_ref;
                    encoder.encode_varint32(2802u32)?;
                    val_ref.encode_len_delimited(encoder)?;
                }
                Rpc_::Payload::ReqWifiScanGetApRecord(val_ref) => {
                    let val_ref = &*val_ref;
                    encoder.encode_varint32(2810u32)?;
                    val_ref.encode_len_delimited(encoder)?;
                }
                Rpc_::Payload::RespGetMacAddress(val_ref) => {
                    let val_ref = &*val_ref;
                    encoder.encode_varint32(4106u32)?;
                    val_ref.encode_len_delimited(encoder)?;
                }
                Rpc_::Payload::RespSetMacAddress(val_ref) => {
                    let val_ref = &*val_ref;
                    encoder.encode_varint32(4114u32)?;
                    val_ref.encode_len_delimited(encoder)?;
                }
                Rpc_::Payload::RespGetWifiMode(val_ref) => {
                    let val_ref = &*val_ref;
                    encoder.encode_varint32(4122u32)?;
                    val_ref.encode_len_delimited(encoder)?;
                }
                Rpc_::Payload::RespSetWifiMode(val_ref) => {
                    let val_ref = &*val_ref;
                    encoder.encode_varint32(4130u32)?;
                    val_ref.encode_len_delimited(encoder)?;
                }
                Rpc_::Payload::RespWifiSetPs(val_ref) => {
                    let val_ref = &*val_ref;
                    encoder.encode_varint32(4210u32)?;
                    val_ref.encode_len_delimited(encoder)?;
                }
                Rpc_::Payload::RespWifiGetPs(val_ref) => {
                    let val_ref = &*val_ref;
                    encoder.encode_varint32(4218u32)?;
                    val_ref.encode_len_delimited(encoder)?;
                }
                Rpc_::Payload::RespOtaBegin(val_ref) => {
                    let val_ref = &*val_ref;
                    encoder.encode_varint32(4226u32)?;
                    val_ref.encode_len_delimited(encoder)?;
                }
                Rpc_::Payload::RespOtaWrite(val_ref) => {
                    let val_ref = &*val_ref;
                    encoder.encode_varint32(4234u32)?;
                    val_ref.encode_len_delimited(encoder)?;
                }
                Rpc_::Payload::RespOtaEnd(val_ref) => {
                    let val_ref = &*val_ref;
                    encoder.encode_varint32(4242u32)?;
                    val_ref.encode_len_delimited(encoder)?;
                }
                Rpc_::Payload::RespSetWifiMaxTxPower(val_ref) => {
                    let val_ref = &*val_ref;
                    encoder.encode_varint32(4250u32)?;
                    val_ref.encode_len_delimited(encoder)?;
                }
                Rpc_::Payload::RespGetWifiMaxTxPower(val_ref) => {
                    let val_ref = &*val_ref;
                    encoder.encode_varint32(4258u32)?;
                    val_ref.encode_len_delimited(encoder)?;
                }
                Rpc_::Payload::RespConfigHeartbeat(val_ref) => {
                    let val_ref = &*val_ref;
                    encoder.encode_varint32(4266u32)?;
                    val_ref.encode_len_delimited(encoder)?;
                }
                Rpc_::Payload::RespWifiInit(val_ref) => {
                    let val_ref = &*val_ref;
                    encoder.encode_varint32(4274u32)?;
                    val_ref.encode_len_delimited(encoder)?;
                }
                Rpc_::Payload::RespWifiDeinit(val_ref) => {
                    let val_ref = &*val_ref;
                    encoder.encode_varint32(4282u32)?;
                    val_ref.encode_len_delimited(encoder)?;
                }
                Rpc_::Payload::RespWifiStart(val_ref) => {
                    let val_ref = &*val_ref;
                    encoder.encode_varint32(4290u32)?;
                    val_ref.encode_len_delimited(encoder)?;
                }
                Rpc_::Payload::RespWifiStop(val_ref) => {
                    let val_ref = &*val_ref;
                    encoder.encode_varint32(4298u32)?;
                    val_ref.encode_len_delimited(encoder)?;
                }
                Rpc_::Payload::RespWifiConnect(val_ref) => {
                    let val_ref = &*val_ref;
                    encoder.encode_varint32(4306u32)?;
                    val_ref.encode_len_delimited(encoder)?;
                }
                Rpc_::Payload::RespWifiDisconnect(val_ref) => {
                    let val_ref = &*val_ref;
                    encoder.encode_varint32(4314u32)?;
                    val_ref.encode_len_delimited(encoder)?;
                }
                Rpc_::Payload::RespWifiSetConfig(val_ref) => {
                    let val_ref = &*val_ref;
                    encoder.encode_varint32(4322u32)?;
                    val_ref.encode_len_delimited(encoder)?;
                }
                Rpc_::Payload::RespWifiGetConfig(val_ref) => {
                    let val_ref = &*val_ref;
                    encoder.encode_varint32(4330u32)?;
                    val_ref.encode_len_delimited(encoder)?;
                }
                Rpc_::Payload::RespWifiScanStart(val_ref) => {
                    let val_ref = &*val_ref;
                    encoder.encode_varint32(4338u32)?;
                    val_ref.encode_len_delimited(encoder)?;
                }
                Rpc_::Payload::RespWifiScanStop(val_ref) => {
                    let val_ref = &*val_ref;
                    encoder.encode_varint32(4346u32)?;
                    val_ref.encode_len_delimited(encoder)?;
                }
                Rpc_::Payload::RespWifiScanGetApNum(val_ref) => {
                    let val_ref = &*val_ref;
                    encoder.encode_varint32(4354u32)?;
                    val_ref.encode_len_delimited(encoder)?;
                }
                Rpc_::Payload::RespWifiScanGetApRecords(val_ref) => {
                    let val_ref = &*val_ref;
                    encoder.encode_varint32(4362u32)?;
                    val_ref.encode_len_delimited(encoder)?;
                }
                Rpc_::Payload::RespWifiClearApList(val_ref) => {
                    let val_ref = &*val_ref;
                    encoder.encode_varint32(4370u32)?;
                    val_ref.encode_len_delimited(encoder)?;
                }
                Rpc_::Payload::RespWifiRestore(val_ref) => {
                    let val_ref = &*val_ref;
                    encoder.encode_varint32(4378u32)?;
                    val_ref.encode_len_delimited(encoder)?;
                }
                Rpc_::Payload::RespWifiClearFastConnect(val_ref) => {
                    let val_ref = &*val_ref;
                    encoder.encode_varint32(4386u32)?;
                    val_ref.encode_len_delimited(encoder)?;
                }
                Rpc_::Payload::RespWifiDeauthSta(val_ref) => {
                    let val_ref = &*val_ref;
                    encoder.encode_varint32(4394u32)?;
                    val_ref.encode_len_delimited(encoder)?;
                }
                Rpc_::Payload::RespWifiStaGetApInfo(val_ref) => {
                    let val_ref = &*val_ref;
                    encoder.encode_varint32(4402u32)?;
                    val_ref.encode_len_delimited(encoder)?;
                }
                Rpc_::Payload::RespWifiSetProtocol(val_ref) => {
                    let val_ref = &*val_ref;
                    encoder.encode_varint32(4426u32)?;
                    val_ref.encode_len_delimited(encoder)?;
                }
                Rpc_::Payload::RespWifiGetProtocol(val_ref) => {
                    let val_ref = &*val_ref;
                    encoder.encode_varint32(4434u32)?;
                    val_ref.encode_len_delimited(encoder)?;
                }
                Rpc_::Payload::RespWifiSetBandwidth(val_ref) => {
                    let val_ref = &*val_ref;
                    encoder.encode_varint32(4442u32)?;
                    val_ref.encode_len_delimited(encoder)?;
                }
                Rpc_::Payload::RespWifiGetBandwidth(val_ref) => {
                    let val_ref = &*val_ref;
                    encoder.encode_varint32(4450u32)?;
                    val_ref.encode_len_delimited(encoder)?;
                }
                Rpc_::Payload::RespWifiSetChannel(val_ref) => {
                    let val_ref = &*val_ref;
                    encoder.encode_varint32(4458u32)?;
                    val_ref.encode_len_delimited(encoder)?;
                }
                Rpc_::Payload::RespWifiGetChannel(val_ref) => {
                    let val_ref = &*val_ref;
                    encoder.encode_varint32(4466u32)?;
                    val_ref.encode_len_delimited(encoder)?;
                }
                Rpc_::Payload::RespWifiSetCountry(val_ref) => {
                    let val_ref = &*val_ref;
                    encoder.encode_varint32(4474u32)?;
                    val_ref.encode_len_delimited(encoder)?;
                }
                Rpc_::Payload::RespWifiGetCountry(val_ref) => {
                    let val_ref = &*val_ref;
                    encoder.encode_varint32(4482u32)?;
                    val_ref.encode_len_delimited(encoder)?;
                }
                Rpc_::Payload::RespWifiApGetStaList(val_ref) => {
                    let val_ref = &*val_ref;
                    encoder.encode_varint32(4538u32)?;
                    val_ref.encode_len_delimited(encoder)?;
                }
                Rpc_::Payload::RespWifiApGetStaAid(val_ref) => {
                    let val_ref = &*val_ref;
                    encoder.encode_varint32(4546u32)?;
                    val_ref.encode_len_delimited(encoder)?;
                }
                Rpc_::Payload::RespWifiSetStorage(val_ref) => {
                    let val_ref = &*val_ref;
                    encoder.encode_varint32(4554u32)?;
                    val_ref.encode_len_delimited(encoder)?;
                }
                Rpc_::Payload::RespWifiSetCountryCode(val_ref) => {
                    let val_ref = &*val_ref;
                    encoder.encode_varint32(4722u32)?;
                    val_ref.encode_len_delimited(encoder)?;
                }
                Rpc_::Payload::RespWifiGetCountryCode(val_ref) => {
                    let val_ref = &*val_ref;
                    encoder.encode_varint32(4730u32)?;
                    val_ref.encode_len_delimited(encoder)?;
                }
                Rpc_::Payload::RespWifiStaGetAid(val_ref) => {
                    let val_ref = &*val_ref;
                    encoder.encode_varint32(4754u32)?;
                    val_ref.encode_len_delimited(encoder)?;
                }
                Rpc_::Payload::RespWifiStaGetNegotiatedPhymode(val_ref) => {
                    let val_ref = &*val_ref;
                    encoder.encode_varint32(4762u32)?;
                    val_ref.encode_len_delimited(encoder)?;
                }
                Rpc_::Payload::RespWifiStaGetRssi(val_ref) => {
                    let val_ref = &*val_ref;
                    encoder.encode_varint32(4778u32)?;
                    val_ref.encode_len_delimited(encoder)?;
                }
                Rpc_::Payload::RespWifiSetProtocols(val_ref) => {
                    let val_ref = &*val_ref;
                    encoder.encode_varint32(4786u32)?;
                    val_ref.encode_len_delimited(encoder)?;
                }
                Rpc_::Payload::RespWifiGetProtocols(val_ref) => {
                    let val_ref = &*val_ref;
                    encoder.encode_varint32(4794u32)?;
                    val_ref.encode_len_delimited(encoder)?;
                }
                Rpc_::Payload::RespWifiSetBandwidths(val_ref) => {
                    let val_ref = &*val_ref;
                    encoder.encode_varint32(4802u32)?;
                    val_ref.encode_len_delimited(encoder)?;
                }
                Rpc_::Payload::RespWifiGetBandwidths(val_ref) => {
                    let val_ref = &*val_ref;
                    encoder.encode_varint32(4810u32)?;
                    val_ref.encode_len_delimited(encoder)?;
                }
                Rpc_::Payload::RespWifiSetBand(val_ref) => {
                    let val_ref = &*val_ref;
                    encoder.encode_varint32(4818u32)?;
                    val_ref.encode_len_delimited(encoder)?;
                }
                Rpc_::Payload::RespWifiGetBand(val_ref) => {
                    let val_ref = &*val_ref;
                    encoder.encode_varint32(4826u32)?;
                    val_ref.encode_len_delimited(encoder)?;
                }
                Rpc_::Payload::RespWifiSetBandmode(val_ref) => {
                    let val_ref = &*val_ref;
                    encoder.encode_varint32(4834u32)?;
                    val_ref.encode_len_delimited(encoder)?;
                }
                Rpc_::Payload::RespWifiGetBandmode(val_ref) => {
                    let val_ref = &*val_ref;
                    encoder.encode_varint32(4842u32)?;
                    val_ref.encode_len_delimited(encoder)?;
                }
                Rpc_::Payload::RespGetCoprocessorFwversion(val_ref) => {
                    let val_ref = &*val_ref;
                    encoder.encode_varint32(4850u32)?;
                    val_ref.encode_len_delimited(encoder)?;
                }
                Rpc_::Payload::RespWifiScanGetApRecord(val_ref) => {
                    let val_ref = &*val_ref;
                    encoder.encode_varint32(4858u32)?;
                    val_ref.encode_len_delimited(encoder)?;
                }
                Rpc_::Payload::EventEspInit(val_ref) => {
                    let val_ref = &*val_ref;
                    encoder.encode_varint32(6154u32)?;
                    val_ref.encode_len_delimited(encoder)?;
                }
                Rpc_::Payload::EventHeartbeat(val_ref) => {
                    let val_ref = &*val_ref;
                    encoder.encode_varint32(6162u32)?;
                    val_ref.encode_len_delimited(encoder)?;
                }
                Rpc_::Payload::EventApStaConnected(val_ref) => {
                    let val_ref = &*val_ref;
                    encoder.encode_varint32(6170u32)?;
                    val_ref.encode_len_delimited(encoder)?;
                }
                Rpc_::Payload::EventApStaDisconnected(val_ref) => {
                    let val_ref = &*val_ref;
                    encoder.encode_varint32(6178u32)?;
                    val_ref.encode_len_delimited(encoder)?;
                }
                Rpc_::Payload::EventWifiEventNoArgs(val_ref) => {
                    let val_ref = &*val_ref;
                    encoder.encode_varint32(6186u32)?;
                    val_ref.encode_len_delimited(encoder)?;
                }
                Rpc_::Payload::EventStaScanDone(val_ref) => {
                    let val_ref = &*val_ref;
                    encoder.encode_varint32(6194u32)?;
                    val_ref.encode_len_delimited(encoder)?;
                }
                Rpc_::Payload::EventStaConnected(val_ref) => {
                    let val_ref = &*val_ref;
                    encoder.encode_varint32(6202u32)?;
                    val_ref.encode_len_delimited(encoder)?;
                }
                Rpc_::Payload::EventStaDisconnected(val_ref) => {
                    let val_ref = &*val_ref;
                    encoder.encode_varint32(6210u32)?;
                    val_ref.encode_len_delimited(encoder)?;
                }
            }
        }
        Ok(())
    }
    fn compute_size(&self) -> usize {
        use ::micropb::{FieldEncode, PbMap};
        let mut size = 0;
        {
            let val_ref = &self.r#msg_type;
            if val_ref.0 != 0 {
                size += 1usize + ::micropb::size::sizeof_int32(val_ref.0 as _);
            }
        }
        {
            let val_ref = &self.r#msg_id;
            if val_ref.0 != 0 {
                size += 1usize + ::micropb::size::sizeof_int32(val_ref.0 as _);
            }
        }
        {
            let val_ref = &self.r#uid;
            if *val_ref != 0 {
                size += 1usize + ::micropb::size::sizeof_varint32(*val_ref as _);
            }
        }
        if let Some(oneof) = &self.r#payload {
            match &*oneof {
                Rpc_::Payload::ReqGetMacAddress(val_ref) => {
                    let val_ref = &*val_ref;
                    size += 2usize + ::micropb::size::sizeof_len_record(val_ref.compute_size());
                }
                Rpc_::Payload::ReqSetMacAddress(val_ref) => {
                    let val_ref = &*val_ref;
                    size += 2usize + ::micropb::size::sizeof_len_record(val_ref.compute_size());
                }
                Rpc_::Payload::ReqGetWifiMode(val_ref) => {
                    let val_ref = &*val_ref;
                    size += 2usize + ::micropb::size::sizeof_len_record(val_ref.compute_size());
                }
                Rpc_::Payload::ReqSetWifiMode(val_ref) => {
                    let val_ref = &*val_ref;
                    size += 2usize + ::micropb::size::sizeof_len_record(val_ref.compute_size());
                }
                Rpc_::Payload::ReqWifiSetPs(val_ref) => {
                    let val_ref = &*val_ref;
                    size += 2usize + ::micropb::size::sizeof_len_record(val_ref.compute_size());
                }
                Rpc_::Payload::ReqWifiGetPs(val_ref) => {
                    let val_ref = &*val_ref;
                    size += 2usize + ::micropb::size::sizeof_len_record(val_ref.compute_size());
                }
                Rpc_::Payload::ReqOtaBegin(val_ref) => {
                    let val_ref = &*val_ref;
                    size += 2usize + ::micropb::size::sizeof_len_record(val_ref.compute_size());
                }
                Rpc_::Payload::ReqOtaWrite(val_ref) => {
                    let val_ref = &*val_ref;
                    size += 2usize + ::micropb::size::sizeof_len_record(val_ref.compute_size());
                }
                Rpc_::Payload::ReqOtaEnd(val_ref) => {
                    let val_ref = &*val_ref;
                    size += 2usize + ::micropb::size::sizeof_len_record(val_ref.compute_size());
                }
                Rpc_::Payload::ReqSetWifiMaxTxPower(val_ref) => {
                    let val_ref = &*val_ref;
                    size += 2usize + ::micropb::size::sizeof_len_record(val_ref.compute_size());
                }
                Rpc_::Payload::ReqGetWifiMaxTxPower(val_ref) => {
                    let val_ref = &*val_ref;
                    size += 2usize + ::micropb::size::sizeof_len_record(val_ref.compute_size());
                }
                Rpc_::Payload::ReqConfigHeartbeat(val_ref) => {
                    let val_ref = &*val_ref;
                    size += 2usize + ::micropb::size::sizeof_len_record(val_ref.compute_size());
                }
                Rpc_::Payload::ReqWifiInit(val_ref) => {
                    let val_ref = &*val_ref;
                    size += 2usize + ::micropb::size::sizeof_len_record(val_ref.compute_size());
                }
                Rpc_::Payload::ReqWifiDeinit(val_ref) => {
                    let val_ref = &*val_ref;
                    size += 2usize + ::micropb::size::sizeof_len_record(val_ref.compute_size());
                }
                Rpc_::Payload::ReqWifiStart(val_ref) => {
                    let val_ref = &*val_ref;
                    size += 2usize + ::micropb::size::sizeof_len_record(val_ref.compute_size());
                }
                Rpc_::Payload::ReqWifiStop(val_ref) => {
                    let val_ref = &*val_ref;
                    size += 2usize + ::micropb::size::sizeof_len_record(val_ref.compute_size());
                }
                Rpc_::Payload::ReqWifiConnect(val_ref) => {
                    let val_ref = &*val_ref;
                    size += 2usize + ::micropb::size::sizeof_len_record(val_ref.compute_size());
                }
                Rpc_::Payload::ReqWifiDisconnect(val_ref) => {
                    let val_ref = &*val_ref;
                    size += 2usize + ::micropb::size::sizeof_len_record(val_ref.compute_size());
                }
                Rpc_::Payload::ReqWifiSetConfig(val_ref) => {
                    let val_ref = &*val_ref;
                    size += 2usize + ::micropb::size::sizeof_len_record(val_ref.compute_size());
                }
                Rpc_::Payload::ReqWifiGetConfig(val_ref) => {
                    let val_ref = &*val_ref;
                    size += 2usize + ::micropb::size::sizeof_len_record(val_ref.compute_size());
                }
                Rpc_::Payload::ReqWifiScanStart(val_ref) => {
                    let val_ref = &*val_ref;
                    size += 2usize + ::micropb::size::sizeof_len_record(val_ref.compute_size());
                }
                Rpc_::Payload::ReqWifiScanStop(val_ref) => {
                    let val_ref = &*val_ref;
                    size += 2usize + ::micropb::size::sizeof_len_record(val_ref.compute_size());
                }
                Rpc_::Payload::ReqWifiScanGetApNum(val_ref) => {
                    let val_ref = &*val_ref;
                    size += 2usize + ::micropb::size::sizeof_len_record(val_ref.compute_size());
                }
                Rpc_::Payload::ReqWifiScanGetApRecords(val_ref) => {
                    let val_ref = &*val_ref;
                    size += 2usize + ::micropb::size::sizeof_len_record(val_ref.compute_size());
                }
                Rpc_::Payload::ReqWifiClearApList(val_ref) => {
                    let val_ref = &*val_ref;
                    size += 2usize + ::micropb::size::sizeof_len_record(val_ref.compute_size());
                }
                Rpc_::Payload::ReqWifiRestore(val_ref) => {
                    let val_ref = &*val_ref;
                    size += 2usize + ::micropb::size::sizeof_len_record(val_ref.compute_size());
                }
                Rpc_::Payload::ReqWifiClearFastConnect(val_ref) => {
                    let val_ref = &*val_ref;
                    size += 2usize + ::micropb::size::sizeof_len_record(val_ref.compute_size());
                }
                Rpc_::Payload::ReqWifiDeauthSta(val_ref) => {
                    let val_ref = &*val_ref;
                    size += 2usize + ::micropb::size::sizeof_len_record(val_ref.compute_size());
                }
                Rpc_::Payload::ReqWifiStaGetApInfo(val_ref) => {
                    let val_ref = &*val_ref;
                    size += 2usize + ::micropb::size::sizeof_len_record(val_ref.compute_size());
                }
                Rpc_::Payload::ReqWifiSetProtocol(val_ref) => {
                    let val_ref = &*val_ref;
                    size += 2usize + ::micropb::size::sizeof_len_record(val_ref.compute_size());
                }
                Rpc_::Payload::ReqWifiGetProtocol(val_ref) => {
                    let val_ref = &*val_ref;
                    size += 2usize + ::micropb::size::sizeof_len_record(val_ref.compute_size());
                }
                Rpc_::Payload::ReqWifiSetBandwidth(val_ref) => {
                    let val_ref = &*val_ref;
                    size += 2usize + ::micropb::size::sizeof_len_record(val_ref.compute_size());
                }
                Rpc_::Payload::ReqWifiGetBandwidth(val_ref) => {
                    let val_ref = &*val_ref;
                    size += 2usize + ::micropb::size::sizeof_len_record(val_ref.compute_size());
                }
                Rpc_::Payload::ReqWifiSetChannel(val_ref) => {
                    let val_ref = &*val_ref;
                    size += 2usize + ::micropb::size::sizeof_len_record(val_ref.compute_size());
                }
                Rpc_::Payload::ReqWifiGetChannel(val_ref) => {
                    let val_ref = &*val_ref;
                    size += 2usize + ::micropb::size::sizeof_len_record(val_ref.compute_size());
                }
                Rpc_::Payload::ReqWifiSetCountry(val_ref) => {
                    let val_ref = &*val_ref;
                    size += 2usize + ::micropb::size::sizeof_len_record(val_ref.compute_size());
                }
                Rpc_::Payload::ReqWifiGetCountry(val_ref) => {
                    let val_ref = &*val_ref;
                    size += 2usize + ::micropb::size::sizeof_len_record(val_ref.compute_size());
                }
                Rpc_::Payload::ReqWifiApGetStaList(val_ref) => {
                    let val_ref = &*val_ref;
                    size += 2usize + ::micropb::size::sizeof_len_record(val_ref.compute_size());
                }
                Rpc_::Payload::ReqWifiApGetStaAid(val_ref) => {
                    let val_ref = &*val_ref;
                    size += 2usize + ::micropb::size::sizeof_len_record(val_ref.compute_size());
                }
                Rpc_::Payload::ReqWifiSetStorage(val_ref) => {
                    let val_ref = &*val_ref;
                    size += 2usize + ::micropb::size::sizeof_len_record(val_ref.compute_size());
                }
                Rpc_::Payload::ReqWifiSetCountryCode(val_ref) => {
                    let val_ref = &*val_ref;
                    size += 2usize + ::micropb::size::sizeof_len_record(val_ref.compute_size());
                }
                Rpc_::Payload::ReqWifiGetCountryCode(val_ref) => {
                    let val_ref = &*val_ref;
                    size += 2usize + ::micropb::size::sizeof_len_record(val_ref.compute_size());
                }
                Rpc_::Payload::ReqWifiStaGetAid(val_ref) => {
                    let val_ref = &*val_ref;
                    size += 2usize + ::micropb::size::sizeof_len_record(val_ref.compute_size());
                }
                Rpc_::Payload::ReqWifiStaGetNegotiatedPhymode(val_ref) => {
                    let val_ref = &*val_ref;
                    size += 2usize + ::micropb::size::sizeof_len_record(val_ref.compute_size());
                }
                Rpc_::Payload::ReqWifiStaGetRssi(val_ref) => {
                    let val_ref = &*val_ref;
                    size += 2usize + ::micropb::size::sizeof_len_record(val_ref.compute_size());
                }
                Rpc_::Payload::ReqWifiSetProtocols(val_ref) => {
                    let val_ref = &*val_ref;
                    size += 2usize + ::micropb::size::sizeof_len_record(val_ref.compute_size());
                }
                Rpc_::Payload::ReqWifiGetProtocols(val_ref) => {
                    let val_ref = &*val_ref;
                    size += 2usize + ::micropb::size::sizeof_len_record(val_ref.compute_size());
                }
                Rpc_::Payload::ReqWifiSetBandwidths(val_ref) => {
                    let val_ref = &*val_ref;
                    size += 2usize + ::micropb::size::sizeof_len_record(val_ref.compute_size());
                }
                Rpc_::Payload::ReqWifiGetBandwidths(val_ref) => {
                    let val_ref = &*val_ref;
                    size += 2usize + ::micropb::size::sizeof_len_record(val_ref.compute_size());
                }
                Rpc_::Payload::ReqWifiSetBand(val_ref) => {
                    let val_ref = &*val_ref;
                    size += 2usize + ::micropb::size::sizeof_len_record(val_ref.compute_size());
                }
                Rpc_::Payload::ReqWifiGetBand(val_ref) => {
                    let val_ref = &*val_ref;
                    size += 2usize + ::micropb::size::sizeof_len_record(val_ref.compute_size());
                }
                Rpc_::Payload::ReqWifiSetBandmode(val_ref) => {
                    let val_ref = &*val_ref;
                    size += 2usize + ::micropb::size::sizeof_len_record(val_ref.compute_size());
                }
                Rpc_::Payload::ReqWifiGetBandmode(val_ref) => {
                    let val_ref = &*val_ref;
                    size += 2usize + ::micropb::size::sizeof_len_record(val_ref.compute_size());
                }
                Rpc_::Payload::ReqGetCoprocessorFwversion(val_ref) => {
                    let val_ref = &*val_ref;
                    size += 2usize + ::micropb::size::sizeof_len_record(val_ref.compute_size());
                }
                Rpc_::Payload::ReqWifiScanGetApRecord(val_ref) => {
                    let val_ref = &*val_ref;
                    size += 2usize + ::micropb::size::sizeof_len_record(val_ref.compute_size());
                }
                Rpc_::Payload::RespGetMacAddress(val_ref) => {
                    let val_ref = &*val_ref;
                    size += 2usize + ::micropb::size::sizeof_len_record(val_ref.compute_size());
                }
                Rpc_::Payload::RespSetMacAddress(val_ref) => {
                    let val_ref = &*val_ref;
                    size += 2usize + ::micropb::size::sizeof_len_record(val_ref.compute_size());
                }
                Rpc_::Payload::RespGetWifiMode(val_ref) => {
                    let val_ref = &*val_ref;
                    size += 2usize + ::micropb::size::sizeof_len_record(val_ref.compute_size());
                }
                Rpc_::Payload::RespSetWifiMode(val_ref) => {
                    let val_ref = &*val_ref;
                    size += 2usize + ::micropb::size::sizeof_len_record(val_ref.compute_size());
                }
                Rpc_::Payload::RespWifiSetPs(val_ref) => {
                    let val_ref = &*val_ref;
                    size += 2usize + ::micropb::size::sizeof_len_record(val_ref.compute_size());
                }
                Rpc_::Payload::RespWifiGetPs(val_ref) => {
                    let val_ref = &*val_ref;
                    size += 2usize + ::micropb::size::sizeof_len_record(val_ref.compute_size());
                }
                Rpc_::Payload::RespOtaBegin(val_ref) => {
                    let val_ref = &*val_ref;
                    size += 2usize + ::micropb::size::sizeof_len_record(val_ref.compute_size());
                }
                Rpc_::Payload::RespOtaWrite(val_ref) => {
                    let val_ref = &*val_ref;
                    size += 2usize + ::micropb::size::sizeof_len_record(val_ref.compute_size());
                }
                Rpc_::Payload::RespOtaEnd(val_ref) => {
                    let val_ref = &*val_ref;
                    size += 2usize + ::micropb::size::sizeof_len_record(val_ref.compute_size());
                }
                Rpc_::Payload::RespSetWifiMaxTxPower(val_ref) => {
                    let val_ref = &*val_ref;
                    size += 2usize + ::micropb::size::sizeof_len_record(val_ref.compute_size());
                }
                Rpc_::Payload::RespGetWifiMaxTxPower(val_ref) => {
                    let val_ref = &*val_ref;
                    size += 2usize + ::micropb::size::sizeof_len_record(val_ref.compute_size());
                }
                Rpc_::Payload::RespConfigHeartbeat(val_ref) => {
                    let val_ref = &*val_ref;
                    size += 2usize + ::micropb::size::sizeof_len_record(val_ref.compute_size());
                }
                Rpc_::Payload::RespWifiInit(val_ref) => {
                    let val_ref = &*val_ref;
                    size += 2usize + ::micropb::size::sizeof_len_record(val_ref.compute_size());
                }
                Rpc_::Payload::RespWifiDeinit(val_ref) => {
                    let val_ref = &*val_ref;
                    size += 2usize + ::micropb::size::sizeof_len_record(val_ref.compute_size());
                }
                Rpc_::Payload::RespWifiStart(val_ref) => {
                    let val_ref = &*val_ref;
                    size += 2usize + ::micropb::size::sizeof_len_record(val_ref.compute_size());
                }
                Rpc_::Payload::RespWifiStop(val_ref) => {
                    let val_ref = &*val_ref;
                    size += 2usize + ::micropb::size::sizeof_len_record(val_ref.compute_size());
                }
                Rpc_::Payload::RespWifiConnect(val_ref) => {
                    let val_ref = &*val_ref;
                    size += 2usize + ::micropb::size::sizeof_len_record(val_ref.compute_size());
                }
                Rpc_::Payload::RespWifiDisconnect(val_ref) => {
                    let val_ref = &*val_ref;
                    size += 2usize + ::micropb::size::sizeof_len_record(val_ref.compute_size());
                }
                Rpc_::Payload::RespWifiSetConfig(val_ref) => {
                    let val_ref = &*val_ref;
                    size += 2usize + ::micropb::size::sizeof_len_record(val_ref.compute_size());
                }
                Rpc_::Payload::RespWifiGetConfig(val_ref) => {
                    let val_ref = &*val_ref;
                    size += 2usize + ::micropb::size::sizeof_len_record(val_ref.compute_size());
                }
                Rpc_::Payload::RespWifiScanStart(val_ref) => {
                    let val_ref = &*val_ref;
                    size += 2usize + ::micropb::size::sizeof_len_record(val_ref.compute_size());
                }
                Rpc_::Payload::RespWifiScanStop(val_ref) => {
                    let val_ref = &*val_ref;
                    size += 2usize + ::micropb::size::sizeof_len_record(val_ref.compute_size());
                }
                Rpc_::Payload::RespWifiScanGetApNum(val_ref) => {
                    let val_ref = &*val_ref;
                    size += 2usize + ::micropb::size::sizeof_len_record(val_ref.compute_size());
                }
                Rpc_::Payload::RespWifiScanGetApRecords(val_ref) => {
                    let val_ref = &*val_ref;
                    size += 2usize + ::micropb::size::sizeof_len_record(val_ref.compute_size());
                }
                Rpc_::Payload::RespWifiClearApList(val_ref) => {
                    let val_ref = &*val_ref;
                    size += 2usize + ::micropb::size::sizeof_len_record(val_ref.compute_size());
                }
                Rpc_::Payload::RespWifiRestore(val_ref) => {
                    let val_ref = &*val_ref;
                    size += 2usize + ::micropb::size::sizeof_len_record(val_ref.compute_size());
                }
                Rpc_::Payload::RespWifiClearFastConnect(val_ref) => {
                    let val_ref = &*val_ref;
                    size += 2usize + ::micropb::size::sizeof_len_record(val_ref.compute_size());
                }
                Rpc_::Payload::RespWifiDeauthSta(val_ref) => {
                    let val_ref = &*val_ref;
                    size += 2usize + ::micropb::size::sizeof_len_record(val_ref.compute_size());
                }
                Rpc_::Payload::RespWifiStaGetApInfo(val_ref) => {
                    let val_ref = &*val_ref;
                    size += 2usize + ::micropb::size::sizeof_len_record(val_ref.compute_size());
                }
                Rpc_::Payload::RespWifiSetProtocol(val_ref) => {
                    let val_ref = &*val_ref;
                    size += 2usize + ::micropb::size::sizeof_len_record(val_ref.compute_size());
                }
                Rpc_::Payload::RespWifiGetProtocol(val_ref) => {
                    let val_ref = &*val_ref;
                    size += 2usize + ::micropb::size::sizeof_len_record(val_ref.compute_size());
                }
                Rpc_::Payload::RespWifiSetBandwidth(val_ref) => {
                    let val_ref = &*val_ref;
                    size += 2usize + ::micropb::size::sizeof_len_record(val_ref.compute_size());
                }
                Rpc_::Payload::RespWifiGetBandwidth(val_ref) => {
                    let val_ref = &*val_ref;
                    size += 2usize + ::micropb::size::sizeof_len_record(val_ref.compute_size());
                }
                Rpc_::Payload::RespWifiSetChannel(val_ref) => {
                    let val_ref = &*val_ref;
                    size += 2usize + ::micropb::size::sizeof_len_record(val_ref.compute_size());
                }
                Rpc_::Payload::RespWifiGetChannel(val_ref) => {
                    let val_ref = &*val_ref;
                    size += 2usize + ::micropb::size::sizeof_len_record(val_ref.compute_size());
                }
                Rpc_::Payload::RespWifiSetCountry(val_ref) => {
                    let val_ref = &*val_ref;
                    size += 2usize + ::micropb::size::sizeof_len_record(val_ref.compute_size());
                }
                Rpc_::Payload::RespWifiGetCountry(val_ref) => {
                    let val_ref = &*val_ref;
                    size += 2usize + ::micropb::size::sizeof_len_record(val_ref.compute_size());
                }
                Rpc_::Payload::RespWifiApGetStaList(val_ref) => {
                    let val_ref = &*val_ref;
                    size += 2usize + ::micropb::size::sizeof_len_record(val_ref.compute_size());
                }
                Rpc_::Payload::RespWifiApGetStaAid(val_ref) => {
                    let val_ref = &*val_ref;
                    size += 2usize + ::micropb::size::sizeof_len_record(val_ref.compute_size());
                }
                Rpc_::Payload::RespWifiSetStorage(val_ref) => {
                    let val_ref = &*val_ref;
                    size += 2usize + ::micropb::size::sizeof_len_record(val_ref.compute_size());
                }
                Rpc_::Payload::RespWifiSetCountryCode(val_ref) => {
                    let val_ref = &*val_ref;
                    size += 2usize + ::micropb::size::sizeof_len_record(val_ref.compute_size());
                }
                Rpc_::Payload::RespWifiGetCountryCode(val_ref) => {
                    let val_ref = &*val_ref;
                    size += 2usize + ::micropb::size::sizeof_len_record(val_ref.compute_size());
                }
                Rpc_::Payload::RespWifiStaGetAid(val_ref) => {
                    let val_ref = &*val_ref;
                    size += 2usize + ::micropb::size::sizeof_len_record(val_ref.compute_size());
                }
                Rpc_::Payload::RespWifiStaGetNegotiatedPhymode(val_ref) => {
                    let val_ref = &*val_ref;
                    size += 2usize + ::micropb::size::sizeof_len_record(val_ref.compute_size());
                }
                Rpc_::Payload::RespWifiStaGetRssi(val_ref) => {
                    let val_ref = &*val_ref;
                    size += 2usize + ::micropb::size::sizeof_len_record(val_ref.compute_size());
                }
                Rpc_::Payload::RespWifiSetProtocols(val_ref) => {
                    let val_ref = &*val_ref;
                    size += 2usize + ::micropb::size::sizeof_len_record(val_ref.compute_size());
                }
                Rpc_::Payload::RespWifiGetProtocols(val_ref) => {
                    let val_ref = &*val_ref;
                    size += 2usize + ::micropb::size::sizeof_len_record(val_ref.compute_size());
                }
                Rpc_::Payload::RespWifiSetBandwidths(val_ref) => {
                    let val_ref = &*val_ref;
                    size += 2usize + ::micropb::size::sizeof_len_record(val_ref.compute_size());
                }
                Rpc_::Payload::RespWifiGetBandwidths(val_ref) => {
                    let val_ref = &*val_ref;
                    size += 2usize + ::micropb::size::sizeof_len_record(val_ref.compute_size());
                }
                Rpc_::Payload::RespWifiSetBand(val_ref) => {
                    let val_ref = &*val_ref;
                    size += 2usize + ::micropb::size::sizeof_len_record(val_ref.compute_size());
                }
                Rpc_::Payload::RespWifiGetBand(val_ref) => {
                    let val_ref = &*val_ref;
                    size += 2usize + ::micropb::size::sizeof_len_record(val_ref.compute_size());
                }
                Rpc_::Payload::RespWifiSetBandmode(val_ref) => {
                    let val_ref = &*val_ref;
                    size += 2usize + ::micropb::size::sizeof_len_record(val_ref.compute_size());
                }
                Rpc_::Payload::RespWifiGetBandmode(val_ref) => {
                    let val_ref = &*val_ref;
                    size += 2usize + ::micropb::size::sizeof_len_record(val_ref.compute_size());
                }
                Rpc_::Payload::RespGetCoprocessorFwversion(val_ref) => {
                    let val_ref = &*val_ref;
                    size += 2usize + ::micropb::size::sizeof_len_record(val_ref.compute_size());
                }
                Rpc_::Payload::RespWifiScanGetApRecord(val_ref) => {
                    let val_ref = &*val_ref;
                    size += 2usize + ::micropb::size::sizeof_len_record(val_ref.compute_size());
                }
                Rpc_::Payload::EventEspInit(val_ref) => {
                    let val_ref = &*val_ref;
                    size += 2usize + ::micropb::size::sizeof_len_record(val_ref.compute_size());
                }
                Rpc_::Payload::EventHeartbeat(val_ref) => {
                    let val_ref = &*val_ref;
                    size += 2usize + ::micropb::size::sizeof_len_record(val_ref.compute_size());
                }
                Rpc_::Payload::EventApStaConnected(val_ref) => {
                    let val_ref = &*val_ref;
                    size += 2usize + ::micropb::size::sizeof_len_record(val_ref.compute_size());
                }
                Rpc_::Payload::EventApStaDisconnected(val_ref) => {
                    let val_ref = &*val_ref;
                    size += 2usize + ::micropb::size::sizeof_len_record(val_ref.compute_size());
                }
                Rpc_::Payload::EventWifiEventNoArgs(val_ref) => {
                    let val_ref = &*val_ref;
                    size += 2usize + ::micropb::size::sizeof_len_record(val_ref.compute_size());
                }
                Rpc_::Payload::EventStaScanDone(val_ref) => {
                    let val_ref = &*val_ref;
                    size += 2usize + ::micropb::size::sizeof_len_record(val_ref.compute_size());
                }
                Rpc_::Payload::EventStaConnected(val_ref) => {
                    let val_ref = &*val_ref;
                    size += 2usize + ::micropb::size::sizeof_len_record(val_ref.compute_size());
                }
                Rpc_::Payload::EventStaDisconnected(val_ref) => {
                    let val_ref = &*val_ref;
                    size += 2usize + ::micropb::size::sizeof_len_record(val_ref.compute_size());
                }
            }
        }
        size
    }
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
#[repr(transparent)]
pub struct Rpc_WifiBw(pub i32);
impl Rpc_WifiBw {
    pub const BwInvalid: Self = Self(0);
    pub const Ht20: Self = Self(1);
    pub const Ht40: Self = Self(2);
}
impl core::default::Default for Rpc_WifiBw {
    fn default() -> Self {
        Self(0)
    }
}
impl core::convert::From<i32> for Rpc_WifiBw {
    fn from(val: i32) -> Self {
        Self(val)
    }
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
#[repr(transparent)]
pub struct Rpc_WifiPowerSave(pub i32);
impl Rpc_WifiPowerSave {
    pub const PsInvalid: Self = Self(0);
    pub const MinModem: Self = Self(1);
    pub const MaxModem: Self = Self(2);
}
impl core::default::Default for Rpc_WifiPowerSave {
    fn default() -> Self {
        Self(0)
    }
}
impl core::convert::From<i32> for Rpc_WifiPowerSave {
    fn from(val: i32) -> Self {
        Self(val)
    }
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
#[repr(transparent)]
pub struct Rpc_WifiSecProt(pub i32);
impl Rpc_WifiSecProt {
    pub const Open: Self = Self(0);
    pub const Wep: Self = Self(1);
    pub const WpaPsk: Self = Self(2);
    pub const Wpa2Psk: Self = Self(3);
    pub const WpaWpa2Psk: Self = Self(4);
    pub const Wpa2Enterprise: Self = Self(5);
    pub const Wpa3Psk: Self = Self(6);
    pub const Wpa2Wpa3Psk: Self = Self(7);
}
impl core::default::Default for Rpc_WifiSecProt {
    fn default() -> Self {
        Self(0)
    }
}
impl core::convert::From<i32> for Rpc_WifiSecProt {
    fn from(val: i32) -> Self {
        Self(val)
    }
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
#[repr(transparent)]
pub struct Rpc_Status(pub i32);
impl Rpc_Status {
    pub const Connected: Self = Self(0);
    pub const NotConnected: Self = Self(1);
    pub const NoApFound: Self = Self(2);
    pub const ConnectionFail: Self = Self(3);
    pub const InvalidArgument: Self = Self(4);
    pub const OutOfRange: Self = Self(5);
}
impl core::default::Default for Rpc_Status {
    fn default() -> Self {
        Self(0)
    }
}
impl core::convert::From<i32> for Rpc_Status {
    fn from(val: i32) -> Self {
        Self(val)
    }
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
#[repr(transparent)]
pub struct RpcType(pub i32);
impl RpcType {
    pub const MsgTypeInvalid: Self = Self(0);
    pub const Req: Self = Self(1);
    pub const Resp: Self = Self(2);
    pub const Event: Self = Self(3);
    pub const MsgTypeMax: Self = Self(4);
}
impl core::default::Default for RpcType {
    fn default() -> Self {
        Self(0)
    }
}
impl core::convert::From<i32> for RpcType {
    fn from(val: i32) -> Self {
        Self(val)
    }
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
#[repr(transparent)]
pub struct RpcId(pub i32);
impl RpcId {
    pub const MsgIdInvalid: Self = Self(0);
    pub const ReqBase: Self = Self(256);
    pub const ReqGetMacAddress: Self = Self(257);
    pub const ReqSetMacAddress: Self = Self(258);
    pub const ReqGetWifiMode: Self = Self(259);
    pub const ReqSetWifiMode: Self = Self(260);
    pub const ReqWifiSetPs: Self = Self(270);
    pub const ReqWifiGetPs: Self = Self(271);
    pub const ReqOtaBegin: Self = Self(272);
    pub const ReqOtaWrite: Self = Self(273);
    pub const ReqOtaEnd: Self = Self(274);
    pub const ReqWifiSetMaxTxPower: Self = Self(275);
    pub const ReqWifiGetMaxTxPower: Self = Self(276);
    pub const ReqConfigHeartbeat: Self = Self(277);
    pub const ReqWifiInit: Self = Self(278);
    pub const ReqWifiDeinit: Self = Self(279);
    pub const ReqWifiStart: Self = Self(280);
    pub const ReqWifiStop: Self = Self(281);
    pub const ReqWifiConnect: Self = Self(282);
    pub const ReqWifiDisconnect: Self = Self(283);
    pub const ReqWifiSetConfig: Self = Self(284);
    pub const ReqWifiGetConfig: Self = Self(285);
    pub const ReqWifiScanStart: Self = Self(286);
    pub const ReqWifiScanStop: Self = Self(287);
    pub const ReqWifiScanGetApNum: Self = Self(288);
    pub const ReqWifiScanGetApRecords: Self = Self(289);
    pub const ReqWifiClearApList: Self = Self(290);
    pub const ReqWifiRestore: Self = Self(291);
    pub const ReqWifiClearFastConnect: Self = Self(292);
    pub const ReqWifiDeauthSta: Self = Self(293);
    pub const ReqWifiStaGetApInfo: Self = Self(294);
    pub const ReqWifiSetProtocol: Self = Self(297);
    pub const ReqWifiGetProtocol: Self = Self(298);
    pub const ReqWifiSetBandwidth: Self = Self(299);
    pub const ReqWifiGetBandwidth: Self = Self(300);
    pub const ReqWifiSetChannel: Self = Self(301);
    pub const ReqWifiGetChannel: Self = Self(302);
    pub const ReqWifiSetCountry: Self = Self(303);
    pub const ReqWifiGetCountry: Self = Self(304);
    pub const ReqWifiSetPromiscuous: Self = Self(305);
    pub const ReqWifiGetPromiscuous: Self = Self(306);
    pub const ReqWifiSetPromiscuousFilter: Self = Self(307);
    pub const ReqWifiGetPromiscuousFilter: Self = Self(308);
    pub const ReqWifiSetPromiscuousCtrlFilter: Self = Self(309);
    pub const ReqWifiGetPromiscuousCtrlFilter: Self = Self(310);
    pub const ReqWifiApGetStaList: Self = Self(311);
    pub const ReqWifiApGetStaAid: Self = Self(312);
    pub const ReqWifiSetStorage: Self = Self(313);
    pub const ReqWifiSetVendorIe: Self = Self(314);
    pub const ReqWifiSetEventMask: Self = Self(315);
    pub const ReqWifiGetEventMask: Self = Self(316);
    pub const ReqWifi80211Tx: Self = Self(317);
    pub const ReqWifiSetCsiConfig: Self = Self(318);
    pub const ReqWifiSetCsi: Self = Self(319);
    pub const ReqWifiSetAntGpio: Self = Self(320);
    pub const ReqWifiGetAntGpio: Self = Self(321);
    pub const ReqWifiSetAnt: Self = Self(322);
    pub const ReqWifiGetAnt: Self = Self(323);
    pub const ReqWifiGetTsfTime: Self = Self(324);
    pub const ReqWifiSetInactiveTime: Self = Self(325);
    pub const ReqWifiGetInactiveTime: Self = Self(326);
    pub const ReqWifiStatisDump: Self = Self(327);
    pub const ReqWifiSetRssiThreshold: Self = Self(328);
    pub const ReqWifiFtmInitiateSession: Self = Self(329);
    pub const ReqWifiFtmEndSession: Self = Self(330);
    pub const ReqWifiFtmRespSetOffset: Self = Self(331);
    pub const ReqWifiConfig11BRate: Self = Self(332);
    pub const ReqWifiConnectionlessModuleSetWakeInterval: Self = Self(333);
    pub const ReqWifiSetCountryCode: Self = Self(334);
    pub const ReqWifiGetCountryCode: Self = Self(335);
    pub const ReqWifiConfig80211TxRate: Self = Self(336);
    pub const ReqWifiDisablePmfConfig: Self = Self(337);
    pub const ReqWifiStaGetAid: Self = Self(338);
    pub const ReqWifiStaGetNegotiatedPhymode: Self = Self(339);
    pub const ReqWifiSetDynamicCs: Self = Self(340);
    pub const ReqWifiStaGetRssi: Self = Self(341);
    pub const ReqWifiSetProtocols: Self = Self(342);
    pub const ReqWifiGetProtocols: Self = Self(343);
    pub const ReqWifiSetBandwidths: Self = Self(344);
    pub const ReqWifiGetBandwidths: Self = Self(345);
    pub const ReqWifiSetBand: Self = Self(346);
    pub const ReqWifiGetBand: Self = Self(347);
    pub const ReqWifiSetBandMode: Self = Self(348);
    pub const ReqWifiGetBandMode: Self = Self(349);
    pub const ReqGetCoprocessorFwVersion: Self = Self(350);
    pub const ReqWifiScanGetApRecord: Self = Self(351);
    pub const ReqMax: Self = Self(352);
    pub const RespBase: Self = Self(512);
    pub const RespGetMacAddress: Self = Self(513);
    pub const RespSetMacAddress: Self = Self(514);
    pub const RespGetWifiMode: Self = Self(515);
    pub const RespSetWifiMode: Self = Self(516);
    pub const RespWifiSetPs: Self = Self(526);
    pub const RespWifiGetPs: Self = Self(527);
    pub const RespOtaBegin: Self = Self(528);
    pub const RespOtaWrite: Self = Self(529);
    pub const RespOtaEnd: Self = Self(530);
    pub const RespWifiSetMaxTxPower: Self = Self(531);
    pub const RespWifiGetMaxTxPower: Self = Self(532);
    pub const RespConfigHeartbeat: Self = Self(533);
    pub const RespWifiInit: Self = Self(534);
    pub const RespWifiDeinit: Self = Self(535);
    pub const RespWifiStart: Self = Self(536);
    pub const RespWifiStop: Self = Self(537);
    pub const RespWifiConnect: Self = Self(538);
    pub const RespWifiDisconnect: Self = Self(539);
    pub const RespWifiSetConfig: Self = Self(540);
    pub const RespWifiGetConfig: Self = Self(541);
    pub const RespWifiScanStart: Self = Self(542);
    pub const RespWifiScanStop: Self = Self(543);
    pub const RespWifiScanGetApNum: Self = Self(544);
    pub const RespWifiScanGetApRecords: Self = Self(545);
    pub const RespWifiClearApList: Self = Self(546);
    pub const RespWifiRestore: Self = Self(547);
    pub const RespWifiClearFastConnect: Self = Self(548);
    pub const RespWifiDeauthSta: Self = Self(549);
    pub const RespWifiStaGetApInfo: Self = Self(550);
    pub const RespWifiSetProtocol: Self = Self(553);
    pub const RespWifiGetProtocol: Self = Self(554);
    pub const RespWifiSetBandwidth: Self = Self(555);
    pub const RespWifiGetBandwidth: Self = Self(556);
    pub const RespWifiSetChannel: Self = Self(557);
    pub const RespWifiGetChannel: Self = Self(558);
    pub const RespWifiSetCountry: Self = Self(559);
    pub const RespWifiGetCountry: Self = Self(560);
    pub const RespWifiSetPromiscuous: Self = Self(561);
    pub const RespWifiGetPromiscuous: Self = Self(562);
    pub const RespWifiSetPromiscuousFilter: Self = Self(563);
    pub const RespWifiGetPromiscuousFilter: Self = Self(564);
    pub const RespWifiSetPromiscuousCtrlFilter: Self = Self(565);
    pub const RespWifiGetPromiscuousCtrlFilter: Self = Self(566);
    pub const RespWifiApGetStaList: Self = Self(567);
    pub const RespWifiApGetStaAid: Self = Self(568);
    pub const RespWifiSetStorage: Self = Self(569);
    pub const RespWifiSetVendorIe: Self = Self(570);
    pub const RespWifiSetEventMask: Self = Self(571);
    pub const RespWifiGetEventMask: Self = Self(572);
    pub const RespWifi80211Tx: Self = Self(573);
    pub const RespWifiSetCsiConfig: Self = Self(574);
    pub const RespWifiSetCsi: Self = Self(575);
    pub const RespWifiSetAntGpio: Self = Self(576);
    pub const RespWifiGetAntGpio: Self = Self(577);
    pub const RespWifiSetAnt: Self = Self(578);
    pub const RespWifiGetAnt: Self = Self(579);
    pub const RespWifiGetTsfTime: Self = Self(580);
    pub const RespWifiSetInactiveTime: Self = Self(581);
    pub const RespWifiGetInactiveTime: Self = Self(582);
    pub const RespWifiStatisDump: Self = Self(583);
    pub const RespWifiSetRssiThreshold: Self = Self(584);
    pub const RespWifiFtmInitiateSession: Self = Self(585);
    pub const RespWifiFtmEndSession: Self = Self(586);
    pub const RespWifiFtmRespSetOffset: Self = Self(587);
    pub const RespWifiConfig11BRate: Self = Self(588);
    pub const RespWifiConnectionlessModuleSetWakeInterval: Self = Self(589);
    pub const RespWifiSetCountryCode: Self = Self(590);
    pub const RespWifiGetCountryCode: Self = Self(591);
    pub const RespWifiConfig80211TxRate: Self = Self(592);
    pub const RespWifiDisablePmfConfig: Self = Self(593);
    pub const RespWifiStaGetAid: Self = Self(594);
    pub const RespWifiStaGetNegotiatedPhymode: Self = Self(595);
    pub const RespWifiSetDynamicCs: Self = Self(596);
    pub const RespWifiStaGetRssi: Self = Self(597);
    pub const RespWifiSetProtocols: Self = Self(598);
    pub const RespWifiGetProtocols: Self = Self(599);
    pub const RespWifiSetBandwidths: Self = Self(600);
    pub const RespWifiGetBandwidths: Self = Self(601);
    pub const RespWifiSetBand: Self = Self(602);
    pub const RespWifiGetBand: Self = Self(603);
    pub const RespWifiSetBandMode: Self = Self(604);
    pub const RespWifiGetBandMode: Self = Self(605);
    pub const RespGetCoprocessorFwVersion: Self = Self(606);
    pub const RespWifiScanGetApRecord: Self = Self(607);
    pub const RespMax: Self = Self(608);
    pub const EventBase: Self = Self(768);
    pub const EventEspInit: Self = Self(769);
    pub const EventHeartbeat: Self = Self(770);
    pub const EventApStaConnected: Self = Self(771);
    pub const EventApStaDisconnected: Self = Self(772);
    pub const EventWifiEventNoArgs: Self = Self(773);
    pub const EventStaScanDone: Self = Self(774);
    pub const EventStaConnected: Self = Self(775);
    pub const EventStaDisconnected: Self = Self(776);
    pub const EventMax: Self = Self(777);
}
impl core::default::Default for RpcId {
    fn default() -> Self {
        Self(0)
    }
}
impl core::convert::From<i32> for RpcId {
    fn from(val: i32) -> Self {
        Self(val)
    }
}