desklock/firmware/components/esp_hosted/common/proto/esp_hosted_rpc.pb-c.h

/* Generated by the protocol buffer compiler.  DO NOT EDIT! */
/* Generated from: esp_hosted_rpc.proto */

#ifndef PROTOBUF_C_esp_5fhosted_5frpc_2eproto__INCLUDED
#define PROTOBUF_C_esp_5fhosted_5frpc_2eproto__INCLUDED

#include <protobuf-c/protobuf-c.h>

PROTOBUF_C__BEGIN_DECLS

#if PROTOBUF_C_VERSION_NUMBER < 1003000
# error This file was generated by a newer version of protoc-c which is incompatible with your libprotobuf-c headers. Please update your headers.
#elif 1004001 < PROTOBUF_C_MIN_COMPILER_VERSION
# error This file was generated by an older version of protoc-c which is incompatible with your libprotobuf-c headers. Please regenerate this file with a newer version of protoc-c.
#endif


typedef struct WifiInitConfig WifiInitConfig;
typedef struct WifiCountry WifiCountry;
typedef struct WifiActiveScanTime WifiActiveScanTime;
typedef struct WifiScanTime WifiScanTime;
typedef struct WifiScanChannelBitmap WifiScanChannelBitmap;
typedef struct WifiScanConfig WifiScanConfig;
typedef struct WifiScanDefaultParams WifiScanDefaultParams;
typedef struct WifiHeApInfo WifiHeApInfo;
typedef struct WifiApRecord WifiApRecord;
typedef struct WifiScanThreshold WifiScanThreshold;
typedef struct WifiPmfConfig WifiPmfConfig;
typedef struct WifiBssMaxIdleConfig WifiBssMaxIdleConfig;
typedef struct WifiApConfig WifiApConfig;
typedef struct WifiStaConfig WifiStaConfig;
typedef struct WifiConfig WifiConfig;
typedef struct WifiStaInfo WifiStaInfo;
typedef struct WifiStaList WifiStaList;
typedef struct WifiPktRxCtrl WifiPktRxCtrl;
typedef struct WifiPromiscuousPkt WifiPromiscuousPkt;
typedef struct WifiPromiscuousFilter WifiPromiscuousFilter;
typedef struct WifiCsiConfig WifiCsiConfig;
typedef struct WifiCsiInfo WifiCsiInfo;
typedef struct WifiAntGpio WifiAntGpio;
typedef struct WifiAntGpioConfig WifiAntGpioConfig;
typedef struct WifiAntConfig WifiAntConfig;
typedef struct WifiActionTxReq WifiActionTxReq;
typedef struct WifiFtmInitiatorCfg WifiFtmInitiatorCfg;
typedef struct WifiEventStaScanDone WifiEventStaScanDone;
typedef struct WifiEventStaConnected WifiEventStaConnected;
typedef struct WifiEventStaDisconnected WifiEventStaDisconnected;
typedef struct WifiEventStaAuthmodeChange WifiEventStaAuthmodeChange;
typedef struct WifiEventStaWpsErPin WifiEventStaWpsErPin;
typedef struct ApCred ApCred;
typedef struct WifiEventStaWpsErSuccess WifiEventStaWpsErSuccess;
typedef struct WifiEventApProbeReqRx WifiEventApProbeReqRx;
typedef struct WifiEventBssRssiLow WifiEventBssRssiLow;
typedef struct WifiFtmReportEntry WifiFtmReportEntry;
typedef struct WifiEventFtmReport WifiEventFtmReport;
typedef struct WifiEventActionTxStatus WifiEventActionTxStatus;
typedef struct WifiEventRocDone WifiEventRocDone;
typedef struct WifiEventApWpsRgPin WifiEventApWpsRgPin;
typedef struct WifiEventApWpsRgFailReason WifiEventApWpsRgFailReason;
typedef struct WifiEventApWpsRgSuccess WifiEventApWpsRgSuccess;
typedef struct WifiProtocols WifiProtocols;
typedef struct WifiBandwidths WifiBandwidths;
typedef struct WifiItwtSetupConfig WifiItwtSetupConfig;
typedef struct WifiTwtConfig WifiTwtConfig;
typedef struct EspAppDesc EspAppDesc;
typedef struct HeapSizeThreshold HeapSizeThreshold;
typedef struct MemInfo MemInfo;
typedef struct HeapInfo HeapInfo;
typedef struct ConnectedSTAList ConnectedSTAList;
typedef struct EapFastConfig EapFastConfig;
typedef struct RpcReqGetMacAddress RpcReqGetMacAddress;
typedef struct RpcRespGetMacAddress RpcRespGetMacAddress;
typedef struct RpcReqGetMode RpcReqGetMode;
typedef struct RpcRespGetMode RpcRespGetMode;
typedef struct RpcReqSetMode RpcReqSetMode;
typedef struct RpcRespSetMode RpcRespSetMode;
typedef struct RpcReqGetPs RpcReqGetPs;
typedef struct RpcRespGetPs RpcRespGetPs;
typedef struct RpcReqSetPs RpcReqSetPs;
typedef struct RpcRespSetPs RpcRespSetPs;
typedef struct RpcReqSetMacAddress RpcReqSetMacAddress;
typedef struct RpcRespSetMacAddress RpcRespSetMacAddress;
typedef struct RpcReqOTABegin RpcReqOTABegin;
typedef struct RpcRespOTABegin RpcRespOTABegin;
typedef struct RpcReqOTAWrite RpcReqOTAWrite;
typedef struct RpcRespOTAWrite RpcRespOTAWrite;
typedef struct RpcReqOTAEnd RpcReqOTAEnd;
typedef struct RpcRespOTAEnd RpcRespOTAEnd;
typedef struct RpcReqOTAActivate RpcReqOTAActivate;
typedef struct RpcRespOTAActivate RpcRespOTAActivate;
typedef struct RpcReqAppGetDesc RpcReqAppGetDesc;
typedef struct RpcRespAppGetDesc RpcRespAppGetDesc;
typedef struct RpcReqWifiSetMaxTxPower RpcReqWifiSetMaxTxPower;
typedef struct RpcRespWifiSetMaxTxPower RpcRespWifiSetMaxTxPower;
typedef struct RpcReqWifiGetMaxTxPower RpcReqWifiGetMaxTxPower;
typedef struct RpcRespWifiGetMaxTxPower RpcRespWifiGetMaxTxPower;
typedef struct RpcReqConfigHeartbeat RpcReqConfigHeartbeat;
typedef struct RpcRespConfigHeartbeat RpcRespConfigHeartbeat;
typedef struct RpcReqWifiInit RpcReqWifiInit;
typedef struct RpcRespWifiInit RpcRespWifiInit;
typedef struct RpcReqWifiDeinit RpcReqWifiDeinit;
typedef struct RpcRespWifiDeinit RpcRespWifiDeinit;
typedef struct RpcReqWifiSetConfig RpcReqWifiSetConfig;
typedef struct RpcRespWifiSetConfig RpcRespWifiSetConfig;
typedef struct RpcReqWifiGetConfig RpcReqWifiGetConfig;
typedef struct RpcRespWifiGetConfig RpcRespWifiGetConfig;
typedef struct RpcReqWifiConnect RpcReqWifiConnect;
typedef struct RpcRespWifiConnect RpcRespWifiConnect;
typedef struct RpcReqWifiDisconnect RpcReqWifiDisconnect;
typedef struct RpcRespWifiDisconnect RpcRespWifiDisconnect;
typedef struct RpcReqWifiStart RpcReqWifiStart;
typedef struct RpcRespWifiStart RpcRespWifiStart;
typedef struct RpcReqWifiStop RpcReqWifiStop;
typedef struct RpcRespWifiStop RpcRespWifiStop;
typedef struct RpcReqWifiScanStart RpcReqWifiScanStart;
typedef struct RpcRespWifiScanStart RpcRespWifiScanStart;
typedef struct RpcReqWifiScanStop RpcReqWifiScanStop;
typedef struct RpcRespWifiScanStop RpcRespWifiScanStop;
typedef struct RpcReqWifiScanGetApNum RpcReqWifiScanGetApNum;
typedef struct RpcRespWifiScanGetApNum RpcRespWifiScanGetApNum;
typedef struct RpcReqWifiScanGetApRecords RpcReqWifiScanGetApRecords;
typedef struct RpcRespWifiScanGetApRecords RpcRespWifiScanGetApRecords;
typedef struct RpcReqWifiScanGetApRecord RpcReqWifiScanGetApRecord;
typedef struct RpcRespWifiScanGetApRecord RpcRespWifiScanGetApRecord;
typedef struct RpcReqWifiClearApList RpcReqWifiClearApList;
typedef struct RpcRespWifiClearApList RpcRespWifiClearApList;
typedef struct RpcReqWifiRestore RpcReqWifiRestore;
typedef struct RpcRespWifiRestore RpcRespWifiRestore;
typedef struct RpcReqWifiClearFastConnect RpcReqWifiClearFastConnect;
typedef struct RpcRespWifiClearFastConnect RpcRespWifiClearFastConnect;
typedef struct RpcReqWifiDeauthSta RpcReqWifiDeauthSta;
typedef struct RpcRespWifiDeauthSta RpcRespWifiDeauthSta;
typedef struct RpcReqWifiStaGetApInfo RpcReqWifiStaGetApInfo;
typedef struct RpcRespWifiStaGetApInfo RpcRespWifiStaGetApInfo;
typedef struct RpcReqWifiSetProtocol RpcReqWifiSetProtocol;
typedef struct RpcRespWifiSetProtocol RpcRespWifiSetProtocol;
typedef struct RpcReqWifiGetProtocol RpcReqWifiGetProtocol;
typedef struct RpcRespWifiGetProtocol RpcRespWifiGetProtocol;
typedef struct RpcReqWifiSetBandwidth RpcReqWifiSetBandwidth;
typedef struct RpcRespWifiSetBandwidth RpcRespWifiSetBandwidth;
typedef struct RpcReqWifiGetBandwidth RpcReqWifiGetBandwidth;
typedef struct RpcRespWifiGetBandwidth RpcRespWifiGetBandwidth;
typedef struct RpcReqWifiSetChannel RpcReqWifiSetChannel;
typedef struct RpcRespWifiSetChannel RpcRespWifiSetChannel;
typedef struct RpcReqWifiGetChannel RpcReqWifiGetChannel;
typedef struct RpcRespWifiGetChannel RpcRespWifiGetChannel;
typedef struct RpcReqWifiSetStorage RpcReqWifiSetStorage;
typedef struct RpcRespWifiSetStorage RpcRespWifiSetStorage;
typedef struct RpcReqWifiSetCountryCode RpcReqWifiSetCountryCode;
typedef struct RpcRespWifiSetCountryCode RpcRespWifiSetCountryCode;
typedef struct RpcReqWifiGetCountryCode RpcReqWifiGetCountryCode;
typedef struct RpcRespWifiGetCountryCode RpcRespWifiGetCountryCode;
typedef struct RpcReqWifiSetCountry RpcReqWifiSetCountry;
typedef struct RpcRespWifiSetCountry RpcRespWifiSetCountry;
typedef struct RpcReqWifiGetCountry RpcReqWifiGetCountry;
typedef struct RpcRespWifiGetCountry RpcRespWifiGetCountry;
typedef struct RpcReqWifiApGetStaList RpcReqWifiApGetStaList;
typedef struct RpcRespWifiApGetStaList RpcRespWifiApGetStaList;
typedef struct RpcReqWifiApGetStaAid RpcReqWifiApGetStaAid;
typedef struct RpcReqWifiStaGetNegotiatedPhymode RpcReqWifiStaGetNegotiatedPhymode;
typedef struct RpcRespWifiStaGetNegotiatedPhymode RpcRespWifiStaGetNegotiatedPhymode;
typedef struct RpcRespWifiApGetStaAid RpcRespWifiApGetStaAid;
typedef struct RpcReqWifiStaGetRssi RpcReqWifiStaGetRssi;
typedef struct RpcRespWifiStaGetRssi RpcRespWifiStaGetRssi;
typedef struct RpcReqWifiScanParams RpcReqWifiScanParams;
typedef struct RpcRespWifiScanParams RpcRespWifiScanParams;
typedef struct RpcReqWifiStaGetAid RpcReqWifiStaGetAid;
typedef struct RpcRespWifiStaGetAid RpcRespWifiStaGetAid;
typedef struct RpcReqWifiSetProtocols RpcReqWifiSetProtocols;
typedef struct RpcRespWifiSetProtocols RpcRespWifiSetProtocols;
typedef struct RpcReqWifiGetProtocols RpcReqWifiGetProtocols;
typedef struct RpcRespWifiGetProtocols RpcRespWifiGetProtocols;
typedef struct RpcReqWifiSetBandwidths RpcReqWifiSetBandwidths;
typedef struct RpcRespWifiSetBandwidths RpcRespWifiSetBandwidths;
typedef struct RpcReqWifiGetBandwidths RpcReqWifiGetBandwidths;
typedef struct RpcRespWifiGetBandwidths RpcRespWifiGetBandwidths;
typedef struct RpcReqWifiSetBand RpcReqWifiSetBand;
typedef struct RpcRespWifiSetBand RpcRespWifiSetBand;
typedef struct RpcReqWifiGetBand RpcReqWifiGetBand;
typedef struct RpcRespWifiGetBand RpcRespWifiGetBand;
typedef struct RpcReqWifiSetBandMode RpcReqWifiSetBandMode;
typedef struct RpcRespWifiSetBandMode RpcRespWifiSetBandMode;
typedef struct RpcReqWifiGetBandMode RpcReqWifiGetBandMode;
typedef struct RpcRespWifiGetBandMode RpcRespWifiGetBandMode;
typedef struct RpcReqWifiSetInactiveTime RpcReqWifiSetInactiveTime;
typedef struct RpcRespWifiSetInactiveTime RpcRespWifiSetInactiveTime;
typedef struct RpcReqWifiGetInactiveTime RpcReqWifiGetInactiveTime;
typedef struct RpcRespWifiGetInactiveTime RpcRespWifiGetInactiveTime;
typedef struct RpcReqWifiDisablePmfConfig RpcReqWifiDisablePmfConfig;
typedef struct RpcRespWifiDisablePmfConfig RpcRespWifiDisablePmfConfig;
typedef struct RpcReqWifiStaItwtSetup RpcReqWifiStaItwtSetup;
typedef struct RpcRespWifiStaItwtSetup RpcRespWifiStaItwtSetup;
typedef struct RpcReqWifiStaItwtTeardown RpcReqWifiStaItwtTeardown;
typedef struct RpcRespWifiStaItwtTeardown RpcRespWifiStaItwtTeardown;
typedef struct RpcReqWifiStaItwtSuspend RpcReqWifiStaItwtSuspend;
typedef struct RpcRespWifiStaItwtSuspend RpcRespWifiStaItwtSuspend;
typedef struct RpcReqWifiStaItwtGetFlowIdStatus RpcReqWifiStaItwtGetFlowIdStatus;
typedef struct RpcRespWifiStaItwtGetFlowIdStatus RpcRespWifiStaItwtGetFlowIdStatus;
typedef struct RpcReqWifiStaItwtSendProbeReq RpcReqWifiStaItwtSendProbeReq;
typedef struct RpcRespWifiStaItwtSendProbeReq RpcRespWifiStaItwtSendProbeReq;
typedef struct RpcReqWifiStaItwtSetTargetWakeTimeOffset RpcReqWifiStaItwtSetTargetWakeTimeOffset;
typedef struct RpcRespWifiStaItwtSetTargetWakeTimeOffset RpcRespWifiStaItwtSetTargetWakeTimeOffset;
typedef struct RpcReqWifiStaTwtConfig RpcReqWifiStaTwtConfig;
typedef struct RpcRespWifiStaTwtConfig RpcRespWifiStaTwtConfig;
typedef struct RpcReqGetCoprocessorFwVersion RpcReqGetCoprocessorFwVersion;
typedef struct RpcRespGetCoprocessorFwVersion RpcRespGetCoprocessorFwVersion;
typedef struct RpcReqSetDhcpDnsStatus RpcReqSetDhcpDnsStatus;
typedef struct RpcRespSetDhcpDnsStatus RpcRespSetDhcpDnsStatus;
typedef struct RpcReqGetDhcpDnsStatus RpcReqGetDhcpDnsStatus;
typedef struct RpcRespGetDhcpDnsStatus RpcRespGetDhcpDnsStatus;
typedef struct RpcReqSuppDppInit RpcReqSuppDppInit;
typedef struct RpcRespSuppDppInit RpcRespSuppDppInit;
typedef struct RpcReqSuppDppDeinit RpcReqSuppDppDeinit;
typedef struct RpcRespSuppDppDeinit RpcRespSuppDppDeinit;
typedef struct RpcReqSuppDppBootstrapGen RpcReqSuppDppBootstrapGen;
typedef struct RpcRespSuppDppBootstrapGen RpcRespSuppDppBootstrapGen;
typedef struct RpcReqSuppDppStartListen RpcReqSuppDppStartListen;
typedef struct RpcRespSuppDppStartListen RpcRespSuppDppStartListen;
typedef struct RpcReqSuppDppStopListen RpcReqSuppDppStopListen;
typedef struct RpcRespSuppDppStopListen RpcRespSuppDppStopListen;
typedef struct RpcReqIfaceMacAddrSetGet RpcReqIfaceMacAddrSetGet;
typedef struct RpcRespIfaceMacAddrSetGet RpcRespIfaceMacAddrSetGet;
typedef struct RpcReqIfaceMacAddrLenGet RpcReqIfaceMacAddrLenGet;
typedef struct RpcRespIfaceMacAddrLenGet RpcRespIfaceMacAddrLenGet;
typedef struct RpcReqFeatureControl RpcReqFeatureControl;
typedef struct RpcRespFeatureControl RpcRespFeatureControl;
typedef struct RpcReqMemMonitor RpcReqMemMonitor;
typedef struct RpcRespMemMonitor RpcRespMemMonitor;
typedef struct RpcEventWifiEventNoArgs RpcEventWifiEventNoArgs;
typedef struct RpcEventESPInit RpcEventESPInit;
typedef struct RpcEventHeartbeat RpcEventHeartbeat;
typedef struct RpcEventAPStaDisconnected RpcEventAPStaDisconnected;
typedef struct RpcEventAPStaConnected RpcEventAPStaConnected;
typedef struct RpcEventStaScanDone RpcEventStaScanDone;
typedef struct RpcEventStaConnected RpcEventStaConnected;
typedef struct RpcEventStaDisconnected RpcEventStaDisconnected;
typedef struct RpcGpioConfig RpcGpioConfig;
typedef struct RpcReqGpioConfig RpcReqGpioConfig;
typedef struct RpcRespGpioConfig RpcRespGpioConfig;
typedef struct RpcReqGpioResetPin RpcReqGpioResetPin;
typedef struct RpcRespGpioResetPin RpcRespGpioResetPin;
typedef struct RpcReqGpioSetLevel RpcReqGpioSetLevel;
typedef struct RpcRespGpioSetLevel RpcRespGpioSetLevel;
typedef struct RpcReqGpioGetLevel RpcReqGpioGetLevel;
typedef struct RpcRespGpioGetLevel RpcRespGpioGetLevel;
typedef struct RpcReqGpioSetDirection RpcReqGpioSetDirection;
typedef struct RpcRespGpioSetDirection RpcRespGpioSetDirection;
typedef struct RpcReqGpioInputEnable RpcReqGpioInputEnable;
typedef struct RpcRespGpioInputEnable RpcRespGpioInputEnable;
typedef struct RpcReqGpioSetPullMode RpcReqGpioSetPullMode;
typedef struct RpcRespGpioSetPullMode RpcRespGpioSetPullMode;
typedef struct RpcReqExtCoex RpcReqExtCoex;
typedef struct RpcRespExtCoex RpcRespExtCoex;
typedef struct RpcEventDhcpDnsStatus RpcEventDhcpDnsStatus;
typedef struct RpcEventStaItwtSetup RpcEventStaItwtSetup;
typedef struct RpcEventStaItwtTeardown RpcEventStaItwtTeardown;
typedef struct RpcEventStaItwtSuspend RpcEventStaItwtSuspend;
typedef struct RpcEventStaItwtProbe RpcEventStaItwtProbe;
typedef struct RpcReqWifiStaEnterpriseEnable RpcReqWifiStaEnterpriseEnable;
typedef struct RpcRespWifiStaEnterpriseEnable RpcRespWifiStaEnterpriseEnable;
typedef struct RpcReqWifiStaEnterpriseDisable RpcReqWifiStaEnterpriseDisable;
typedef struct RpcRespWifiStaEnterpriseDisable RpcRespWifiStaEnterpriseDisable;
typedef struct RpcReqEapSetIdentity RpcReqEapSetIdentity;
typedef struct RpcRespEapSetIdentity RpcRespEapSetIdentity;
typedef struct RpcReqEapClearIdentity RpcReqEapClearIdentity;
typedef struct RpcRespEapClearIdentity RpcRespEapClearIdentity;
typedef struct RpcReqEapSetUsername RpcReqEapSetUsername;
typedef struct RpcRespEapSetUsername RpcRespEapSetUsername;
typedef struct RpcReqEapClearUsername RpcReqEapClearUsername;
typedef struct RpcRespEapClearUsername RpcRespEapClearUsername;
typedef struct RpcReqEapSetPassword RpcReqEapSetPassword;
typedef struct RpcRespEapSetPassword RpcRespEapSetPassword;
typedef struct RpcReqEapClearPassword RpcReqEapClearPassword;
typedef struct RpcRespEapClearPassword RpcRespEapClearPassword;
typedef struct RpcReqEapSetNewPassword RpcReqEapSetNewPassword;
typedef struct RpcRespEapSetNewPassword RpcRespEapSetNewPassword;
typedef struct RpcReqEapClearNewPassword RpcReqEapClearNewPassword;
typedef struct RpcRespEapClearNewPassword RpcRespEapClearNewPassword;
typedef struct RpcReqEapSetCaCert RpcReqEapSetCaCert;
typedef struct RpcRespEapSetCaCert RpcRespEapSetCaCert;
typedef struct RpcReqEapClearCaCert RpcReqEapClearCaCert;
typedef struct RpcRespEapClearCaCert RpcRespEapClearCaCert;
typedef struct RpcReqEapSetCertificateAndKey RpcReqEapSetCertificateAndKey;
typedef struct RpcRespEapSetCertificateAndKey RpcRespEapSetCertificateAndKey;
typedef struct RpcReqEapClearCertificateAndKey RpcReqEapClearCertificateAndKey;
typedef struct RpcRespEapClearCertificateAndKey RpcRespEapClearCertificateAndKey;
typedef struct RpcReqEapSetDisableTimeCheck RpcReqEapSetDisableTimeCheck;
typedef struct RpcRespEapSetDisableTimeCheck RpcRespEapSetDisableTimeCheck;
typedef struct RpcReqEapGetDisableTimeCheck RpcReqEapGetDisableTimeCheck;
typedef struct RpcRespEapGetDisableTimeCheck RpcRespEapGetDisableTimeCheck;
typedef struct RpcReqEapSetTtlsPhase2Method RpcReqEapSetTtlsPhase2Method;
typedef struct RpcRespEapSetTtlsPhase2Method RpcRespEapSetTtlsPhase2Method;
typedef struct RpcReqEapSetSuiteb192bitCertification RpcReqEapSetSuiteb192bitCertification;
typedef struct RpcRespEapSetSuiteb192bitCertification RpcRespEapSetSuiteb192bitCertification;
typedef struct RpcReqEapSetPacFile RpcReqEapSetPacFile;
typedef struct RpcRespEapSetPacFile RpcRespEapSetPacFile;
typedef struct RpcReqEapSetFastParams RpcReqEapSetFastParams;
typedef struct RpcRespEapSetFastParams RpcRespEapSetFastParams;
typedef struct RpcReqEapUseDefaultCertBundle RpcReqEapUseDefaultCertBundle;
typedef struct RpcRespEapUseDefaultCertBundle RpcRespEapUseDefaultCertBundle;
typedef struct RpcReqWifiSetOkcSupport RpcReqWifiSetOkcSupport;
typedef struct RpcRespWifiSetOkcSupport RpcRespWifiSetOkcSupport;
typedef struct RpcReqEapSetDomainName RpcReqEapSetDomainName;
typedef struct RpcRespEapSetDomainName RpcRespEapSetDomainName;
typedef struct RpcReqEapSetEapMethods RpcReqEapSetEapMethods;
typedef struct RpcRespEapSetEapMethods RpcRespEapSetEapMethods;
typedef struct RpcEventSuppDppUriReady RpcEventSuppDppUriReady;
typedef struct RpcEventSuppDppCfgRecvd RpcEventSuppDppCfgRecvd;
typedef struct RpcEventSuppDppFail RpcEventSuppDppFail;
typedef struct RpcEventWifiDppUriReady RpcEventWifiDppUriReady;
typedef struct RpcEventWifiDppCfgRecvd RpcEventWifiDppCfgRecvd;
typedef struct RpcEventWifiDppFail RpcEventWifiDppFail;
typedef struct RpcReqCustomRpc RpcReqCustomRpc;
typedef struct RpcRespCustomRpc RpcRespCustomRpc;
typedef struct RpcEventCustomRpc RpcEventCustomRpc;
typedef struct RpcEventMemMonitor RpcEventMemMonitor;
typedef struct Rpc Rpc;


/* --- enums --- */

typedef enum _RpcWifiBw {
  RPC__WIFI_BW__BW_Invalid = 0,
  RPC__WIFI_BW__HT20 = 1,
  RPC__WIFI_BW__HT40 = 2
    PROTOBUF_C__FORCE_ENUM_TO_BE_INT_SIZE(RPC__WIFI_BW)
} RpcWifiBw;
typedef enum _RpcWifiPowerSave {
  RPC__WIFI_POWER_SAVE__PS_Invalid = 0,
  RPC__WIFI_POWER_SAVE__MIN_MODEM = 1,
  RPC__WIFI_POWER_SAVE__MAX_MODEM = 2
    PROTOBUF_C__FORCE_ENUM_TO_BE_INT_SIZE(RPC__WIFI_POWER_SAVE)
} RpcWifiPowerSave;
typedef enum _RpcWifiSecProt {
  RPC__WIFI_SEC_PROT__Open = 0,
  RPC__WIFI_SEC_PROT__WEP = 1,
  RPC__WIFI_SEC_PROT__WPA_PSK = 2,
  RPC__WIFI_SEC_PROT__WPA2_PSK = 3,
  RPC__WIFI_SEC_PROT__WPA_WPA2_PSK = 4,
  RPC__WIFI_SEC_PROT__WPA2_ENTERPRISE = 5,
  RPC__WIFI_SEC_PROT__WPA3_PSK = 6,
  RPC__WIFI_SEC_PROT__WPA2_WPA3_PSK = 7
    PROTOBUF_C__FORCE_ENUM_TO_BE_INT_SIZE(RPC__WIFI_SEC_PROT)
} RpcWifiSecProt;
/*
 * enums for Control path 
 */
typedef enum _RpcStatus {
  RPC__STATUS__Connected = 0,
  RPC__STATUS__Not_Connected = 1,
  RPC__STATUS__No_AP_Found = 2,
  RPC__STATUS__Connection_Fail = 3,
  RPC__STATUS__Invalid_Argument = 4,
  RPC__STATUS__Out_Of_Range = 5
    PROTOBUF_C__FORCE_ENUM_TO_BE_INT_SIZE(RPC__STATUS)
} RpcStatus;
typedef enum _RpcCmd {
  RPC_CMD__Invalid = 0,
  RPC_CMD__Get = 1,
  RPC_CMD__Set = 2
    PROTOBUF_C__FORCE_ENUM_TO_BE_INT_SIZE(RPC_CMD)
} RpcCmd;
typedef enum _RpcType {
  RPC_TYPE__MsgType_Invalid = 0,
  RPC_TYPE__Req = 1,
  RPC_TYPE__Resp = 2,
  RPC_TYPE__Event = 3,
  RPC_TYPE__MsgType_Max = 4
    PROTOBUF_C__FORCE_ENUM_TO_BE_INT_SIZE(RPC_TYPE)
} RpcType;
typedef enum _RpcFeature {
  RPC_FEATURE__Feature_None = 0,
  /*
   * Bluetooth (BT) Feature
   */
  RPC_FEATURE__Feature_Bluetooth = 1,
  /*
   * OpenThread RCP (Radio Co-processor) Feature
   */
  /*
   * add additional features here
   */
  RPC_FEATURE__Feature_Openthread_Rcp = 2
    PROTOBUF_C__FORCE_ENUM_TO_BE_INT_SIZE(RPC_FEATURE)
} RpcFeature;
typedef enum _RpcFeatureCommand {
  RPC_FEATURE_COMMAND__Feature_Command_None = 0,
  /*
   * Bluetooth (BT) Feature Commands
   */
  RPC_FEATURE_COMMAND__Feature_Command_BT_Init = 1,
  RPC_FEATURE_COMMAND__Feature_Command_BT_Deinit = 2,
  RPC_FEATURE_COMMAND__Feature_Command_BT_Enable = 3,
  RPC_FEATURE_COMMAND__Feature_Command_BT_Disable = 4,
  /*
   * Generic Feature Commands. Currently used for:
   * - OpenThread (OT)
   */
  RPC_FEATURE_COMMAND__Feature_Command_Init = 5,
  RPC_FEATURE_COMMAND__Feature_Command_Deinit = 6,
  RPC_FEATURE_COMMAND__Feature_Command_Enable = 7,
  RPC_FEATURE_COMMAND__Feature_Command_Disable = 8,
  /*
   * add additional feature commands here
   */
  RPC_FEATURE_COMMAND__Feature_Command_Query = 9
    PROTOBUF_C__FORCE_ENUM_TO_BE_INT_SIZE(RPC_FEATURE_COMMAND)
} RpcFeatureCommand;
typedef enum _RpcFeatureOption {
  RPC_FEATURE_OPTION__Feature_Option_None = 0,
  /*
   * Bluetooth (BT) Feature Options
   */
  /*
   * release memory when deinit BT
   */
  RPC_FEATURE_OPTION__Feature_Option_BT_Deinit_Release_Memory = 1,
  /*
   * Generic Queries. Currently used for:
   * - OpenThread (OT)
   */
  /*
   * is the feature configured (via Kconfig)
   */
  RPC_FEATURE_OPTION__Feature_Option_Query_Configured = 2,
  /*
   * is the feature initialised
   */
  RPC_FEATURE_OPTION__Feature_Option_Query_Inited = 3,
  /*
   * is the feature enabled
   */
  RPC_FEATURE_OPTION__Feature_Option_Query_Enabled = 4,
  /*
   * is the feature ready
   */
  RPC_FEATURE_OPTION__Feature_Option_Query_Ready = 5
    PROTOBUF_C__FORCE_ENUM_TO_BE_INT_SIZE(RPC_FEATURE_OPTION)
} RpcFeatureOption;
typedef enum _RpcId {
  RPC_ID__MsgId_Invalid = 0,
  /*
   ** Request Msgs *
   */
  /*
   *0x100
   */
  RPC_ID__Req_Base = 256,
  /*
   *0x101
   */
  RPC_ID__Req_GetMACAddress = 257,
  /*
   *0x102
   */
  RPC_ID__Req_SetMacAddress = 258,
  /*
   *0x103
   */
  RPC_ID__Req_GetWifiMode = 259,
  /*
   *0x104
   */
  RPC_ID__Req_SetWifiMode = 260,
  /*
   *0x105
   */
  RPC_ID__Req_SuppDppInit = 261,
  /*
   *0x106
   */
  RPC_ID__Req_SuppDppDeinit = 262,
  /*
   *0x107
   */
  RPC_ID__Req_SuppDppBootstrapGen = 263,
  /*
   *0x108
   */
  RPC_ID__Req_SuppDppStartListen = 264,
  /*
   *0x109
   */
  RPC_ID__Req_SuppDppStopListen = 265,
  /*
   *0x10a
   */
  RPC_ID__Req_OTAActivate = 266,
  /*
   *0x10b
   */
  RPC_ID__Req_AppGetDesc = 267,
  /*
   *0x10c
   */
  RPC_ID__Req_MemMonitor = 268,
  /*
   *0x10d
   */
  RPC_ID__Req_WifiScanParams = 269,
  /*
   *0x10e
   */
  RPC_ID__Req_WifiSetPs = 270,
  /*
   *0x10f
   */
  RPC_ID__Req_WifiGetPs = 271,
  /*
   *0x110
   */
  RPC_ID__Req_OTABegin = 272,
  /*
   *0x111
   */
  RPC_ID__Req_OTAWrite = 273,
  /*
   *0x112
   */
  RPC_ID__Req_OTAEnd = 274,
  /*
   *0x113
   */
  RPC_ID__Req_WifiSetMaxTxPower = 275,
  /*
   *0x114
   */
  RPC_ID__Req_WifiGetMaxTxPower = 276,
  /*
   *0x115
   */
  RPC_ID__Req_ConfigHeartbeat = 277,
  /*
   *0x116
   */
  RPC_ID__Req_WifiInit = 278,
  /*
   *0x117
   */
  RPC_ID__Req_WifiDeinit = 279,
  /*
   *0x118
   */
  RPC_ID__Req_WifiStart = 280,
  /*
   *0x119
   */
  RPC_ID__Req_WifiStop = 281,
  /*
   *0x11a
   */
  RPC_ID__Req_WifiConnect = 282,
  /*
   *0x11b
   */
  RPC_ID__Req_WifiDisconnect = 283,
  /*
   *0x11c
   */
  RPC_ID__Req_WifiSetConfig = 284,
  /*
   *0x11d
   */
  RPC_ID__Req_WifiGetConfig = 285,
  /*
   *0x11e
   */
  RPC_ID__Req_WifiScanStart = 286,
  /*
   *0x11f
   */
  RPC_ID__Req_WifiScanStop = 287,
  /*
   *0x120
   */
  RPC_ID__Req_WifiScanGetApNum = 288,
  /*
   *0x121
   */
  RPC_ID__Req_WifiScanGetApRecords = 289,
  /*
   *0x122
   */
  RPC_ID__Req_WifiClearApList = 290,
  /*
   *0x123
   */
  RPC_ID__Req_WifiRestore = 291,
  /*
   *0x124
   */
  RPC_ID__Req_WifiClearFastConnect = 292,
  /*
   *0x125
   */
  RPC_ID__Req_WifiDeauthSta = 293,
  /*
   *0x126
   */
  RPC_ID__Req_WifiStaGetApInfo = 294,
  /*
   *Req_WifiSetPs                     = 295; //0x127
   *Req_WifiGetPs                     = 296; //0x128
   */
  /*
   *0x129
   */
  RPC_ID__Req_WifiSetProtocol = 297,
  /*
   *0x12a
   */
  RPC_ID__Req_WifiGetProtocol = 298,
  /*
   *0x12b
   */
  RPC_ID__Req_WifiSetBandwidth = 299,
  /*
   *0x12c
   */
  RPC_ID__Req_WifiGetBandwidth = 300,
  /*
   *0x12d
   */
  RPC_ID__Req_WifiSetChannel = 301,
  /*
   *0x12e
   */
  RPC_ID__Req_WifiGetChannel = 302,
  /*
   *0x12f
   */
  RPC_ID__Req_WifiSetCountry = 303,
  /*
   *0x130
   */
  RPC_ID__Req_WifiGetCountry = 304,
  /*
   *  Req_WifiSetPromiscuousRxCb        = 305; //0x131
   */
  /*
   *0x131
   */
  RPC_ID__Req_WifiSetPromiscuous = 305,
  /*
   *0x132
   */
  RPC_ID__Req_WifiGetPromiscuous = 306,
  /*
   *0x133
   */
  RPC_ID__Req_WifiSetPromiscuousFilter = 307,
  /*
   *0x134
   */
  RPC_ID__Req_WifiGetPromiscuousFilter = 308,
  /*
   *0x135
   */
  RPC_ID__Req_WifiSetPromiscuousCtrlFilter = 309,
  /*
   *0x136
   */
  RPC_ID__Req_WifiGetPromiscuousCtrlFilter = 310,
  /*
   *0x137
   */
  RPC_ID__Req_WifiApGetStaList = 311,
  /*
   *0x138
   */
  RPC_ID__Req_WifiApGetStaAid = 312,
  /*
   *0x139
   */
  RPC_ID__Req_WifiSetStorage = 313,
  /*
   *0x13a
   */
  RPC_ID__Req_WifiSetVendorIe = 314,
  /*
   *  Req_WifiSetVendorIeCb             = 315; //0x13b
   */
  /*
   *0x13b
   */
  RPC_ID__Req_WifiSetEventMask = 315,
  /*
   *0x13c
   */
  RPC_ID__Req_WifiGetEventMask = 316,
  /*
   *0x13d
   */
  RPC_ID__Req_Wifi80211Tx = 317,
  /*
   *	Req_WifiSetCsiRxCb                = 318; //0x13e
   */
  /*
   *0x13e
   */
  RPC_ID__Req_WifiSetCsiConfig = 318,
  /*
   *0x13f
   */
  RPC_ID__Req_WifiSetCsi = 319,
  /*
   *0x140
   */
  RPC_ID__Req_WifiSetAntGpio = 320,
  /*
   *0x141
   */
  RPC_ID__Req_WifiGetAntGpio = 321,
  /*
   *0x142
   */
  RPC_ID__Req_WifiSetAnt = 322,
  /*
   *0x143
   */
  RPC_ID__Req_WifiGetAnt = 323,
  /*
   *0x144
   */
  RPC_ID__Req_WifiGetTsfTime = 324,
  /*
   *0x145
   */
  RPC_ID__Req_WifiSetInactiveTime = 325,
  /*
   *0x146
   */
  RPC_ID__Req_WifiGetInactiveTime = 326,
  /*
   *0x147
   */
  RPC_ID__Req_WifiStatisDump = 327,
  /*
   *0x148
   */
  RPC_ID__Req_WifiSetRssiThreshold = 328,
  /*
   *0x149
   */
  RPC_ID__Req_WifiFtmInitiateSession = 329,
  /*
   *0x14a
   */
  RPC_ID__Req_WifiFtmEndSession = 330,
  /*
   *0x14b
   */
  RPC_ID__Req_WifiFtmRespSetOffset = 331,
  /*
   *0x14c
   */
  RPC_ID__Req_WifiConfig11bRate = 332,
  /*
   *0x14d
   */
  RPC_ID__Req_WifiConnectionlessModuleSetWakeInterval = 333,
  /*
   *0x14e
   */
  RPC_ID__Req_WifiSetCountryCode = 334,
  /*
   *0x14f
   */
  RPC_ID__Req_WifiGetCountryCode = 335,
  /*
   *0x150
   */
  RPC_ID__Req_WifiConfig80211TxRate = 336,
  /*
   *0x151
   */
  RPC_ID__Req_WifiDisablePmfConfig = 337,
  /*
   *0x152
   */
  RPC_ID__Req_WifiStaGetAid = 338,
  /*
   *0x153
   */
  RPC_ID__Req_WifiStaGetNegotiatedPhymode = 339,
  /*
   *0x154
   */
  RPC_ID__Req_WifiSetDynamicCs = 340,
  /*
   *0x155
   */
  RPC_ID__Req_WifiStaGetRssi = 341,
  /*
   *0x156
   */
  RPC_ID__Req_WifiSetProtocols = 342,
  /*
   *0x157
   */
  RPC_ID__Req_WifiGetProtocols = 343,
  /*
   *0x158
   */
  RPC_ID__Req_WifiSetBandwidths = 344,
  /*
   *0x159
   */
  RPC_ID__Req_WifiGetBandwidths = 345,
  /*
   *0x15a
   */
  RPC_ID__Req_WifiSetBand = 346,
  /*
   *0x15b
   */
  RPC_ID__Req_WifiGetBand = 347,
  /*
   *0x15c
   */
  RPC_ID__Req_WifiSetBandMode = 348,
  /*
   *0x15d
   */
  RPC_ID__Req_WifiGetBandMode = 349,
  /*
   *0x15e
   */
  RPC_ID__Req_GetCoprocessorFwVersion = 350,
  /*
   *0x15f
   */
  RPC_ID__Req_WifiScanGetApRecord = 351,
  /*
   *0x160
   */
  RPC_ID__Req_SetDhcpDnsStatus = 352,
  /*
   *0x161
   */
  RPC_ID__Req_GetDhcpDnsStatus = 353,
  /*
   *0x162
   */
  RPC_ID__Req_WifiStaTwtConfig = 354,
  /*
   *0x163
   */
  RPC_ID__Req_WifiStaItwtSetup = 355,
  /*
   *0x164
   */
  RPC_ID__Req_WifiStaItwtTeardown = 356,
  /*
   *0x165
   */
  RPC_ID__Req_WifiStaItwtSuspend = 357,
  /*
   *0x166
   */
  RPC_ID__Req_WifiStaItwtGetFlowIdStatus = 358,
  /*
   *0x167
   */
  RPC_ID__Req_WifiStaItwtSendProbeReq = 359,
  /*
   *0x168
   */
  RPC_ID__Req_WifiStaItwtSetTargetWakeTimeOffset = 360,
  /*
   *0x169
   */
  RPC_ID__Req_WifiStaEnterpriseEnable = 361,
  /*
   *0x16A
   */
  RPC_ID__Req_WifiStaEnterpriseDisable = 362,
  /*
   *0x16B
   */
  RPC_ID__Req_EapSetIdentity = 363,
  /*
   *0x16C
   */
  RPC_ID__Req_EapClearIdentity = 364,
  /*
   *0x16D
   */
  RPC_ID__Req_EapSetUsername = 365,
  /*
   *0x16E
   */
  RPC_ID__Req_EapClearUsername = 366,
  /*
   *0x16F
   */
  RPC_ID__Req_EapSetPassword = 367,
  /*
   *0x170
   */
  RPC_ID__Req_EapClearPassword = 368,
  /*
   *0x171
   */
  RPC_ID__Req_EapSetNewPassword = 369,
  /*
   *0x172
   */
  RPC_ID__Req_EapClearNewPassword = 370,
  /*
   *0x173
   */
  RPC_ID__Req_EapSetCaCert = 371,
  /*
   *0x174
   */
  RPC_ID__Req_EapClearCaCert = 372,
  /*
   *0x175
   */
  RPC_ID__Req_EapSetCertificateAndKey = 373,
  /*
   *0x176
   */
  RPC_ID__Req_EapClearCertificateAndKey = 374,
  /*
   *0x177
   */
  RPC_ID__Req_EapGetDisableTimeCheck = 375,
  /*
   *0x178
   */
  RPC_ID__Req_EapSetTtlsPhase2Method = 376,
  /*
   *0x179
   */
  RPC_ID__Req_EapSetSuitebCertification = 377,
  /*
   *0x17A
   */
  RPC_ID__Req_EapSetPacFile = 378,
  /*
   *0x17B
   */
  RPC_ID__Req_EapSetFastParams = 379,
  /*
   *0x17C
   */
  RPC_ID__Req_EapUseDefaultCertBundle = 380,
  /*
   *0x17D
   */
  RPC_ID__Req_WifiSetOkcSupport = 381,
  /*
   *0x17E
   */
  RPC_ID__Req_EapSetDomainName = 382,
  /*
   *0x17F
   */
  RPC_ID__Req_EapSetDisableTimeCheck = 383,
  /*
   *0x180
   */
  RPC_ID__Req_EapSetEapMethods = 384,
  /*
   *0x181
   */
  RPC_ID__Req_IfaceMacAddrSetGet = 385,
  /*
   *0x182
   */
  RPC_ID__Req_IfaceMacAddrLenGet = 386,
  /*
   * Common RPC to handle simple feature control with one optional parameter
   * Supported Features:
   * - BT Init/Deinit/Enable/Disable
   */
  /*
   *0x183
   */
  RPC_ID__Req_FeatureControl = 387,
  /*
   * Custom RPC for user-defined packed structures 
   */
  /*
   *0x184
   */
  RPC_ID__Req_CustomRpc = 388,
  /*
   * 0x185
   */
  RPC_ID__Req_GpioConfig = 389,
  /*
   * 0x186
   */
  RPC_ID__Req_GpioResetPin = 390,
  /*
   * 0x187
   */
  RPC_ID__Req_GpioSetLevel = 391,
  /*
   * 0x188
   */
  RPC_ID__Req_GpioGetLevel = 392,
  /*
   * 0x189
   */
  RPC_ID__Req_GpioSetDirection = 393,
  /*
   * 0x18a
   */
  RPC_ID__Req_GpioInputEnable = 394,
  /*
   * 0x18B
   */
  RPC_ID__Req_GpioSetPullMode = 395,
  /*
   * 0x18C
   */
  RPC_ID__Req_ExtCoex = 396,
  /*
   * Add new control path command response before Req_Max
   * and update Req_Max 
   */
  /*
   *0x18D
   */
  RPC_ID__Req_Max = 397,
  /*
   ** Response Msgs *
   */
  RPC_ID__Resp_Base = 512,
  RPC_ID__Resp_GetMACAddress = 513,
  RPC_ID__Resp_SetMacAddress = 514,
  RPC_ID__Resp_GetWifiMode = 515,
  RPC_ID__Resp_SetWifiMode = 516,
  RPC_ID__Resp_SuppDppInit = 517,
  RPC_ID__Resp_SuppDppDeinit = 518,
  RPC_ID__Resp_SuppDppBootstrapGen = 519,
  RPC_ID__Resp_SuppDppStartListen = 520,
  RPC_ID__Resp_SuppDppStopListen = 521,
  /*
   *Resp_SetSoftAPVendorSpecificIE    = 522;
   *Resp_StartSoftAP                  = 523;
   *Resp_GetSoftAPConnectedSTAList    = 524;
   *Resp_StopSoftAP                   = 525;
   */
  RPC_ID__Resp_OTAActivate = 522,
  RPC_ID__Resp_AppGetDesc = 523,
  RPC_ID__Resp_MemMonitor = 524,
  RPC_ID__Resp_WifiScanParams = 525,
  RPC_ID__Resp_WifiSetPs = 526,
  RPC_ID__Resp_WifiGetPs = 527,
  RPC_ID__Resp_OTABegin = 528,
  RPC_ID__Resp_OTAWrite = 529,
  RPC_ID__Resp_OTAEnd = 530,
  RPC_ID__Resp_WifiSetMaxTxPower = 531,
  RPC_ID__Resp_WifiGetMaxTxPower = 532,
  RPC_ID__Resp_ConfigHeartbeat = 533,
  RPC_ID__Resp_WifiInit = 534,
  RPC_ID__Resp_WifiDeinit = 535,
  RPC_ID__Resp_WifiStart = 536,
  RPC_ID__Resp_WifiStop = 537,
  RPC_ID__Resp_WifiConnect = 538,
  RPC_ID__Resp_WifiDisconnect = 539,
  RPC_ID__Resp_WifiSetConfig = 540,
  RPC_ID__Resp_WifiGetConfig = 541,
  RPC_ID__Resp_WifiScanStart = 542,
  RPC_ID__Resp_WifiScanStop = 543,
  RPC_ID__Resp_WifiScanGetApNum = 544,
  RPC_ID__Resp_WifiScanGetApRecords = 545,
  RPC_ID__Resp_WifiClearApList = 546,
  RPC_ID__Resp_WifiRestore = 547,
  RPC_ID__Resp_WifiClearFastConnect = 548,
  RPC_ID__Resp_WifiDeauthSta = 549,
  RPC_ID__Resp_WifiStaGetApInfo = 550,
  /*
   *Resp_WifiSetPs                    = 551;
   *Resp_WifiGetPs                    = 552;
   */
  RPC_ID__Resp_WifiSetProtocol = 553,
  RPC_ID__Resp_WifiGetProtocol = 554,
  RPC_ID__Resp_WifiSetBandwidth = 555,
  RPC_ID__Resp_WifiGetBandwidth = 556,
  RPC_ID__Resp_WifiSetChannel = 557,
  RPC_ID__Resp_WifiGetChannel = 558,
  RPC_ID__Resp_WifiSetCountry = 559,
  RPC_ID__Resp_WifiGetCountry = 560,
  /*
   *  Resp_WifiSetPromiscuousRxCb       = 561;
   */
  RPC_ID__Resp_WifiSetPromiscuous = 561,
  RPC_ID__Resp_WifiGetPromiscuous = 562,
  RPC_ID__Resp_WifiSetPromiscuousFilter = 563,
  RPC_ID__Resp_WifiGetPromiscuousFilter = 564,
  RPC_ID__Resp_WifiSetPromiscuousCtrlFilter = 565,
  RPC_ID__Resp_WifiGetPromiscuousCtrlFilter = 566,
  RPC_ID__Resp_WifiApGetStaList = 567,
  RPC_ID__Resp_WifiApGetStaAid = 568,
  RPC_ID__Resp_WifiSetStorage = 569,
  RPC_ID__Resp_WifiSetVendorIe = 570,
  /*
   *  Resp_WifiSetVendorIeCb            = 571;
   */
  RPC_ID__Resp_WifiSetEventMask = 571,
  RPC_ID__Resp_WifiGetEventMask = 572,
  RPC_ID__Resp_Wifi80211Tx = 573,
  /*
   *	Resp_WifiSetCsiRxCb               = 573;
   */
  RPC_ID__Resp_WifiSetCsiConfig = 574,
  RPC_ID__Resp_WifiSetCsi = 575,
  RPC_ID__Resp_WifiSetAntGpio = 576,
  RPC_ID__Resp_WifiGetAntGpio = 577,
  RPC_ID__Resp_WifiSetAnt = 578,
  RPC_ID__Resp_WifiGetAnt = 579,
  RPC_ID__Resp_WifiGetTsfTime = 580,
  RPC_ID__Resp_WifiSetInactiveTime = 581,
  RPC_ID__Resp_WifiGetInactiveTime = 582,
  RPC_ID__Resp_WifiStatisDump = 583,
  RPC_ID__Resp_WifiSetRssiThreshold = 584,
  RPC_ID__Resp_WifiFtmInitiateSession = 585,
  RPC_ID__Resp_WifiFtmEndSession = 586,
  RPC_ID__Resp_WifiFtmRespSetOffset = 587,
  RPC_ID__Resp_WifiConfig11bRate = 588,
  RPC_ID__Resp_WifiConnectionlessModuleSetWakeInterval = 589,
  RPC_ID__Resp_WifiSetCountryCode = 590,
  RPC_ID__Resp_WifiGetCountryCode = 591,
  RPC_ID__Resp_WifiConfig80211TxRate = 592,
  RPC_ID__Resp_WifiDisablePmfConfig = 593,
  RPC_ID__Resp_WifiStaGetAid = 594,
  RPC_ID__Resp_WifiStaGetNegotiatedPhymode = 595,
  RPC_ID__Resp_WifiSetDynamicCs = 596,
  RPC_ID__Resp_WifiStaGetRssi = 597,
  RPC_ID__Resp_WifiSetProtocols = 598,
  RPC_ID__Resp_WifiGetProtocols = 599,
  RPC_ID__Resp_WifiSetBandwidths = 600,
  RPC_ID__Resp_WifiGetBandwidths = 601,
  RPC_ID__Resp_WifiSetBand = 602,
  RPC_ID__Resp_WifiGetBand = 603,
  RPC_ID__Resp_WifiSetBandMode = 604,
  RPC_ID__Resp_WifiGetBandMode = 605,
  RPC_ID__Resp_GetCoprocessorFwVersion = 606,
  RPC_ID__Resp_WifiScanGetApRecord = 607,
  RPC_ID__Resp_SetDhcpDnsStatus = 608,
  RPC_ID__Resp_GetDhcpDnsStatus = 609,
  RPC_ID__Resp_WifiStaTwtConfig = 610,
  RPC_ID__Resp_WifiStaItwtSetup = 611,
  RPC_ID__Resp_WifiStaItwtTeardown = 612,
  RPC_ID__Resp_WifiStaItwtSuspend = 613,
  RPC_ID__Resp_WifiStaItwtGetFlowIdStatus = 614,
  RPC_ID__Resp_WifiStaItwtSendProbeReq = 615,
  RPC_ID__Resp_WifiStaItwtSetTargetWakeTimeOffset = 616,
  RPC_ID__Resp_WifiStaEnterpriseEnable = 617,
  RPC_ID__Resp_WifiStaEnterpriseDisable = 618,
  RPC_ID__Resp_EapSetIdentity = 619,
  RPC_ID__Resp_EapClearIdentity = 620,
  RPC_ID__Resp_EapSetUsername = 621,
  RPC_ID__Resp_EapClearUsername = 622,
  RPC_ID__Resp_EapSetPassword = 623,
  RPC_ID__Resp_EapClearPassword = 624,
  RPC_ID__Resp_EapSetNewPassword = 625,
  RPC_ID__Resp_EapClearNewPassword = 626,
  RPC_ID__Resp_EapSetCaCert = 627,
  RPC_ID__Resp_EapClearCaCert = 628,
  RPC_ID__Resp_EapSetCertificateAndKey = 629,
  RPC_ID__Resp_EapClearCertificateAndKey = 630,
  RPC_ID__Resp_EapGetDisableTimeCheck = 631,
  RPC_ID__Resp_EapSetTtlsPhase2Method = 632,
  RPC_ID__Resp_EapSetSuitebCertification = 633,
  RPC_ID__Resp_EapSetPacFile = 634,
  RPC_ID__Resp_EapSetFastParams = 635,
  RPC_ID__Resp_EapUseDefaultCertBundle = 636,
  RPC_ID__Resp_WifiSetOkcSupport = 637,
  RPC_ID__Resp_EapSetDomainName = 638,
  RPC_ID__Resp_EapSetDisableTimeCheck = 639,
  RPC_ID__Resp_EapSetEapMethods = 640,
  RPC_ID__Resp_IfaceMacAddrSetGet = 641,
  RPC_ID__Resp_IfaceMacAddrLenGet = 642,
  RPC_ID__Resp_FeatureControl = 643,
  RPC_ID__Resp_CustomRpc = 644,
  RPC_ID__Resp_GpioConfig = 645,
  RPC_ID__Resp_GpioResetPin = 646,
  RPC_ID__Resp_GpioSetLevel = 647,
  RPC_ID__Resp_GpioGetLevel = 648,
  RPC_ID__Resp_GpioSetDirection = 649,
  RPC_ID__Resp_GpioInputEnable = 650,
  RPC_ID__Resp_GpioSetPullMode = 651,
  RPC_ID__Resp_ExtCoex = 652,
  /*
   * Add new control path command response before Resp_Max
   * and update Resp_Max 
   */
  RPC_ID__Resp_Max = 653,
  /*
   ** Event Msgs *
   */
  RPC_ID__Event_Base = 768,
  RPC_ID__Event_ESPInit = 769,
  RPC_ID__Event_Heartbeat = 770,
  RPC_ID__Event_AP_StaConnected = 771,
  RPC_ID__Event_AP_StaDisconnected = 772,
  RPC_ID__Event_WifiEventNoArgs = 773,
  RPC_ID__Event_StaScanDone = 774,
  RPC_ID__Event_StaConnected = 775,
  RPC_ID__Event_StaDisconnected = 776,
  RPC_ID__Event_DhcpDnsStatus = 777,
  RPC_ID__Event_StaItwtSetup = 778,
  RPC_ID__Event_StaItwtTeardown = 779,
  RPC_ID__Event_StaItwtSuspend = 780,
  RPC_ID__Event_StaItwtProbe = 781,
  /*
   * Supplicant DPP Events received by dpp callback on host
   */
  RPC_ID__Event_SuppDppUriReady = 782,
  RPC_ID__Event_SuppDppCfgRecvd = 783,
  RPC_ID__Event_SuppDppFail = 784,
  /*
   * Wifi DPP Events
   */
  RPC_ID__Event_WifiDppUriReady = 785,
  RPC_ID__Event_WifiDppCfgRecvd = 786,
  RPC_ID__Event_WifiDppFail = 787,
  /*
   * Custom RPC event for user-defined packed structures 
   */
  RPC_ID__Event_CustomRpc = 788,
  RPC_ID__Event_MemMonitor = 789,
  /*
   * Add new control path command notification before Event_Max
   * and update Event_Max 
   */
  RPC_ID__Event_Max = 790
    PROTOBUF_C__FORCE_ENUM_TO_BE_INT_SIZE(RPC_ID)
} RpcId;
typedef enum _RpcGpioMode {
  RPC__GPIO_MODE__GPIO_MODE_DISABLE = 0,
  RPC__GPIO_MODE__GPIO_MODE_INPUT = 1,
  RPC__GPIO_MODE__GPIO_MODE_OUTPUT = 2,
  RPC__GPIO_MODE__GPIO_MODE_INPUT_OUTPUT = 3
    PROTOBUF_C__FORCE_ENUM_TO_BE_INT_SIZE(RPC__GPIO_MODE)
} RpcGpioMode;
typedef enum _RpcGpioPullMode {
  RPC__GPIO_PULL_MODE__GPIO_PULL_NONE = 0,
  RPC__GPIO_PULL_MODE__GPIO_PULL_UP = 1,
  RPC__GPIO_PULL_MODE__GPIO_PULL_DOWN = 2
    PROTOBUF_C__FORCE_ENUM_TO_BE_INT_SIZE(RPC__GPIO_PULL_MODE)
} RpcGpioPullMode;
typedef enum _RpcMemMonitorConfig {
  /*
   * don't change the monitor configuration
   */
  RPC__MEM_MONITOR_CONFIG__MEMMONITOR_NO_CHANGE = 0,
  /*
   * - to get current memory values without modifying config
   */
  /*
   * disable the monitor
   */
  RPC__MEM_MONITOR_CONFIG__MEMMONITOR_DISABLE = 1,
  /*
   * (re)enable the monitor with new configuration
   */
  RPC__MEM_MONITOR_CONFIG__MEMMONITOR_ENABLE = 2
    PROTOBUF_C__FORCE_ENUM_TO_BE_INT_SIZE(RPC__MEM_MONITOR_CONFIG)
} RpcMemMonitorConfig;
/*
 * Single RPC for external coex: cmd determines which fields are used 
 */
typedef enum _RpcExtCoexCmd {
  RPC__EXT_COEX_CMD__SetGpioPin = 0,
  RPC__EXT_COEX_CMD__Disable = 1,
  RPC__EXT_COEX_CMD__SetWorkMode = 2,
  RPC__EXT_COEX_CMD__SetGrantDelay = 3,
  RPC__EXT_COEX_CMD__SetValidateHigh = 4
    PROTOBUF_C__FORCE_ENUM_TO_BE_INT_SIZE(RPC__EXT_COEX_CMD)
} RpcExtCoexCmd;

/* --- messages --- */

struct  WifiInitConfig
{
  ProtobufCMessage base;
  /*
   **< WiFi static RX buffer number 
   */
  int32_t static_rx_buf_num;
  /*
   **< WiFi dynamic RX buffer number 
   */
  int32_t dynamic_rx_buf_num;
  /*
   **< WiFi TX buffer type 
   */
  int32_t tx_buf_type;
  /*
   **< WiFi static TX buffer number 
   */
  int32_t static_tx_buf_num;
  /*
   **< WiFi dynamic TX buffer number 
   */
  int32_t dynamic_tx_buf_num;
  /*
   **< WiFi TX cache buffer number 
   */
  int32_t cache_tx_buf_num;
  /*
   **< WiFi channel state information enable flag 
   */
  int32_t csi_enable;
  /*
   **< WiFi AMPDU RX feature enable flag 
   */
  int32_t ampdu_rx_enable;
  /*
   **< WiFi AMPDU TX feature enable flag 
   */
  int32_t ampdu_tx_enable;
  /*
   **< WiFi AMSDU TX feature enable flag 
   */
  int32_t amsdu_tx_enable;
  /*
   **< WiFi NVS flash enable flag 
   */
  int32_t nvs_enable;
  /*
   **< Nano option for printf/scan family enable flag 
   */
  int32_t nano_enable;
  /*
   **< WiFi Block Ack RX window size 
   */
  int32_t rx_ba_win;
  /*
   **< WiFi Task Core ID 
   */
  int32_t wifi_task_core_id;
  /*
   **< WiFi softAP maximum length of the beacon 
   */
  int32_t beacon_max_len;
  /*
   **< WiFi management short buffer number, the minimum value is 6, the maximum value is 32 
   */
  int32_t mgmt_sbuf_num;
  /*
   **< Enables additional WiFi features and capabilities 
   */
  uint64_t feature_caps;
  /*
   **< WiFi Power Management for station at disconnected status 
   */
  protobuf_c_boolean sta_disconnected_pm;
  /*
   **< Maximum encrypt number of peers supported by espnow 
   */
  int32_t espnow_max_encrypt_num;
  /*
   **< WiFi init magic number, it should be the last field 
   */
  int32_t magic;
  /*
   **< WiFi RX MGMT buffer type 
   */
  int32_t rx_mgmt_buf_type;
  /*
   **< WiFi RX MGMT buffer number 
   */
  int32_t rx_mgmt_buf_num;
  /*
   **< WiFi TX HE TB QUEUE number for STA HE TB PPDU transmission 
   */
  int32_t tx_hetb_queue_num;
  /*
   **< enable dump sigb field 
   */
  int32_t dump_hesigb_enable;
};
#define WIFI_INIT_CONFIG__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&wifi_init_config__descriptor) \
    , 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }


struct  WifiCountry
{
  ProtobufCMessage base;
  /*
   **< country code string of 3 chars
   */
  ProtobufCBinaryData cc;
  /*
   **< start channel 
   */
  uint32_t schan;
  /*
   **< total channel number 
   */
  uint32_t nchan;
  /*
   **< This field is used for getting WiFi maximum transmitting power,
   *call esp_wifi_set_max_tx_power to set the maximum transmitting power. 
   */
  int32_t max_tx_power;
  /*
   **< country policy 
   */
  int32_t policy;
};
#define WIFI_COUNTRY__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&wifi_country__descriptor) \
    , {0,NULL}, 0, 0, 0, 0 }


struct  WifiActiveScanTime
{
  ProtobufCMessage base;
  /*
   **< minimum active scan time per channel, units: millisecond 
   */
  uint32_t min;
  /*
   **< maximum active scan time per channel, units: millisecond, values above 1500ms may
   *cause station to disconnect from AP and are not recommended.  
   */
  uint32_t max;
};
#define WIFI_ACTIVE_SCAN_TIME__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&wifi_active_scan_time__descriptor) \
    , 0, 0 }


struct  WifiScanTime
{
  ProtobufCMessage base;
  /*
   **< active scan time per channel, units: millisecond. 
   */
  WifiActiveScanTime *active;
  /*
   **< passive scan time per channel, units: millisecond, values above 1500ms may
   *cause station to disconnect from AP and are not recommended. 
   */
  uint32_t passive;
};
#define WIFI_SCAN_TIME__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&wifi_scan_time__descriptor) \
    , NULL, 0 }


struct  WifiScanChannelBitmap
{
  ProtobufCMessage base;
  /*
   **< Represents 2.4 GHz channels, that bits can be set as wifi_2g_channel_bit_t shown. 
   */
  uint32_t ghz_2_channels;
  /*
   **< Represents 5 GHz channels, that bits can be set as wifi_5g_channel_bit_t shown. 
   */
  uint32_t ghz_5_channels;
};
#define WIFI_SCAN_CHANNEL_BITMAP__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&wifi_scan_channel_bitmap__descriptor) \
    , 0, 0 }


struct  WifiScanConfig
{
  ProtobufCMessage base;
  /*
   **< SSID of AP 33char
   */
  ProtobufCBinaryData ssid;
  /*
   **< MAC address of AP 6char 
   */
  ProtobufCBinaryData bssid;
  /*
   **< channel, scan the specific channel 
   */
  uint32_t channel;
  /*
   **< enable to scan AP whose SSID is hidden 
   */
  protobuf_c_boolean show_hidden;
  /*
   **< scan type, active or passive 
   */
  int32_t scan_type;
  /*
   **< scan time per channel 
   */
  WifiScanTime *scan_time;
  /*
   **< time spent at home channel between scanning consecutive channels.
   */
  uint32_t home_chan_dwell_time;
  /*
   **< Channel bitmap for setting specific channels to be scanned.
   *Please note that the 'channel' parameter above needs to be set to 0 to allow scanning by bitmap.
   *Also, note that only allowed channels configured by wifi_country_t can be scanned. 
   */
  WifiScanChannelBitmap *channel_bitmap;
};
#define WIFI_SCAN_CONFIG__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&wifi_scan_config__descriptor) \
    , {0,NULL}, {0,NULL}, 0, 0, 0, NULL, 0, NULL }


struct  WifiScanDefaultParams
{
  ProtobufCMessage base;
  /*
   **< Scan time per channel 
   */
  WifiScanTime *scan_time;
  /*
   **< Time spent at home channel between scanning consecutive channels.
   */
  uint32_t home_chan_dwell_time;
};
#define WIFI_SCAN_DEFAULT_PARAMS__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&wifi_scan_default_params__descriptor) \
    , NULL, 0 }


struct  WifiHeApInfo
{
  ProtobufCMessage base;
  /*
   *uint8_t bss_color:6;                   **< an unsigned integer whose value is the BSS Color of the BSS corresponding to the AP * 
   *uint8_t partial_bss_color:1;           **< indicate if an AID assignment rule based on the BSS color * 
   *uint8_t bss_color_disabled:1;          **< indicate if the use of BSS color is disabled * 
   */
  /*
   * Manually have to parse for above bits 
   */
  uint32_t bitmask;
  /*
   **< in M-BSSID set, identifies the nontransmitted BSSID 
   */
  uint32_t bssid_index;
};
#define WIFI_HE_AP_INFO__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&wifi_he_ap_info__descriptor) \
    , 0, 0 }


struct  WifiApRecord
{
  ProtobufCMessage base;
  /*
   **< MAC address of AP 6char 
   */
  ProtobufCBinaryData bssid;
  /*
   **< SSID of AP 33char 
   */
  ProtobufCBinaryData ssid;
  /*
   **< channel of AP 
   */
  uint32_t primary;
  /*
   **< secondary channel of AP 
   */
  int32_t second;
  /*
   **< signal strength of AP 
   */
  int32_t rssi;
  /*
   **< authmode of AP 
   */
  int32_t authmode;
  /*
   **< pairwise cipher of AP 
   */
  int32_t pairwise_cipher;
  /*
   **< group cipher of AP 
   */
  int32_t group_cipher;
  /*
   **< antenna used to receive beacon from AP 
   */
  int32_t ant;
  /*
   *uint32_t phy_11b:1;                        **< bit: 0 flag to identify if 11b mode is enabled or not * 
   *uint32_t phy_11g:1;                        **< bit: 1 flag to identify if 11g mode is enabled or not * 
   *uint32_t phy_11n:1;                        **< bit: 2 flag to identify if 11n mode is enabled or not * 
   *uint32_t phy_lr:1;                         **< bit: 3 flag to identify if low rate is enabled or not * 
   *uint32_t wps:1;                            **< bit: 4 flag to identify if WPS is supported or not * 
   *uint32_t ftm_responder:1;                  **< bit: 5 flag to identify if FTM is supported in responder mode * 
   *uint32_t ftm_initiator:1;                  **< bit: 6 flag to identify if FTM is supported in initiator mode * 
   *uint32_t reserved:25;                      **< bit: 7..31 reserved * 
   */
  /*
   * Manually have to parse for above bits 
   */
  uint32_t bitmask;
  /*
   **< country information of AP 
   */
  WifiCountry *country;
  WifiHeApInfo *he_ap;
  /*
   **< For AP 20 MHz this value is set to 1. For AP 40 MHz this value is set to 2.
   *For AP 80 MHz this value is set to 3. For AP 160MHz this value is set to 4.
   *For AP 80+80MHz this value is set to 5
   */
  uint32_t bandwidth;
  /*
   **< This fields are used only AP bandwidth is 80 and 160 MHz, to transmit the center channel
   *frequency of the BSS. For AP bandwidth is 80 + 80 MHz, it is the center channel frequency
   *of the lower frequency segment.
   */
  uint32_t vht_ch_freq1;
  /*
   **< This fields are used only AP bandwidth is 80 + 80 MHz, and is used to transmit the center
   *channel frequency of the second segment. 
   */
  uint32_t vht_ch_freq2;
};
#define WIFI_AP_RECORD__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&wifi_ap_record__descriptor) \
    , {0,NULL}, {0,NULL}, 0, 0, 0, 0, 0, 0, 0, 0, NULL, NULL, 0, 0, 0 }


struct  WifiScanThreshold
{
  ProtobufCMessage base;
  /*
   **< The minimum rssi to accept in the fast scan mode 
   */
  int32_t rssi;
  /*
   **< The weakest authmode to accept in the fast scan mode
   *Note: In case this value is not set and password is set as per WPA2 standards(password len >= 8),
   *it will be defaulted to WPA2 and device won't connect to deprecated WEP/WPA networks.
   *Please set authmode threshold as WIFI_AUTH_WEP/WIFI_AUTH_WPA_PSK to connect to WEP/WPA networks 
   */
  int32_t authmode;
  /*
   **< The RSSI value of the 5G AP is within the rssi_5g_adjustment range compared to the 2G AP, the 5G AP will be given priority for connection. 
   */
  uint32_t rssi_5g_adjustment;
};
#define WIFI_SCAN_THRESHOLD__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&wifi_scan_threshold__descriptor) \
    , 0, 0, 0 }


struct  WifiPmfConfig
{
  ProtobufCMessage base;
  /*
   **< Deprecated variable. Device will always connect in PMF mode if other device also advertises PMF capability. 
   */
  protobuf_c_boolean capable;
  /*
   **< Advertises that Protected Management Frame is required. Device will not associate to non-PMF capable devices. 
   */
  protobuf_c_boolean required;
};
#define WIFI_PMF_CONFIG__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&wifi_pmf_config__descriptor) \
    , 0, 0 }


struct  WifiBssMaxIdleConfig
{
  ProtobufCMessage base;
  /*
   **< Sets BSS Max idle period (1 Unit = 1000TUs OR 1.024 Seconds). If there are no frames for this period from a STA, SoftAP will disassociate due to inactivity. Setting it to 0 disables the feature 
   */
  uint32_t period;
  /*
   **< Requires clients to use protected keep alive frames for BSS Max Idle period 
   */
  protobuf_c_boolean protected_keep_alive;
};
#define WIFI_BSS_MAX_IDLE_CONFIG__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&wifi_bss_max_idle_config__descriptor) \
    , 0, 0 }


struct  WifiApConfig
{
  ProtobufCMessage base;
  /*
   **< SSID of ESP32 soft-AP. If ssid_len field is 0, this must be a Null terminated string. Otherwise, length is set according to ssid_len. 32 char
   */
  ProtobufCBinaryData ssid;
  /*
   **< Password of ESP32 soft-AP. 64 char
   */
  ProtobufCBinaryData password;
  /*
   **< Optional length of SSID field. 
   */
  uint32_t ssid_len;
  /*
   **< Channel of ESP32 soft-AP 
   */
  uint32_t channel;
  /*
   **< Auth mode of ESP32 soft-AP. Do not support AUTH_WEP in soft-AP mode 
   */
  int32_t authmode;
  /*
   **< Broadcast SSID or not, default 0, broadcast the SSID 
   */
  uint32_t ssid_hidden;
  /*
   **< Max number of stations allowed to connect in 
   */
  uint32_t max_connection;
  /*
   **< Beacon interval which should be multiples of 100. Unit: TU(time unit, 1 TU = 1024 us). Range: 100 ~ 60000. Default value: 100 
   */
  uint32_t beacon_interval;
  /*
   **< pairwise cipher of SoftAP, group cipher will be derived using this.
   *cipher values are valid starting from WIFI_CIPHER_TYPE_TKIP, enum values before that will be considered as invalid and default cipher suites(TKIP+CCMP) will be used.
   *Valid cipher suites in softAP mode are WIFI_CIPHER_TYPE_TKIP, WIFI_CIPHER_TYPE_CCMP and WIFI_CIPHER_TYPE_TKIP_CCMP. 
   */
  int32_t pairwise_cipher;
  /*
   **< Enable FTM Responder mode 
   */
  protobuf_c_boolean ftm_responder;
  /*
   **< Configuration for Protected Management Frame 
   */
  WifiPmfConfig *pmf_cfg;
  /*
   **< Configuration for SAE PWE derivation method 
   */
  int32_t sae_pwe_h2e;
  /*
   **< Channel Switch Announcement Count. Notify the station that the channel will switch after the csa_count beacon intervals. Default value: 3 
   */
  uint32_t csa_count;
  /*
   **< Dtim period of soft-AP. Range: 1 ~ 10. Default value: 1 
   */
  uint32_t dtim_period;
  /*
   **< Whether to enable transition disable feature 
   */
  uint32_t transition_disable;
  /*
   **< Enable SAE EXT feature. SOC_GCMP_SUPPORT is required for this feature. 
   */
  uint32_t sae_ext;
  /*
   **< Configuration for bss max idle, effective if CONFIG_WIFI_BSS_MAX_IDLE_SUPPORT is enabled 
   */
  WifiBssMaxIdleConfig *bss_max_idle_cfg;
  /*
   **< GTK rekeying interval in seconds. If set to 0, GTK rekeying is disabled. Range: 60 ~ 65535 including 0. 
   */
  uint32_t gtk_rekey_interval;
};
#define WIFI_AP_CONFIG__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&wifi_ap_config__descriptor) \
    , {0,NULL}, {0,NULL}, 0, 0, 0, 0, 0, 0, 0, 0, NULL, 0, 0, 0, 0, 0, NULL, 0 }


struct  WifiStaConfig
{
  ProtobufCMessage base;
  /*
   **< SSID of target AP. 32char 
   */
  ProtobufCBinaryData ssid;
  /*
   **< Password of target AP. 64char 
   */
  ProtobufCBinaryData password;
  /*
   **< do all channel scan or fast scan 
   */
  int32_t scan_method;
  /*
   **< whether set MAC address of target AP or not. Generally, station_config.bssid_set needs to be 0,
   *and it needs to be 1 only when users need to check the MAC address of the AP.
   */
  protobuf_c_boolean bssid_set;
  /*
   **< MAC address of target AP 6char 
   */
  ProtobufCBinaryData bssid;
  /*
   **< channel of target AP. Set to 1~13 to scan starting from the specified channel
   *before connecting to AP. If the channel of AP is unknown, set it to 0.
   */
  uint32_t channel;
  /*
   **< Listen interval for ESP32 station to receive beacon when WIFI_PS_MAX_MODEM is set.
   *Units: AP beacon intervals. Defaults to 3 if set to 0. 
   */
  uint32_t listen_interval;
  /*
   **< sort the connect AP in the list by rssi or security mode 
   */
  int32_t sort_method;
  /*
   **< When sort_method is set, only APs which have an auth mode that is more secure
   *than the selected auth mode and a signal stronger than the minimum RSSI will be used. 
   */
  WifiScanThreshold *threshold;
  /*
   **< Configuration for Protected Management Frame. Will be advertised in RSN Capabilities in RSN IE. 
   */
  WifiPmfConfig *pmf_cfg;
  /*
   *uint32_t rm_enabled:1;                     **< Whether Radio Measurements are enabled for the connection * 
   *uint32_t btm_enabled:1;                    **< Whether BSS Transition Management is enabled for the connection * 
   *uint32_t mbo_enabled:1;                    **< Whether MBO is enabled for the connection * 
   *uint32_t ft_enabled:1;                     **< Whether FT is enabled for the connection * 
   *uint32_t owe_enabled:1;                    **< Whether OWE is enabled for the connection * 
   *uint32_t transition_disable:1;             **< Whether to enable transition disable feature * 
   *uint32_t reserved:26;                      **< Reserved for future feature set * 
   */
  uint32_t bitmask;
  /*
   **< Whether SAE hash to element is enabled 
   */
  int32_t sae_pwe_h2e;
  /*
   **< Number of connection retries station will do before moving to next AP.
   *scan_method should be set as WIFI_ALL_CHANNEL_SCAN to use this config.
   *Note: Enabling this may cause connection time to increase in case best AP doesn't behave properly. 
   */
  uint32_t failure_retry_cnt;
  /*
   *uint32_t he_dcm_set:1;                                         **< Whether DCM max.constellation for transmission and reception is set. * 
   *uint32_t he_dcm_max_constellation_tx:2;                        **< Indicate the max.constellation for DCM in TB PPDU the STA supported. 0: not supported. 1: BPSK, 2: QPSK, 3: 16-QAM. The default value is 3. * 
   *uint32_t he_dcm_max_constellation_rx:2;                        **< Indicate the max.constellation for DCM in both Data field and HE-SIG-B field the STA supported. 0: not supported. 1: BPSK, 2: QPSK, 3: 16-QAM. The default value is 3. * 
   *uint32_t he_mcs9_enabled:1;                                    **< Whether to support HE-MCS 0 to 9. The default value is 0. * 
   *uint32_t he_su_beamformee_disabled:1;                          **< Whether to disable support for operation as an SU beamformee. * 
   *uint32_t he_trig_su_bmforming_feedback_disabled:1;             **< Whether to disable support the transmission of SU feedback in an HE TB sounding sequence. * 
   *uint32_t he_trig_mu_bmforming_partial_feedback_disabled:1;     **< Whether to disable support the transmission of partial-bandwidth MU feedback in an HE TB sounding sequence. * 
   * uint32_t he_trig_cqi_feedback_disabled:1;                      **< Whether to disable support the transmission of CQI feedback in an HE TB sounding sequence. * 
   * uint32_t vht_su_beamformee_disabled: 1;                        **< Whether to disable support for operation as an VHT SU beamformee. * 
   * uint32_t vht_mu_beamformee_disabled: 1;                        **< Whether to disable support for operation as an VHT MU beamformee. * 
   * uint32_t vht_mcs8_enabled: 1;                                  **< Whether to support VHT-MCS8. The default value is 0. * 
   * uint32_t he_reserved:19;                                       **< Reserved for future feature set * 
   */
  uint32_t he_bitmask;
  /*
   **< Password identifier for H2E. this needs to be null terminated string. SAE_H2E_IDENTIFIER_LEN chars 
   */
  ProtobufCBinaryData sae_h2e_identifier;
  /*
   **< Configuration for SAE-PK (Public Key) Authentication method 
   */
  uint32_t sae_pk_mode;
};
#define WIFI_STA_CONFIG__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&wifi_sta_config__descriptor) \
    , {0,NULL}, {0,NULL}, 0, 0, {0,NULL}, 0, 0, 0, NULL, NULL, 0, 0, 0, 0, {0,NULL}, 0 }


typedef enum {
  WIFI_CONFIG__U__NOT_SET = 0,
  WIFI_CONFIG__U_AP = 1,
  WIFI_CONFIG__U_STA = 2
    PROTOBUF_C__FORCE_ENUM_TO_BE_INT_SIZE(WIFI_CONFIG__U__CASE)
} WifiConfig__UCase;

struct  WifiConfig
{
  ProtobufCMessage base;
  WifiConfig__UCase u_case;
  union {
    /*
     **< configuration of AP 
     */
    WifiApConfig *ap;
    /*
     **< configuration of STA 
     */
    WifiStaConfig *sta;
  };
};
#define WIFI_CONFIG__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&wifi_config__descriptor) \
    , WIFI_CONFIG__U__NOT_SET, {0} }


struct  WifiStaInfo
{
  ProtobufCMessage base;
  /*
   **< mac address 6 char 
   */
  ProtobufCBinaryData mac;
  /*
   **< current average rssi of sta connected 
   */
  int32_t rssi;
  /*
   *uint32_t phy_11b:1;                        **< bit: 0 flag to identify if 11b mode is enabled or not * 
   *uint32_t phy_11g:1;                        **< bit: 1 flag to identify if 11g mode is enabled or not * 
   *uint32_t phy_11n:1;                        **< bit: 2 flag to identify if 11n mode is enabled or not * 
   *uint32_t phy_lr:1;                         **< bit: 3 flag to identify if low rate is enabled or not * 
   *uint32_t phy_11x:1;                        **< bit: 4 flag to identify identify if 11ax mode is enabled or not * 
   *uint32_t is_mesh_child:1;                  **< bit: 5 flag to identify mesh child * 
   *uint32_t reserved:26;                      **< bit: 6..31 reserved * 
   */
  uint32_t bitmask;
};
#define WIFI_STA_INFO__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&wifi_sta_info__descriptor) \
    , {0,NULL}, 0, 0 }


struct  WifiStaList
{
  ProtobufCMessage base;
  /*
   **< station list 
   */
  size_t n_sta;
  WifiStaInfo **sta;
  /*
   **< number of stations in the list (other entries are invalid) 
   */
  int32_t num;
};
#define WIFI_STA_LIST__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&wifi_sta_list__descriptor) \
    , 0,NULL, 0 }


struct  WifiPktRxCtrl
{
  ProtobufCMessage base;
  /*
   **< 8bits Received Signal Strength Indicator(RSSI) of packet. unit: dBm 
   */
  int32_t rssi;
  /*
   **< 5bits PHY rate encoding of the packet. Only valid for non HT(11bg) packet 
   */
  uint32_t rate;
  /*
   *uint32 :1;                                 **< reserved * 
   */
  /*
   **< 2bits 0: non HT(11bg) packet; 1: HT(11n) packet; 3: VHT(11ac) packet 
   */
  uint32_t sig_mode;
  /*
   *uint32 :16;                                **< reserved * 
   */
  /*
   **< 7bits Modulation Coding Scheme. If is HT(11n) packet, shows the modulation, range from 0 to 76(MSC0 ~ MCS76) 
   */
  uint32_t mcs;
  /*
   **< 1bit Channel Bandwidth of the packet. 0: 20MHz; 1: 40MHz 
   */
  uint32_t cwb;
  /*
   *uint32 :16;                                **< reserved * 
   */
  /*
   **< 1bit reserved 
   */
  uint32_t smoothing;
  /*
   **< 1bit reserved 
   */
  uint32_t not_sounding;
  /*
   *uint32 :1;                                 **< reserved * 
   */
  /*
   **< 1bit Aggregation. 0: MPDU packet; 1: AMPDU packet 
   */
  uint32_t aggregation;
  /*
   **< 2bits Space Time Block Code(STBC). 0: non STBC packet; 1: STBC packet 
   */
  uint32_t stbc;
  /*
   **< 1bit Flag is set for 11n packets which are LDPC 
   */
  uint32_t fec_coding;
  /*
   **< 1bit Short Guide Interval(SGI). 0: Long GI; 1: Short GI 
   */
  uint32_t sgi;
  /*
   **< 8bits noise floor of Radio Frequency Module(RF). unit: dBm
   */
  int32_t noise_floor;
  /*
   **< 8bits ampdu cnt 
   */
  uint32_t ampdu_cnt;
  /*
   **< 4bits primary channel on which this packet is received 
   */
  uint32_t channel;
  /*
   **< 4bits secondary channel on which this packet is received. 0: none; 1: above; 2: below 
   */
  uint32_t secondary_channel;
  /*
   *uint32 :8;                                 **< reserved * 
   */
  /*
   **< 32bit timestamp. The local time when this packet is received. It is precise only if modem sleep or light sleep is not enabled. unit: microsecond 
   */
  uint32_t timestamp;
  /*
   *uint32 :32;                                **< reserved * 
   *unsigned :32;                              **< reserved * 
   *unsigned :31;                              **< reserved * 
   */
  /*
   **< 1bit antenna number from which this packet is received. 0: WiFi antenna 0; 1: WiFi antenna 1 
   */
  uint32_t ant;
  /*
   **<  12bits length of packet including Frame Check Sequence(FCS) 
   */
  uint32_t sig_len;
  /*
   *unsigned :12;                              **< reserved * 
   */
  /*
   **< 8bits state of the packet. 0: no error; others: error numbers which are not public 
   */
  uint32_t rx_state;
};
#define WIFI_PKT_RX_CTRL__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&wifi_pkt_rx_ctrl__descriptor) \
    , 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }


struct  WifiPromiscuousPkt
{
  ProtobufCMessage base;
  /*
   **< metadata header 
   */
  WifiPktRxCtrl *rx_ctrl;
  /*
   **< Note: variable length. Data or management payload. Length of payload is described by rx_ctrl.sig_len. Type of content determined by packet type argument of callback. 
   */
  ProtobufCBinaryData payload;
};
#define WIFI_PROMISCUOUS_PKT__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&wifi_promiscuous_pkt__descriptor) \
    , NULL, {0,NULL} }


struct  WifiPromiscuousFilter
{
  ProtobufCMessage base;
  /*
   **< OR of one or more filter values WIFI_PROMIS_FILTER_* 
   */
  uint32_t filter_mask;
};
#define WIFI_PROMISCUOUS_FILTER__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&wifi_promiscuous_filter__descriptor) \
    , 0 }


struct  WifiCsiConfig
{
  ProtobufCMessage base;
  /*
   **< enable to receive legacy long training field(lltf) data. Default enabled 
   */
  protobuf_c_boolean lltf_en;
  /*
   **< enable to receive HT long training field(htltf) data. Default enabled 
   */
  protobuf_c_boolean htltf_en;
  /*
   **< enable to receive space time block code HT long training field(stbc-htltf2) data. Default enabled 
   */
  protobuf_c_boolean stbc_htltf2_en;
  /*
   **< enable to generate htlft data by averaging lltf and ht_ltf data when receiving HT packet. Otherwise, use ht_ltf data directly. Default enabled 
   */
  protobuf_c_boolean ltf_merge_en;
  /*
   **< enable to turn on channel filter to smooth adjacent sub-carrier. Disable it to keep independence of adjacent sub-carrier. Default enabled 
   */
  protobuf_c_boolean channel_filter_en;
  /*
   **< manually scale the CSI data by left shifting or automatically scale the CSI data.
   *If set true, please set the shift bits. false: automatically. true: manually. Default false 
   */
  protobuf_c_boolean manu_scale;
  /*
   **< manually left shift bits of the scale of the CSI data. The range of the left shift bits is 0~15 
   */
  uint32_t shift;
};
#define WIFI_CSI_CONFIG__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&wifi_csi_config__descriptor) \
    , 0, 0, 0, 0, 0, 0, 0 }


struct  WifiCsiInfo
{
  ProtobufCMessage base;
  /*
   **< received packet radio metadata header of the CSI data 
   */
  WifiPktRxCtrl *rx_ctrl;
  /*
   **< 6bits source MAC address of the CSI data 
   */
  ProtobufCBinaryData mac;
  /*
   **< 6bits destination MAC address of the CSI data 
   */
  ProtobufCBinaryData dmac;
  /*
   **< first four bytes of the CSI data is invalid or not 
   */
  protobuf_c_boolean first_word_invalid;
  /*
   **< Note: variable length. buffer of CSI data 
   */
  ProtobufCBinaryData buf;
  /*
   **< length of CSI data 
   */
  uint32_t len;
};
#define WIFI_CSI_INFO__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&wifi_csi_info__descriptor) \
    , NULL, {0,NULL}, {0,NULL}, 0, {0,NULL}, 0 }


struct  WifiAntGpio
{
  ProtobufCMessage base;
  /*
   **< 1bit Whether this GPIO is connected to external antenna switch 
   */
  uint32_t gpio_select;
  /*
   **< 7bits The GPIO number that connects to external antenna switch 
   */
  uint32_t gpio_num;
};
#define WIFI_ANT_GPIO__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&wifi_ant_gpio__descriptor) \
    , 0, 0 }


struct  WifiAntGpioConfig
{
  ProtobufCMessage base;
  /*
   **< The configurations of GPIOs that connect to external antenna switch 
   */
  size_t n_gpio_cfgs;
  WifiAntGpio **gpio_cfgs;
};
#define WIFI_ANT_GPIO_CONFIG__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&wifi_ant_gpio_config__descriptor) \
    , 0,NULL }


struct  WifiAntConfig
{
  ProtobufCMessage base;
  /*
   **< WiFi antenna mode for receiving 
   */
  int32_t rx_ant_mode;
  /*
   **< Default antenna mode for receiving, it's ignored if rx_ant_mode is not WIFI_ANT_MODE_AUTO 
   */
  int32_t rx_ant_default;
  /*
   **< WiFi antenna mode for transmission, it can be set to WIFI_ANT_MODE_AUTO only if rx_ant_mode is set to WIFI_ANT_MODE_AUTO 
   */
  int32_t tx_ant_mode;
  /*
   **< 4bits Index (in antenna GPIO configuration) of enabled WIFI_ANT_MODE_ANT0 
   */
  uint32_t enabled_ant0;
  /*
   **< 4bits Index (in antenna GPIO configuration) of enabled WIFI_ANT_MODE_ANT1 
   */
  uint32_t enabled_ant1;
};
#define WIFI_ANT_CONFIG__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&wifi_ant_config__descriptor) \
    , 0, 0, 0, 0, 0 }


struct  WifiActionTxReq
{
  ProtobufCMessage base;
  /*
   **< WiFi interface to send request to 
   */
  int32_t ifx;
  /*
   **< 6bits Destination MAC address 
   */
  ProtobufCBinaryData dest_mac;
  /*
   **< Indicates no ack required 
   */
  protobuf_c_boolean no_ack;
  /*
   *TODO
   *wifi_action_rx_cb_t rx_cb;                 **< Rx Callback to receive any response * 
   */
  /*
   **< Length of the appended Data 
   */
  uint32_t data_len;
  /*
   **< note: variable length. Appended Data payload 
   */
  ProtobufCBinaryData data;
};
#define WIFI_ACTION_TX_REQ__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&wifi_action_tx_req__descriptor) \
    , 0, {0,NULL}, 0, 0, {0,NULL} }


struct  WifiFtmInitiatorCfg
{
  ProtobufCMessage base;
  /*
   **< 6bits MAC address of the FTM Responder 
   */
  ProtobufCBinaryData resp_mac;
  /*
   **< Primary channel of the FTM Responder 
   */
  uint32_t channel;
  /*
   **< No. of FTM frames requested in terms of 4 or 8 bursts (allowed values - 0(No pref), 16, 24, 32, 64) 
   */
  uint32_t frm_count;
  /*
   **< Requested time period between consecutive FTM bursts in 100's of milliseconds (0 - No pref) 
   */
  uint32_t burst_period;
};
#define WIFI_FTM_INITIATOR_CFG__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&wifi_ftm_initiator_cfg__descriptor) \
    , {0,NULL}, 0, 0, 0 }


struct  WifiEventStaScanDone
{
  ProtobufCMessage base;
  /*
   **< status of scanning APs: 0 — success, 1 - failure 
   */
  uint32_t status;
  /*
   **< number of scan results 
   */
  uint32_t number;
  /*
   **< scan sequence number, used for block scan 
   */
  uint32_t scan_id;
};
#define WIFI_EVENT_STA_SCAN_DONE__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&wifi_event_sta_scan_done__descriptor) \
    , 0, 0, 0 }


struct  WifiEventStaConnected
{
  ProtobufCMessage base;
  /*
   **< 32bytes SSID of connected AP 
   */
  ProtobufCBinaryData ssid;
  /*
   **< SSID length of connected AP 
   */
  uint32_t ssid_len;
  /*
   **< 6bytes BSSID of connected AP
   */
  ProtobufCBinaryData bssid;
  /*
   **< channel of connected AP
   */
  uint32_t channel;
  /*
   **< authentication mode used by AP
   */
  int32_t authmode;
  /*
   **< authentication id assigned by the connected AP
   */
  int32_t aid;
};
#define WIFI_EVENT_STA_CONNECTED__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&wifi_event_sta_connected__descriptor) \
    , {0,NULL}, 0, {0,NULL}, 0, 0, 0 }


struct  WifiEventStaDisconnected
{
  ProtobufCMessage base;
  /*
   **< SSID of disconnected AP 
   */
  ProtobufCBinaryData ssid;
  /*
   **< SSID length of disconnected AP 
   */
  uint32_t ssid_len;
  /*
   **< BSSID of disconnected AP 
   */
  ProtobufCBinaryData bssid;
  /*
   **< reason of disconnection 
   */
  uint32_t reason;
  /*
   **< rssi of disconnection 
   */
  int32_t rssi;
};
#define WIFI_EVENT_STA_DISCONNECTED__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&wifi_event_sta_disconnected__descriptor) \
    , {0,NULL}, 0, {0,NULL}, 0, 0 }


struct  WifiEventStaAuthmodeChange
{
  ProtobufCMessage base;
  /*
   **< the old auth mode of AP 
   */
  int32_t old_mode;
  /*
   **< the new auth mode of AP 
   */
  int32_t new_mode;
};
#define WIFI_EVENT_STA_AUTHMODE_CHANGE__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&wifi_event_sta_authmode_change__descriptor) \
    , 0, 0 }


struct  WifiEventStaWpsErPin
{
  ProtobufCMessage base;
  /*
   **< 8bytes PIN code of station in enrollee mode 
   */
  ProtobufCBinaryData pin_code;
};
#define WIFI_EVENT_STA_WPS_ER_PIN__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&wifi_event_sta_wps_er_pin__descriptor) \
    , {0,NULL} }


struct  ApCred
{
  ProtobufCMessage base;
  /*
   **< 32bytes SSID of AP 
   */
  ProtobufCBinaryData ssid;
  /*
   **< 64bytes Passphrase for the AP 
   */
  ProtobufCBinaryData passphrase;
};
#define AP_CRED__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&ap_cred__descriptor) \
    , {0,NULL}, {0,NULL} }


struct  WifiEventStaWpsErSuccess
{
  ProtobufCMessage base;
  /*
   **< Number of AP credentials received 
   */
  uint32_t ap_cred_cnt;
  /*
   **< All AP credentials received from WPS handshake 
   */
  size_t n_ap_creds;
  ApCred **ap_creds;
};
#define WIFI_EVENT_STA_WPS_ER_SUCCESS__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&wifi_event_sta_wps_er_success__descriptor) \
    , 0, 0,NULL }


/*
 ** Argument structure for WIFI_EVENT_AP_PROBEREQRECVED event 
 */
struct  WifiEventApProbeReqRx
{
  ProtobufCMessage base;
  /*
   **< Received probe request signal strength 
   */
  int32_t rssi;
  /*
   **< MAC address of the station which send probe request 
   */
  uint32_t mac;
};
#define WIFI_EVENT_AP_PROBE_REQ_RX__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&wifi_event_ap_probe_req_rx__descriptor) \
    , 0, 0 }


/*
 ** Argument structure for WIFI_EVENT_STA_BSS_RSSI_LOW event 
 */
struct  WifiEventBssRssiLow
{
  ProtobufCMessage base;
  /*
   **< RSSI value of bss 
   */
  int32_t rssi;
};
#define WIFI_EVENT_BSS_RSSI_LOW__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&wifi_event_bss_rssi_low__descriptor) \
    , 0 }


struct  WifiFtmReportEntry
{
  ProtobufCMessage base;
  /*
   * *< Dialog Token of the FTM frame 
   */
  uint32_t dlog_token;
  /*
   * *< RSSI of the FTM frame received 
   */
  int32_t rssi;
  /*
   * *< Round Trip Time in pSec with a peer 
   */
  uint32_t rtt;
  /*
   * TODO: uint32 is supported by proto? 
   */
  /*
   * *< Time of departure of FTM frame from FTM Responder in pSec 
   */
  uint64_t t1;
  /*
   * *< Time of arrival of FTM frame at FTM Initiator in pSec 
   */
  uint64_t t2;
  /*
   * *< Time of departure of ACK from FTM Initiator in pSec 
   */
  uint64_t t3;
  /*
   * *< Time of arrival of ACK at FTM Responder in pSec 
   */
  uint64_t t4;
};
#define WIFI_FTM_REPORT_ENTRY__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&wifi_ftm_report_entry__descriptor) \
    , 0, 0, 0, 0, 0, 0, 0 }


struct  WifiEventFtmReport
{
  ProtobufCMessage base;
  /*
   * *< 6bytes MAC address of the FTM Peer 
   */
  ProtobufCBinaryData peer_mac;
  /*
   * *< Status of the FTM operation 
   */
  int32_t status;
  /*
   * *< Raw average Round-Trip-Time with peer in Nano-Seconds 
   */
  uint32_t rtt_raw;
  /*
   * *< Estimated Round-Trip-Time with peer in Nano-Seconds 
   */
  uint32_t rtt_est;
  /*
   * *< Estimated one-way distance in Centi-Meters 
   */
  uint32_t dist_est;
  /*
   * *< Note var len Pointer to FTM Report with multiple entries, should be freed after use 
   */
  size_t n_ftm_report_data;
  WifiFtmReportEntry **ftm_report_data;
  /*
   * *< Number of entries in the FTM Report data 
   */
  uint32_t ftm_report_num_entries;
};
#define WIFI_EVENT_FTM_REPORT__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&wifi_event_ftm_report__descriptor) \
    , {0,NULL}, 0, 0, 0, 0, 0,NULL, 0 }


struct  WifiEventActionTxStatus
{
  ProtobufCMessage base;
  /*
   **< WiFi interface to send request to 
   */
  int32_t ifx;
  /*
   **< Context to identify the request 
   */
  uint32_t context;
  /*
   **< 6bytes Destination MAC address 
   */
  ProtobufCBinaryData da;
  /*
   **< Status of the operation 
   */
  uint32_t status;
};
#define WIFI_EVENT_ACTION_TX_STATUS__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&wifi_event_action_tx_status__descriptor) \
    , 0, 0, {0,NULL}, 0 }


struct  WifiEventRocDone
{
  ProtobufCMessage base;
  /*
   **< Context to identify the request 
   */
  uint32_t context;
};
#define WIFI_EVENT_ROC_DONE__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&wifi_event_roc_done__descriptor) \
    , 0 }


struct  WifiEventApWpsRgPin
{
  ProtobufCMessage base;
  /*
   **< 8bytes PIN code of station in enrollee mode 
   */
  ProtobufCBinaryData pin_code;
};
#define WIFI_EVENT_AP_WPS_RG_PIN__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&wifi_event_ap_wps_rg_pin__descriptor) \
    , {0,NULL} }


struct  WifiEventApWpsRgFailReason
{
  ProtobufCMessage base;
  /*
   **< WPS failure reason wps_fail_reason_t 
   */
  int32_t reason;
  /*
   **< 6bytes Enrollee mac address 
   */
  ProtobufCBinaryData peer_macaddr;
};
#define WIFI_EVENT_AP_WPS_RG_FAIL_REASON__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&wifi_event_ap_wps_rg_fail_reason__descriptor) \
    , 0, {0,NULL} }


struct  WifiEventApWpsRgSuccess
{
  ProtobufCMessage base;
  /*
   **< 6bytes Enrollee mac address 
   */
  ProtobufCBinaryData peer_macaddr;
};
#define WIFI_EVENT_AP_WPS_RG_SUCCESS__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&wifi_event_ap_wps_rg_success__descriptor) \
    , {0,NULL} }


struct  WifiProtocols
{
  ProtobufCMessage base;
  /*
   **< Represents 2.4 GHz protocol, support 802.11b or 802.11g or 802.11n or 802.11ax or LR mode 
   */
  uint32_t ghz_2g;
  /*
   **< Represents 5 GHz protocol, support 802.11a or 802.11n or 802.11ac or 802.11ax 
   */
  uint32_t ghz_5g;
};
#define WIFI_PROTOCOLS__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&wifi_protocols__descriptor) \
    , 0, 0 }


struct  WifiBandwidths
{
  ProtobufCMessage base;
  /*
   * Represents 2.4 GHz bandwidth 
   */
  uint32_t ghz_2g;
  /*
   * Represents 5 GHz bandwidth 
   */
  uint32_t ghz_5g;
};
#define WIFI_BANDWIDTHS__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&wifi_bandwidths__descriptor) \
    , 0, 0 }


struct  WifiItwtSetupConfig
{
  ProtobufCMessage base;
  uint32_t setup_cmd;
  /*
   * uint16_t trigger : 1;                **< 1: a trigger-enabled individual TWT, 0: a non-trigger-enabled individual TWT * 
   * uint16_t flow_type : 1;              **< 0: an announced individual TWT, 1: an unannounced individual TWT * 
   * uint16_t flow_id : 3;                 **< When set up an individual TWT agreement, the flow id will be assigned by AP after a successful agreement setup.
   *                                          flow_id could be specified to a value in the range of [0, 7], but it might be changed by AP in the response.
   *                                          When change TWT parameters of the existing TWT agreement, flow_id should be an existing one. The value range is [0, 7]. * 
   * uint16_t wake_invl_expn : 5;         **< Individual TWT Wake Interval Exponent. The value range is [0, 31]. * 
   * uint16_t wake_duration_unit : 1;     **< Individual TWT Wake duration unit, 0: 256us 1: TU (TU = 1024us)* 
   * uint16_t reserved : 5;               **< bit: 11.15 reserved * 
   */
  uint32_t bitmask_1;
  uint32_t min_wake_dura;
  uint32_t wake_invl_mant;
  uint32_t twt_id;
  uint32_t timeout_time_ms;
};
#define WIFI_ITWT_SETUP_CONFIG__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&wifi_itwt_setup_config__descriptor) \
    , 0, 0, 0, 0, 0, 0 }


struct  WifiTwtConfig
{
  ProtobufCMessage base;
  /*
   **< post twt wakeup event 
   */
  protobuf_c_boolean post_wakeup_event;
  /*
   **< twt enable send qos null to keep alive 
   */
  protobuf_c_boolean twt_enable_keep_alive;
};
#define WIFI_TWT_CONFIG__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&wifi_twt_config__descriptor) \
    , 0, 0 }


struct  EspAppDesc
{
  ProtobufCMessage base;
  /*
   *!< Magic word ESP_APP_DESC_MAGIC_WORD 
   */
  uint32_t magic_word;
  /*
   *!< Secure version 
   */
  uint32_t secure_version;
  /*
   *!< reserv1 
   */
  ProtobufCBinaryData reserv1;
  /*
   *!< Application version 
   */
  ProtobufCBinaryData version;
  /*
   *!< Project name 
   */
  ProtobufCBinaryData project_name;
  /*
   *!< Compile time 
   */
  ProtobufCBinaryData time;
  /*
   *!< Compile date
   */
  ProtobufCBinaryData date;
  /*
   *!< Version IDF 
   */
  ProtobufCBinaryData idf_ver;
  /*
   *!< sha256 of elf file 
   */
  ProtobufCBinaryData app_elf_sha256;
  /*
   *!< Minimal eFuse block revision supported by image, in format: major * 100 + minor 
   */
  uint32_t min_efuse_blk_rev_full;
  /*
   *!< Maximal eFuse block revision supported by image, in format: major * 100 + minor 
   */
  uint32_t max_efuse_blk_rev_full;
  /*
   *!< MMU page size in log base 2 format 
   */
  uint32_t mmu_page_size;
  /*
   *!< reserv3 
   */
  ProtobufCBinaryData reserv3;
  /*
   *!< reserv2 
   */
  ProtobufCBinaryData reserv2;
};
#define ESP_APP_DESC__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&esp_app_desc__descriptor) \
    , 0, 0, {0,NULL}, {0,NULL}, {0,NULL}, {0,NULL}, {0,NULL}, {0,NULL}, {0,NULL}, 0, 0, 0, {0,NULL}, {0,NULL} }


/*
 * heap size threshold based on memory capability
 */
struct  HeapSizeThreshold
{
  ProtobufCMessage base;
  uint32_t threshold_mem_dma;
  uint32_t threshold_mem_8bit;
};
#define HEAP_SIZE_THRESHOLD__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&heap_size_threshold__descriptor) \
    , 0, 0 }


struct  MemInfo
{
  ProtobufCMessage base;
  /*
   * current heap free size
   */
  uint32_t free_size;
  /*
   * largest free block of memory able to be allocated
   */
  uint32_t largest_free_block;
};
#define MEM_INFO__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&mem_info__descriptor) \
    , 0, 0 }


/*
 * heap info based on capability
 */
struct  HeapInfo
{
  ProtobufCMessage base;
  MemInfo *mem_dma;
  MemInfo *mem_8bit;
};
#define HEAP_INFO__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&heap_info__descriptor) \
    , NULL, NULL }


struct  ConnectedSTAList
{
  ProtobufCMessage base;
  ProtobufCBinaryData mac;
  int32_t rssi;
};
#define CONNECTED_STALIST__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&connected_stalist__descriptor) \
    , {0,NULL}, 0 }


struct  EapFastConfig
{
  ProtobufCMessage base;
  /*
   * Enable or disable Fast Provisioning in EAP-FAST (0 = disabled, 1 = enabled)
   */
  int32_t fast_provisioning;
  /*
   * Maximum length of the PAC (Protected Access Credential) list
   */
  int32_t fast_max_pac_list_len;
  /*
   * Set to true for binary format PAC, false for ASCII format PAC
   */
  protobuf_c_boolean fast_pac_format_binary;
};
#define EAP_FAST_CONFIG__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&eap_fast_config__descriptor) \
    , 0, 0, 0 }


/*
 ** Req/Resp structure *
 */
struct  RpcReqGetMacAddress
{
  ProtobufCMessage base;
  int32_t mode;
};
#define RPC__REQ__GET_MAC_ADDRESS__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&rpc__req__get_mac_address__descriptor) \
    , 0 }


struct  RpcRespGetMacAddress
{
  ProtobufCMessage base;
  ProtobufCBinaryData mac;
  int32_t resp;
};
#define RPC__RESP__GET_MAC_ADDRESS__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__get_mac_address__descriptor) \
    , {0,NULL}, 0 }


struct  RpcReqGetMode
{
  ProtobufCMessage base;
};
#define RPC__REQ__GET_MODE__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&rpc__req__get_mode__descriptor) \
     }


struct  RpcRespGetMode
{
  ProtobufCMessage base;
  int32_t mode;
  int32_t resp;
};
#define RPC__RESP__GET_MODE__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__get_mode__descriptor) \
    , 0, 0 }


struct  RpcReqSetMode
{
  ProtobufCMessage base;
  int32_t mode;
};
#define RPC__REQ__SET_MODE__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&rpc__req__set_mode__descriptor) \
    , 0 }


struct  RpcRespSetMode
{
  ProtobufCMessage base;
  int32_t resp;
};
#define RPC__RESP__SET_MODE__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__set_mode__descriptor) \
    , 0 }


struct  RpcReqGetPs
{
  ProtobufCMessage base;
};
#define RPC__REQ__GET_PS__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&rpc__req__get_ps__descriptor) \
     }


struct  RpcRespGetPs
{
  ProtobufCMessage base;
  int32_t resp;
  int32_t type;
};
#define RPC__RESP__GET_PS__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__get_ps__descriptor) \
    , 0, 0 }


struct  RpcReqSetPs
{
  ProtobufCMessage base;
  int32_t type;
};
#define RPC__REQ__SET_PS__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&rpc__req__set_ps__descriptor) \
    , 0 }


struct  RpcRespSetPs
{
  ProtobufCMessage base;
  int32_t resp;
};
#define RPC__RESP__SET_PS__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__set_ps__descriptor) \
    , 0 }


struct  RpcReqSetMacAddress
{
  ProtobufCMessage base;
  ProtobufCBinaryData mac;
  int32_t mode;
};
#define RPC__REQ__SET_MAC_ADDRESS__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&rpc__req__set_mac_address__descriptor) \
    , {0,NULL}, 0 }


struct  RpcRespSetMacAddress
{
  ProtobufCMessage base;
  int32_t resp;
};
#define RPC__RESP__SET_MAC_ADDRESS__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__set_mac_address__descriptor) \
    , 0 }


struct  RpcReqOTABegin
{
  ProtobufCMessage base;
};
#define RPC__REQ__OTABEGIN__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&rpc__req__otabegin__descriptor) \
     }


struct  RpcRespOTABegin
{
  ProtobufCMessage base;
  int32_t resp;
};
#define RPC__RESP__OTABEGIN__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__otabegin__descriptor) \
    , 0 }


struct  RpcReqOTAWrite
{
  ProtobufCMessage base;
  ProtobufCBinaryData ota_data;
};
#define RPC__REQ__OTAWRITE__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&rpc__req__otawrite__descriptor) \
    , {0,NULL} }


struct  RpcRespOTAWrite
{
  ProtobufCMessage base;
  int32_t resp;
};
#define RPC__RESP__OTAWRITE__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__otawrite__descriptor) \
    , 0 }


struct  RpcReqOTAEnd
{
  ProtobufCMessage base;
};
#define RPC__REQ__OTAEND__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&rpc__req__otaend__descriptor) \
     }


struct  RpcRespOTAEnd
{
  ProtobufCMessage base;
  int32_t resp;
};
#define RPC__RESP__OTAEND__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__otaend__descriptor) \
    , 0 }


struct  RpcReqOTAActivate
{
  ProtobufCMessage base;
};
#define RPC__REQ__OTAACTIVATE__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&rpc__req__otaactivate__descriptor) \
     }


struct  RpcRespOTAActivate
{
  ProtobufCMessage base;
  int32_t resp;
};
#define RPC__RESP__OTAACTIVATE__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__otaactivate__descriptor) \
    , 0 }


struct  RpcReqAppGetDesc
{
  ProtobufCMessage base;
};
#define RPC__REQ__APP_GET_DESC__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&rpc__req__app_get_desc__descriptor) \
     }


struct  RpcRespAppGetDesc
{
  ProtobufCMessage base;
  int32_t resp;
  EspAppDesc *app_desc;
};
#define RPC__RESP__APP_GET_DESC__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__app_get_desc__descriptor) \
    , 0, NULL }


struct  RpcReqWifiSetMaxTxPower
{
  ProtobufCMessage base;
  int32_t power;
};
#define RPC__REQ__WIFI_SET_MAX_TX_POWER__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&rpc__req__wifi_set_max_tx_power__descriptor) \
    , 0 }


struct  RpcRespWifiSetMaxTxPower
{
  ProtobufCMessage base;
  int32_t resp;
};
#define RPC__RESP__WIFI_SET_MAX_TX_POWER__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__wifi_set_max_tx_power__descriptor) \
    , 0 }


struct  RpcReqWifiGetMaxTxPower
{
  ProtobufCMessage base;
};
#define RPC__REQ__WIFI_GET_MAX_TX_POWER__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&rpc__req__wifi_get_max_tx_power__descriptor) \
     }


struct  RpcRespWifiGetMaxTxPower
{
  ProtobufCMessage base;
  int32_t power;
  int32_t resp;
};
#define RPC__RESP__WIFI_GET_MAX_TX_POWER__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__wifi_get_max_tx_power__descriptor) \
    , 0, 0 }


struct  RpcReqConfigHeartbeat
{
  ProtobufCMessage base;
  protobuf_c_boolean enable;
  int32_t duration;
};
#define RPC__REQ__CONFIG_HEARTBEAT__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&rpc__req__config_heartbeat__descriptor) \
    , 0, 0 }


struct  RpcRespConfigHeartbeat
{
  ProtobufCMessage base;
  int32_t resp;
};
#define RPC__RESP__CONFIG_HEARTBEAT__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__config_heartbeat__descriptor) \
    , 0 }


struct  RpcReqWifiInit
{
  ProtobufCMessage base;
  WifiInitConfig *cfg;
};
#define RPC__REQ__WIFI_INIT__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&rpc__req__wifi_init__descriptor) \
    , NULL }


struct  RpcRespWifiInit
{
  ProtobufCMessage base;
  int32_t resp;
};
#define RPC__RESP__WIFI_INIT__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__wifi_init__descriptor) \
    , 0 }


struct  RpcReqWifiDeinit
{
  ProtobufCMessage base;
};
#define RPC__REQ__WIFI_DEINIT__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&rpc__req__wifi_deinit__descriptor) \
     }


struct  RpcRespWifiDeinit
{
  ProtobufCMessage base;
  int32_t resp;
};
#define RPC__RESP__WIFI_DEINIT__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__wifi_deinit__descriptor) \
    , 0 }


struct  RpcReqWifiSetConfig
{
  ProtobufCMessage base;
  int32_t iface;
  WifiConfig *cfg;
};
#define RPC__REQ__WIFI_SET_CONFIG__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&rpc__req__wifi_set_config__descriptor) \
    , 0, NULL }


struct  RpcRespWifiSetConfig
{
  ProtobufCMessage base;
  int32_t resp;
};
#define RPC__RESP__WIFI_SET_CONFIG__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__wifi_set_config__descriptor) \
    , 0 }


struct  RpcReqWifiGetConfig
{
  ProtobufCMessage base;
  int32_t iface;
};
#define RPC__REQ__WIFI_GET_CONFIG__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&rpc__req__wifi_get_config__descriptor) \
    , 0 }


struct  RpcRespWifiGetConfig
{
  ProtobufCMessage base;
  int32_t resp;
  int32_t iface;
  WifiConfig *cfg;
};
#define RPC__RESP__WIFI_GET_CONFIG__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__wifi_get_config__descriptor) \
    , 0, 0, NULL }


struct  RpcReqWifiConnect
{
  ProtobufCMessage base;
};
#define RPC__REQ__WIFI_CONNECT__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&rpc__req__wifi_connect__descriptor) \
     }


struct  RpcRespWifiConnect
{
  ProtobufCMessage base;
  int32_t resp;
};
#define RPC__RESP__WIFI_CONNECT__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__wifi_connect__descriptor) \
    , 0 }


struct  RpcReqWifiDisconnect
{
  ProtobufCMessage base;
};
#define RPC__REQ__WIFI_DISCONNECT__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&rpc__req__wifi_disconnect__descriptor) \
     }


struct  RpcRespWifiDisconnect
{
  ProtobufCMessage base;
  int32_t resp;
};
#define RPC__RESP__WIFI_DISCONNECT__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__wifi_disconnect__descriptor) \
    , 0 }


struct  RpcReqWifiStart
{
  ProtobufCMessage base;
};
#define RPC__REQ__WIFI_START__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&rpc__req__wifi_start__descriptor) \
     }


struct  RpcRespWifiStart
{
  ProtobufCMessage base;
  int32_t resp;
};
#define RPC__RESP__WIFI_START__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__wifi_start__descriptor) \
    , 0 }


struct  RpcReqWifiStop
{
  ProtobufCMessage base;
};
#define RPC__REQ__WIFI_STOP__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&rpc__req__wifi_stop__descriptor) \
     }


struct  RpcRespWifiStop
{
  ProtobufCMessage base;
  int32_t resp;
};
#define RPC__RESP__WIFI_STOP__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__wifi_stop__descriptor) \
    , 0 }


struct  RpcReqWifiScanStart
{
  ProtobufCMessage base;
  WifiScanConfig *config;
  protobuf_c_boolean block;
  int32_t config_set;
};
#define RPC__REQ__WIFI_SCAN_START__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&rpc__req__wifi_scan_start__descriptor) \
    , NULL, 0, 0 }


struct  RpcRespWifiScanStart
{
  ProtobufCMessage base;
  int32_t resp;
};
#define RPC__RESP__WIFI_SCAN_START__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__wifi_scan_start__descriptor) \
    , 0 }


struct  RpcReqWifiScanStop
{
  ProtobufCMessage base;
};
#define RPC__REQ__WIFI_SCAN_STOP__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&rpc__req__wifi_scan_stop__descriptor) \
     }


struct  RpcRespWifiScanStop
{
  ProtobufCMessage base;
  int32_t resp;
};
#define RPC__RESP__WIFI_SCAN_STOP__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__wifi_scan_stop__descriptor) \
    , 0 }


struct  RpcReqWifiScanGetApNum
{
  ProtobufCMessage base;
};
#define RPC__REQ__WIFI_SCAN_GET_AP_NUM__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&rpc__req__wifi_scan_get_ap_num__descriptor) \
     }


struct  RpcRespWifiScanGetApNum
{
  ProtobufCMessage base;
  int32_t resp;
  int32_t number;
};
#define RPC__RESP__WIFI_SCAN_GET_AP_NUM__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__wifi_scan_get_ap_num__descriptor) \
    , 0, 0 }


struct  RpcReqWifiScanGetApRecords
{
  ProtobufCMessage base;
  int32_t number;
};
#define RPC__REQ__WIFI_SCAN_GET_AP_RECORDS__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&rpc__req__wifi_scan_get_ap_records__descriptor) \
    , 0 }


struct  RpcRespWifiScanGetApRecords
{
  ProtobufCMessage base;
  int32_t resp;
  int32_t number;
  size_t n_ap_records;
  WifiApRecord **ap_records;
};
#define RPC__RESP__WIFI_SCAN_GET_AP_RECORDS__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__wifi_scan_get_ap_records__descriptor) \
    , 0, 0, 0,NULL }


struct  RpcReqWifiScanGetApRecord
{
  ProtobufCMessage base;
};
#define RPC__REQ__WIFI_SCAN_GET_AP_RECORD__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&rpc__req__wifi_scan_get_ap_record__descriptor) \
     }


struct  RpcRespWifiScanGetApRecord
{
  ProtobufCMessage base;
  int32_t resp;
  WifiApRecord *ap_record;
};
#define RPC__RESP__WIFI_SCAN_GET_AP_RECORD__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__wifi_scan_get_ap_record__descriptor) \
    , 0, NULL }


struct  RpcReqWifiClearApList
{
  ProtobufCMessage base;
};
#define RPC__REQ__WIFI_CLEAR_AP_LIST__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&rpc__req__wifi_clear_ap_list__descriptor) \
     }


struct  RpcRespWifiClearApList
{
  ProtobufCMessage base;
  int32_t resp;
};
#define RPC__RESP__WIFI_CLEAR_AP_LIST__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__wifi_clear_ap_list__descriptor) \
    , 0 }


struct  RpcReqWifiRestore
{
  ProtobufCMessage base;
};
#define RPC__REQ__WIFI_RESTORE__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&rpc__req__wifi_restore__descriptor) \
     }


struct  RpcRespWifiRestore
{
  ProtobufCMessage base;
  int32_t resp;
};
#define RPC__RESP__WIFI_RESTORE__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__wifi_restore__descriptor) \
    , 0 }


struct  RpcReqWifiClearFastConnect
{
  ProtobufCMessage base;
};
#define RPC__REQ__WIFI_CLEAR_FAST_CONNECT__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&rpc__req__wifi_clear_fast_connect__descriptor) \
     }


struct  RpcRespWifiClearFastConnect
{
  ProtobufCMessage base;
  int32_t resp;
};
#define RPC__RESP__WIFI_CLEAR_FAST_CONNECT__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__wifi_clear_fast_connect__descriptor) \
    , 0 }


struct  RpcReqWifiDeauthSta
{
  ProtobufCMessage base;
  int32_t aid;
};
#define RPC__REQ__WIFI_DEAUTH_STA__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&rpc__req__wifi_deauth_sta__descriptor) \
    , 0 }


struct  RpcRespWifiDeauthSta
{
  ProtobufCMessage base;
  int32_t resp;
  int32_t aid;
};
#define RPC__RESP__WIFI_DEAUTH_STA__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__wifi_deauth_sta__descriptor) \
    , 0, 0 }


struct  RpcReqWifiStaGetApInfo
{
  ProtobufCMessage base;
};
#define RPC__REQ__WIFI_STA_GET_AP_INFO__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&rpc__req__wifi_sta_get_ap_info__descriptor) \
     }


struct  RpcRespWifiStaGetApInfo
{
  ProtobufCMessage base;
  int32_t resp;
  WifiApRecord *ap_record;
};
#define RPC__RESP__WIFI_STA_GET_AP_INFO__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__wifi_sta_get_ap_info__descriptor) \
    , 0, NULL }


struct  RpcReqWifiSetProtocol
{
  ProtobufCMessage base;
  int32_t ifx;
  int32_t protocol_bitmap;
};
#define RPC__REQ__WIFI_SET_PROTOCOL__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&rpc__req__wifi_set_protocol__descriptor) \
    , 0, 0 }


struct  RpcRespWifiSetProtocol
{
  ProtobufCMessage base;
  int32_t resp;
};
#define RPC__RESP__WIFI_SET_PROTOCOL__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__wifi_set_protocol__descriptor) \
    , 0 }


struct  RpcReqWifiGetProtocol
{
  ProtobufCMessage base;
  int32_t ifx;
};
#define RPC__REQ__WIFI_GET_PROTOCOL__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&rpc__req__wifi_get_protocol__descriptor) \
    , 0 }


struct  RpcRespWifiGetProtocol
{
  ProtobufCMessage base;
  int32_t resp;
  int32_t protocol_bitmap;
};
#define RPC__RESP__WIFI_GET_PROTOCOL__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__wifi_get_protocol__descriptor) \
    , 0, 0 }


struct  RpcReqWifiSetBandwidth
{
  ProtobufCMessage base;
  int32_t ifx;
  int32_t bw;
};
#define RPC__REQ__WIFI_SET_BANDWIDTH__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&rpc__req__wifi_set_bandwidth__descriptor) \
    , 0, 0 }


struct  RpcRespWifiSetBandwidth
{
  ProtobufCMessage base;
  int32_t resp;
};
#define RPC__RESP__WIFI_SET_BANDWIDTH__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__wifi_set_bandwidth__descriptor) \
    , 0 }


struct  RpcReqWifiGetBandwidth
{
  ProtobufCMessage base;
  int32_t ifx;
};
#define RPC__REQ__WIFI_GET_BANDWIDTH__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&rpc__req__wifi_get_bandwidth__descriptor) \
    , 0 }


struct  RpcRespWifiGetBandwidth
{
  ProtobufCMessage base;
  int32_t resp;
  int32_t bw;
};
#define RPC__RESP__WIFI_GET_BANDWIDTH__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__wifi_get_bandwidth__descriptor) \
    , 0, 0 }


struct  RpcReqWifiSetChannel
{
  ProtobufCMessage base;
  int32_t primary;
  int32_t second;
};
#define RPC__REQ__WIFI_SET_CHANNEL__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&rpc__req__wifi_set_channel__descriptor) \
    , 0, 0 }


struct  RpcRespWifiSetChannel
{
  ProtobufCMessage base;
  int32_t resp;
};
#define RPC__RESP__WIFI_SET_CHANNEL__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__wifi_set_channel__descriptor) \
    , 0 }


struct  RpcReqWifiGetChannel
{
  ProtobufCMessage base;
};
#define RPC__REQ__WIFI_GET_CHANNEL__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&rpc__req__wifi_get_channel__descriptor) \
     }


struct  RpcRespWifiGetChannel
{
  ProtobufCMessage base;
  int32_t resp;
  int32_t primary;
  int32_t second;
};
#define RPC__RESP__WIFI_GET_CHANNEL__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__wifi_get_channel__descriptor) \
    , 0, 0, 0 }


struct  RpcReqWifiSetStorage
{
  ProtobufCMessage base;
  int32_t storage;
};
#define RPC__REQ__WIFI_SET_STORAGE__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&rpc__req__wifi_set_storage__descriptor) \
    , 0 }


struct  RpcRespWifiSetStorage
{
  ProtobufCMessage base;
  int32_t resp;
};
#define RPC__RESP__WIFI_SET_STORAGE__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__wifi_set_storage__descriptor) \
    , 0 }


struct  RpcReqWifiSetCountryCode
{
  ProtobufCMessage base;
  ProtobufCBinaryData country;
  protobuf_c_boolean ieee80211d_enabled;
};
#define RPC__REQ__WIFI_SET_COUNTRY_CODE__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&rpc__req__wifi_set_country_code__descriptor) \
    , {0,NULL}, 0 }


struct  RpcRespWifiSetCountryCode
{
  ProtobufCMessage base;
  int32_t resp;
};
#define RPC__RESP__WIFI_SET_COUNTRY_CODE__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__wifi_set_country_code__descriptor) \
    , 0 }


struct  RpcReqWifiGetCountryCode
{
  ProtobufCMessage base;
};
#define RPC__REQ__WIFI_GET_COUNTRY_CODE__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&rpc__req__wifi_get_country_code__descriptor) \
     }


struct  RpcRespWifiGetCountryCode
{
  ProtobufCMessage base;
  int32_t resp;
  ProtobufCBinaryData country;
};
#define RPC__RESP__WIFI_GET_COUNTRY_CODE__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__wifi_get_country_code__descriptor) \
    , 0, {0,NULL} }


struct  RpcReqWifiSetCountry
{
  ProtobufCMessage base;
  WifiCountry *country;
};
#define RPC__REQ__WIFI_SET_COUNTRY__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&rpc__req__wifi_set_country__descriptor) \
    , NULL }


struct  RpcRespWifiSetCountry
{
  ProtobufCMessage base;
  int32_t resp;
};
#define RPC__RESP__WIFI_SET_COUNTRY__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__wifi_set_country__descriptor) \
    , 0 }


struct  RpcReqWifiGetCountry
{
  ProtobufCMessage base;
};
#define RPC__REQ__WIFI_GET_COUNTRY__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&rpc__req__wifi_get_country__descriptor) \
     }


struct  RpcRespWifiGetCountry
{
  ProtobufCMessage base;
  int32_t resp;
  WifiCountry *country;
};
#define RPC__RESP__WIFI_GET_COUNTRY__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__wifi_get_country__descriptor) \
    , 0, NULL }


struct  RpcReqWifiApGetStaList
{
  ProtobufCMessage base;
};
#define RPC__REQ__WIFI_AP_GET_STA_LIST__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&rpc__req__wifi_ap_get_sta_list__descriptor) \
     }


struct  RpcRespWifiApGetStaList
{
  ProtobufCMessage base;
  int32_t resp;
  WifiStaList *sta_list;
};
#define RPC__RESP__WIFI_AP_GET_STA_LIST__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__wifi_ap_get_sta_list__descriptor) \
    , 0, NULL }


struct  RpcReqWifiApGetStaAid
{
  ProtobufCMessage base;
  ProtobufCBinaryData mac;
};
#define RPC__REQ__WIFI_AP_GET_STA_AID__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&rpc__req__wifi_ap_get_sta_aid__descriptor) \
    , {0,NULL} }


struct  RpcReqWifiStaGetNegotiatedPhymode
{
  ProtobufCMessage base;
};
#define RPC__REQ__WIFI_STA_GET_NEGOTIATED_PHYMODE__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&rpc__req__wifi_sta_get_negotiated_phymode__descriptor) \
     }


struct  RpcRespWifiStaGetNegotiatedPhymode
{
  ProtobufCMessage base;
  int32_t resp;
  uint32_t phymode;
};
#define RPC__RESP__WIFI_STA_GET_NEGOTIATED_PHYMODE__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__wifi_sta_get_negotiated_phymode__descriptor) \
    , 0, 0 }


struct  RpcRespWifiApGetStaAid
{
  ProtobufCMessage base;
  int32_t resp;
  uint32_t aid;
};
#define RPC__RESP__WIFI_AP_GET_STA_AID__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__wifi_ap_get_sta_aid__descriptor) \
    , 0, 0 }


struct  RpcReqWifiStaGetRssi
{
  ProtobufCMessage base;
};
#define RPC__REQ__WIFI_STA_GET_RSSI__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&rpc__req__wifi_sta_get_rssi__descriptor) \
     }


struct  RpcRespWifiStaGetRssi
{
  ProtobufCMessage base;
  int32_t resp;
  int32_t rssi;
};
#define RPC__RESP__WIFI_STA_GET_RSSI__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__wifi_sta_get_rssi__descriptor) \
    , 0, 0 }


struct  RpcReqWifiScanParams
{
  ProtobufCMessage base;
  RpcCmd cmd;
  WifiScanDefaultParams *config;
  protobuf_c_boolean is_config_null;
};
#define RPC__REQ__WIFI_SCAN_PARAMS__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&rpc__req__wifi_scan_params__descriptor) \
    , RPC_CMD__Invalid, NULL, 0 }


struct  RpcRespWifiScanParams
{
  ProtobufCMessage base;
  int32_t resp;
  WifiScanDefaultParams *config;
};
#define RPC__RESP__WIFI_SCAN_PARAMS__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__wifi_scan_params__descriptor) \
    , 0, NULL }


struct  RpcReqWifiStaGetAid
{
  ProtobufCMessage base;
};
#define RPC__REQ__WIFI_STA_GET_AID__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&rpc__req__wifi_sta_get_aid__descriptor) \
     }


struct  RpcRespWifiStaGetAid
{
  ProtobufCMessage base;
  int32_t resp;
  uint32_t aid;
};
#define RPC__RESP__WIFI_STA_GET_AID__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__wifi_sta_get_aid__descriptor) \
    , 0, 0 }


struct  RpcReqWifiSetProtocols
{
  ProtobufCMessage base;
  int32_t ifx;
  WifiProtocols *protocols;
};
#define RPC__REQ__WIFI_SET_PROTOCOLS__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&rpc__req__wifi_set_protocols__descriptor) \
    , 0, NULL }


struct  RpcRespWifiSetProtocols
{
  ProtobufCMessage base;
  int32_t resp;
  uint32_t ifx;
};
#define RPC__RESP__WIFI_SET_PROTOCOLS__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__wifi_set_protocols__descriptor) \
    , 0, 0 }


struct  RpcReqWifiGetProtocols
{
  ProtobufCMessage base;
  int32_t ifx;
};
#define RPC__REQ__WIFI_GET_PROTOCOLS__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&rpc__req__wifi_get_protocols__descriptor) \
    , 0 }


struct  RpcRespWifiGetProtocols
{
  ProtobufCMessage base;
  int32_t resp;
  int32_t ifx;
  WifiProtocols *protocols;
};
#define RPC__RESP__WIFI_GET_PROTOCOLS__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__wifi_get_protocols__descriptor) \
    , 0, 0, NULL }


struct  RpcReqWifiSetBandwidths
{
  ProtobufCMessage base;
  int32_t ifx;
  WifiBandwidths *bandwidths;
};
#define RPC__REQ__WIFI_SET_BANDWIDTHS__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&rpc__req__wifi_set_bandwidths__descriptor) \
    , 0, NULL }


struct  RpcRespWifiSetBandwidths
{
  ProtobufCMessage base;
  int32_t resp;
  int32_t ifx;
};
#define RPC__RESP__WIFI_SET_BANDWIDTHS__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__wifi_set_bandwidths__descriptor) \
    , 0, 0 }


struct  RpcReqWifiGetBandwidths
{
  ProtobufCMessage base;
  int32_t ifx;
};
#define RPC__REQ__WIFI_GET_BANDWIDTHS__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&rpc__req__wifi_get_bandwidths__descriptor) \
    , 0 }


struct  RpcRespWifiGetBandwidths
{
  ProtobufCMessage base;
  int32_t resp;
  int32_t ifx;
  WifiBandwidths *bandwidths;
};
#define RPC__RESP__WIFI_GET_BANDWIDTHS__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__wifi_get_bandwidths__descriptor) \
    , 0, 0, NULL }


struct  RpcReqWifiSetBand
{
  ProtobufCMessage base;
  uint32_t band;
};
#define RPC__REQ__WIFI_SET_BAND__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&rpc__req__wifi_set_band__descriptor) \
    , 0 }


struct  RpcRespWifiSetBand
{
  ProtobufCMessage base;
  int32_t resp;
};
#define RPC__RESP__WIFI_SET_BAND__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__wifi_set_band__descriptor) \
    , 0 }


struct  RpcReqWifiGetBand
{
  ProtobufCMessage base;
};
#define RPC__REQ__WIFI_GET_BAND__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&rpc__req__wifi_get_band__descriptor) \
     }


struct  RpcRespWifiGetBand
{
  ProtobufCMessage base;
  int32_t resp;
  uint32_t band;
};
#define RPC__RESP__WIFI_GET_BAND__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__wifi_get_band__descriptor) \
    , 0, 0 }


struct  RpcReqWifiSetBandMode
{
  ProtobufCMessage base;
  uint32_t bandmode;
};
#define RPC__REQ__WIFI_SET_BAND_MODE__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&rpc__req__wifi_set_band_mode__descriptor) \
    , 0 }


struct  RpcRespWifiSetBandMode
{
  ProtobufCMessage base;
  int32_t resp;
};
#define RPC__RESP__WIFI_SET_BAND_MODE__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__wifi_set_band_mode__descriptor) \
    , 0 }


struct  RpcReqWifiGetBandMode
{
  ProtobufCMessage base;
};
#define RPC__REQ__WIFI_GET_BAND_MODE__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&rpc__req__wifi_get_band_mode__descriptor) \
     }


struct  RpcRespWifiGetBandMode
{
  ProtobufCMessage base;
  int32_t resp;
  uint32_t bandmode;
};
#define RPC__RESP__WIFI_GET_BAND_MODE__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__wifi_get_band_mode__descriptor) \
    , 0, 0 }


struct  RpcReqWifiSetInactiveTime
{
  ProtobufCMessage base;
  uint32_t ifx;
  uint32_t sec;
};
#define RPC__REQ__WIFI_SET_INACTIVE_TIME__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&rpc__req__wifi_set_inactive_time__descriptor) \
    , 0, 0 }


struct  RpcRespWifiSetInactiveTime
{
  ProtobufCMessage base;
  int32_t resp;
};
#define RPC__RESP__WIFI_SET_INACTIVE_TIME__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__wifi_set_inactive_time__descriptor) \
    , 0 }


struct  RpcReqWifiGetInactiveTime
{
  ProtobufCMessage base;
  uint32_t ifx;
};
#define RPC__REQ__WIFI_GET_INACTIVE_TIME__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&rpc__req__wifi_get_inactive_time__descriptor) \
    , 0 }


struct  RpcRespWifiGetInactiveTime
{
  ProtobufCMessage base;
  int32_t resp;
  uint32_t sec;
};
#define RPC__RESP__WIFI_GET_INACTIVE_TIME__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__wifi_get_inactive_time__descriptor) \
    , 0, 0 }


struct  RpcReqWifiDisablePmfConfig
{
  ProtobufCMessage base;
  uint32_t ifx;
};
#define RPC__REQ__WIFI_DISABLE_PMF_CONFIG__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&rpc__req__wifi_disable_pmf_config__descriptor) \
    , 0 }


struct  RpcRespWifiDisablePmfConfig
{
  ProtobufCMessage base;
  int32_t resp;
  uint32_t ifx;
};
#define RPC__RESP__WIFI_DISABLE_PMF_CONFIG__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__wifi_disable_pmf_config__descriptor) \
    , 0, 0 }


struct  RpcReqWifiStaItwtSetup
{
  ProtobufCMessage base;
  WifiItwtSetupConfig *setup_config;
};
#define RPC__REQ__WIFI_STA_ITWT_SETUP__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&rpc__req__wifi_sta_itwt_setup__descriptor) \
    , NULL }


struct  RpcRespWifiStaItwtSetup
{
  ProtobufCMessage base;
  int32_t resp;
};
#define RPC__RESP__WIFI_STA_ITWT_SETUP__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__wifi_sta_itwt_setup__descriptor) \
    , 0 }


struct  RpcReqWifiStaItwtTeardown
{
  ProtobufCMessage base;
  int32_t flow_id;
};
#define RPC__REQ__WIFI_STA_ITWT_TEARDOWN__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&rpc__req__wifi_sta_itwt_teardown__descriptor) \
    , 0 }


struct  RpcRespWifiStaItwtTeardown
{
  ProtobufCMessage base;
  int32_t resp;
};
#define RPC__RESP__WIFI_STA_ITWT_TEARDOWN__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__wifi_sta_itwt_teardown__descriptor) \
    , 0 }


struct  RpcReqWifiStaItwtSuspend
{
  ProtobufCMessage base;
  int32_t flow_id;
  int32_t suspend_time_ms;
};
#define RPC__REQ__WIFI_STA_ITWT_SUSPEND__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&rpc__req__wifi_sta_itwt_suspend__descriptor) \
    , 0, 0 }


struct  RpcRespWifiStaItwtSuspend
{
  ProtobufCMessage base;
  int32_t resp;
};
#define RPC__RESP__WIFI_STA_ITWT_SUSPEND__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__wifi_sta_itwt_suspend__descriptor) \
    , 0 }


struct  RpcReqWifiStaItwtGetFlowIdStatus
{
  ProtobufCMessage base;
};
#define RPC__REQ__WIFI_STA_ITWT_GET_FLOW_ID_STATUS__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&rpc__req__wifi_sta_itwt_get_flow_id_status__descriptor) \
     }


struct  RpcRespWifiStaItwtGetFlowIdStatus
{
  ProtobufCMessage base;
  int32_t resp;
  int32_t flow_id_bitmap;
};
#define RPC__RESP__WIFI_STA_ITWT_GET_FLOW_ID_STATUS__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__wifi_sta_itwt_get_flow_id_status__descriptor) \
    , 0, 0 }


struct  RpcReqWifiStaItwtSendProbeReq
{
  ProtobufCMessage base;
  int32_t timeout_ms;
};
#define RPC__REQ__WIFI_STA_ITWT_SEND_PROBE_REQ__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&rpc__req__wifi_sta_itwt_send_probe_req__descriptor) \
    , 0 }


struct  RpcRespWifiStaItwtSendProbeReq
{
  ProtobufCMessage base;
  int32_t resp;
};
#define RPC__RESP__WIFI_STA_ITWT_SEND_PROBE_REQ__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__wifi_sta_itwt_send_probe_req__descriptor) \
    , 0 }


struct  RpcReqWifiStaItwtSetTargetWakeTimeOffset
{
  ProtobufCMessage base;
  int32_t offset_us;
};
#define RPC__REQ__WIFI_STA_ITWT_SET_TARGET_WAKE_TIME_OFFSET__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&rpc__req__wifi_sta_itwt_set_target_wake_time_offset__descriptor) \
    , 0 }


struct  RpcRespWifiStaItwtSetTargetWakeTimeOffset
{
  ProtobufCMessage base;
  int32_t resp;
};
#define RPC__RESP__WIFI_STA_ITWT_SET_TARGET_WAKE_TIME_OFFSET__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__wifi_sta_itwt_set_target_wake_time_offset__descriptor) \
    , 0 }


struct  RpcReqWifiStaTwtConfig
{
  ProtobufCMessage base;
  WifiTwtConfig *config;
};
#define RPC__REQ__WIFI_STA_TWT_CONFIG__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&rpc__req__wifi_sta_twt_config__descriptor) \
    , NULL }


struct  RpcRespWifiStaTwtConfig
{
  ProtobufCMessage base;
  int32_t resp;
};
#define RPC__RESP__WIFI_STA_TWT_CONFIG__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__wifi_sta_twt_config__descriptor) \
    , 0 }


struct  RpcReqGetCoprocessorFwVersion
{
  ProtobufCMessage base;
};
#define RPC__REQ__GET_COPROCESSOR_FW_VERSION__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&rpc__req__get_coprocessor_fw_version__descriptor) \
     }


struct  RpcRespGetCoprocessorFwVersion
{
  ProtobufCMessage base;
  int32_t resp;
  uint32_t major1;
  uint32_t minor1;
  uint32_t patch1;
  int32_t revision;
  int32_t prerelease;
  int32_t build;
  /*
   * from sdkconfig->CONFIG_IDF_FIRMWARE_CHIP_ID
   */
  uint32_t chip_id;
  /*
   * from sdkconfig->CONFIG_IDF_TARGET
   */
  ProtobufCBinaryData idf_target;
};
#define RPC__RESP__GET_COPROCESSOR_FW_VERSION__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__get_coprocessor_fw_version__descriptor) \
    , 0, 0, 0, 0, 0, 0, 0, 0, {0,NULL} }


struct  RpcReqSetDhcpDnsStatus
{
  ProtobufCMessage base;
  int32_t iface;
  int32_t net_link_up;
  int32_t dhcp_up;
  ProtobufCBinaryData dhcp_ip;
  ProtobufCBinaryData dhcp_nm;
  ProtobufCBinaryData dhcp_gw;
  int32_t dns_up;
  ProtobufCBinaryData dns_ip;
  int32_t dns_type;
};
#define RPC__REQ__SET_DHCP_DNS_STATUS__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&rpc__req__set_dhcp_dns_status__descriptor) \
    , 0, 0, 0, {0,NULL}, {0,NULL}, {0,NULL}, 0, {0,NULL}, 0 }


struct  RpcRespSetDhcpDnsStatus
{
  ProtobufCMessage base;
  int32_t resp;
};
#define RPC__RESP__SET_DHCP_DNS_STATUS__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__set_dhcp_dns_status__descriptor) \
    , 0 }


struct  RpcReqGetDhcpDnsStatus
{
  ProtobufCMessage base;
  int32_t iface;
};
#define RPC__REQ__GET_DHCP_DNS_STATUS__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&rpc__req__get_dhcp_dns_status__descriptor) \
    , 0 }


struct  RpcRespGetDhcpDnsStatus
{
  ProtobufCMessage base;
  int32_t iface;
  int32_t net_link_up;
  int32_t dhcp_up;
  ProtobufCBinaryData dhcp_ip;
  ProtobufCBinaryData dhcp_nm;
  ProtobufCBinaryData dhcp_gw;
  int32_t dns_up;
  ProtobufCBinaryData dns_ip;
  int32_t dns_type;
  int32_t resp;
};
#define RPC__RESP__GET_DHCP_DNS_STATUS__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__get_dhcp_dns_status__descriptor) \
    , 0, 0, 0, {0,NULL}, {0,NULL}, {0,NULL}, 0, {0,NULL}, 0, 0 }


struct  RpcReqSuppDppInit
{
  ProtobufCMessage base;
  /*
   * enables sending of Event_SuppDpp to host via callback
   */
  protobuf_c_boolean cb;
};
#define RPC__REQ__SUPP_DPP_INIT__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&rpc__req__supp_dpp_init__descriptor) \
    , 0 }


struct  RpcRespSuppDppInit
{
  ProtobufCMessage base;
  int32_t resp;
};
#define RPC__RESP__SUPP_DPP_INIT__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__supp_dpp_init__descriptor) \
    , 0 }


struct  RpcReqSuppDppDeinit
{
  ProtobufCMessage base;
};
#define RPC__REQ__SUPP_DPP_DEINIT__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&rpc__req__supp_dpp_deinit__descriptor) \
     }


struct  RpcRespSuppDppDeinit
{
  ProtobufCMessage base;
  int32_t resp;
};
#define RPC__RESP__SUPP_DPP_DEINIT__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__supp_dpp_deinit__descriptor) \
    , 0 }


struct  RpcReqSuppDppBootstrapGen
{
  ProtobufCMessage base;
  /*
   * DPP Bootstrapping listen channels separated by commas
   */
  ProtobufCBinaryData chan_list;
  /*
   * Bootstrap method type, only QR Code method is supported for now.
   */
  int32_t type;
  /*
   * (Optional) 32 byte Raw Private Key for generating a Bootstrapping Public Key
   */
  ProtobufCBinaryData key;
  /*
   * (Optional) Ancillary Device Information like Serial Number
   */
  ProtobufCBinaryData info;
};
#define RPC__REQ__SUPP_DPP_BOOTSTRAP_GEN__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&rpc__req__supp_dpp_bootstrap_gen__descriptor) \
    , {0,NULL}, 0, {0,NULL}, {0,NULL} }


struct  RpcRespSuppDppBootstrapGen
{
  ProtobufCMessage base;
  int32_t resp;
};
#define RPC__RESP__SUPP_DPP_BOOTSTRAP_GEN__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__supp_dpp_bootstrap_gen__descriptor) \
    , 0 }


struct  RpcReqSuppDppStartListen
{
  ProtobufCMessage base;
};
#define RPC__REQ__SUPP_DPP_START_LISTEN__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&rpc__req__supp_dpp_start_listen__descriptor) \
     }


struct  RpcRespSuppDppStartListen
{
  ProtobufCMessage base;
  int32_t resp;
};
#define RPC__RESP__SUPP_DPP_START_LISTEN__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__supp_dpp_start_listen__descriptor) \
    , 0 }


struct  RpcReqSuppDppStopListen
{
  ProtobufCMessage base;
};
#define RPC__REQ__SUPP_DPP_STOP_LISTEN__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&rpc__req__supp_dpp_stop_listen__descriptor) \
     }


struct  RpcRespSuppDppStopListen
{
  ProtobufCMessage base;
  int32_t resp;
};
#define RPC__RESP__SUPP_DPP_STOP_LISTEN__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__supp_dpp_stop_listen__descriptor) \
    , 0 }


struct  RpcReqIfaceMacAddrSetGet
{
  ProtobufCMessage base;
  protobuf_c_boolean set;
  uint32_t type;
  /*
   * only valid for set
   */
  ProtobufCBinaryData mac;
};
#define RPC__REQ__IFACE_MAC_ADDR_SET_GET__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&rpc__req__iface_mac_addr_set_get__descriptor) \
    , 0, 0, {0,NULL} }


struct  RpcRespIfaceMacAddrSetGet
{
  ProtobufCMessage base;
  int32_t resp;
  protobuf_c_boolean set;
  uint32_t type;
  ProtobufCBinaryData mac;
};
#define RPC__RESP__IFACE_MAC_ADDR_SET_GET__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__iface_mac_addr_set_get__descriptor) \
    , 0, 0, 0, {0,NULL} }


struct  RpcReqIfaceMacAddrLenGet
{
  ProtobufCMessage base;
  uint32_t type;
};
#define RPC__REQ__IFACE_MAC_ADDR_LEN_GET__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&rpc__req__iface_mac_addr_len_get__descriptor) \
    , 0 }


struct  RpcRespIfaceMacAddrLenGet
{
  ProtobufCMessage base;
  int32_t resp;
  uint32_t type;
  uint32_t len;
};
#define RPC__RESP__IFACE_MAC_ADDR_LEN_GET__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__iface_mac_addr_len_get__descriptor) \
    , 0, 0, 0 }


struct  RpcReqFeatureControl
{
  ProtobufCMessage base;
  RpcFeature feature;
  RpcFeatureCommand command;
  RpcFeatureOption option;
};
#define RPC__REQ__FEATURE_CONTROL__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&rpc__req__feature_control__descriptor) \
    , RPC_FEATURE__Feature_None, RPC_FEATURE_COMMAND__Feature_Command_None, RPC_FEATURE_OPTION__Feature_Option_None }


struct  RpcRespFeatureControl
{
  ProtobufCMessage base;
  int32_t resp;
  RpcFeature feature;
  RpcFeatureCommand command;
  RpcFeatureOption option;
};
#define RPC__RESP__FEATURE_CONTROL__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__feature_control__descriptor) \
    , 0, RPC_FEATURE__Feature_None, RPC_FEATURE_COMMAND__Feature_Command_None, RPC_FEATURE_OPTION__Feature_Option_None }


/*
 * Configures the memory threshold for heap space monitoring for both internal and external ram
 *Set values to 0 to disable
 */
struct  RpcReqMemMonitor
{
  ProtobufCMessage base;
  /*
   * configure monitor
   */
  RpcMemMonitorConfig config;
  /*
   * report the memory used based on the set interval. When disabled, report only when heap memory falls below a set value
   */
  protobuf_c_boolean report_always;
  /*
   * interval between heap checks, periodic reports (if enabled)
   */
  uint32_t interval_sec;
  /*
   * minimum reporting threshold for internal memory
   */
  HeapSizeThreshold *internal;
  /*
   * minimum reporting threshold for external memory
   */
  HeapSizeThreshold *external;
};
#define RPC__REQ__MEM_MONITOR__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&rpc__req__mem_monitor__descriptor) \
    , RPC__MEM_MONITOR_CONFIG__MEMMONITOR_NO_CHANGE, 0, 0, NULL, NULL }


struct  RpcRespMemMonitor
{
  ProtobufCMessage base;
  int32_t resp;
  RpcMemMonitorConfig config;
  protobuf_c_boolean report_always;
  uint32_t interval_sec;
  /*
   * current total free heap size
   */
  uint32_t curr_total_heap_size;
  /*
   * current heap sizes for internal memory
   */
  HeapInfo *curr_internal;
  /*
   * current heap sizes for external memory
   */
  HeapInfo *curr_external;
};
#define RPC__RESP__MEM_MONITOR__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__mem_monitor__descriptor) \
    , 0, RPC__MEM_MONITOR_CONFIG__MEMMONITOR_NO_CHANGE, 0, 0, 0, NULL, NULL }


struct  RpcEventWifiEventNoArgs
{
  ProtobufCMessage base;
  int32_t resp;
  int32_t event_id;
};
#define RPC__EVENT__WIFI_EVENT_NO_ARGS__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&rpc__event__wifi_event_no_args__descriptor) \
    , 0, 0 }


struct  RpcEventESPInit
{
  ProtobufCMessage base;
  /*
   * reserved
   */
  ProtobufCBinaryData init_data;
  uint32_t cp_reset_reason;
};
#define RPC__EVENT__ESPINIT__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&rpc__event__espinit__descriptor) \
    , {0,NULL}, 0 }


struct  RpcEventHeartbeat
{
  ProtobufCMessage base;
  int32_t hb_num;
};
#define RPC__EVENT__HEARTBEAT__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&rpc__event__heartbeat__descriptor) \
    , 0 }


struct  RpcEventAPStaDisconnected
{
  ProtobufCMessage base;
  int32_t resp;
  ProtobufCBinaryData mac;
  uint32_t aid;
  protobuf_c_boolean is_mesh_child;
  uint32_t reason;
};
#define RPC__EVENT__AP__STA_DISCONNECTED__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&rpc__event__ap__sta_disconnected__descriptor) \
    , 0, {0,NULL}, 0, 0, 0 }


struct  RpcEventAPStaConnected
{
  ProtobufCMessage base;
  int32_t resp;
  ProtobufCBinaryData mac;
  uint32_t aid;
  protobuf_c_boolean is_mesh_child;
};
#define RPC__EVENT__AP__STA_CONNECTED__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&rpc__event__ap__sta_connected__descriptor) \
    , 0, {0,NULL}, 0, 0 }


struct  RpcEventStaScanDone
{
  ProtobufCMessage base;
  int32_t resp;
  WifiEventStaScanDone *scan_done;
};
#define RPC__EVENT__STA_SCAN_DONE__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&rpc__event__sta_scan_done__descriptor) \
    , 0, NULL }


struct  RpcEventStaConnected
{
  ProtobufCMessage base;
  int32_t resp;
  WifiEventStaConnected *sta_connected;
};
#define RPC__EVENT__STA_CONNECTED__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&rpc__event__sta_connected__descriptor) \
    , 0, NULL }


struct  RpcEventStaDisconnected
{
  ProtobufCMessage base;
  int32_t resp;
  WifiEventStaDisconnected *sta_disconnected;
};
#define RPC__EVENT__STA_DISCONNECTED__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&rpc__event__sta_disconnected__descriptor) \
    , 0, NULL }


struct  RpcGpioConfig
{
  ProtobufCMessage base;
  uint64_t pin_bit_mask;
  RpcGpioMode mode;
  protobuf_c_boolean pull_up_en;
  protobuf_c_boolean pull_down_en;
  int32_t intr_type;
};
#define RPC__GPIO_CONFIG__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&rpc__gpio_config__descriptor) \
    , 0, RPC__GPIO_MODE__GPIO_MODE_DISABLE, 0, 0, 0 }


struct  RpcReqGpioConfig
{
  ProtobufCMessage base;
  RpcGpioConfig *config;
};
#define RPC__REQ__GPIO_CONFIG__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&rpc__req__gpio_config__descriptor) \
    , NULL }


struct  RpcRespGpioConfig
{
  ProtobufCMessage base;
  int32_t resp;
};
#define RPC__RESP__GPIO_CONFIG__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__gpio_config__descriptor) \
    , 0 }


struct  RpcReqGpioResetPin
{
  ProtobufCMessage base;
  int32_t gpio_num;
};
#define RPC__REQ__GPIO_RESET_PIN__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&rpc__req__gpio_reset_pin__descriptor) \
    , 0 }


struct  RpcRespGpioResetPin
{
  ProtobufCMessage base;
  int32_t resp;
};
#define RPC__RESP__GPIO_RESET_PIN__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__gpio_reset_pin__descriptor) \
    , 0 }


struct  RpcReqGpioSetLevel
{
  ProtobufCMessage base;
  int32_t gpio_num;
  /*
   * 0 or 1
   */
  uint32_t level;
};
#define RPC__REQ__GPIO_SET_LEVEL__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&rpc__req__gpio_set_level__descriptor) \
    , 0, 0 }


struct  RpcRespGpioSetLevel
{
  ProtobufCMessage base;
  int32_t resp;
};
#define RPC__RESP__GPIO_SET_LEVEL__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__gpio_set_level__descriptor) \
    , 0 }


struct  RpcReqGpioGetLevel
{
  ProtobufCMessage base;
  int32_t gpio_num;
};
#define RPC__REQ__GPIO_GET_LEVEL__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&rpc__req__gpio_get_level__descriptor) \
    , 0 }


struct  RpcRespGpioGetLevel
{
  ProtobufCMessage base;
  int32_t resp;
  uint32_t level;
};
#define RPC__RESP__GPIO_GET_LEVEL__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__gpio_get_level__descriptor) \
    , 0, 0 }


struct  RpcReqGpioSetDirection
{
  ProtobufCMessage base;
  int32_t gpio_num;
  RpcGpioMode mode;
};
#define RPC__REQ__GPIO_SET_DIRECTION__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&rpc__req__gpio_set_direction__descriptor) \
    , 0, RPC__GPIO_MODE__GPIO_MODE_DISABLE }


struct  RpcRespGpioSetDirection
{
  ProtobufCMessage base;
  int32_t resp;
};
#define RPC__RESP__GPIO_SET_DIRECTION__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__gpio_set_direction__descriptor) \
    , 0 }


struct  RpcReqGpioInputEnable
{
  ProtobufCMessage base;
  int32_t gpio_num;
};
#define RPC__REQ__GPIO_INPUT_ENABLE__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&rpc__req__gpio_input_enable__descriptor) \
    , 0 }


struct  RpcRespGpioInputEnable
{
  ProtobufCMessage base;
  int32_t resp;
};
#define RPC__RESP__GPIO_INPUT_ENABLE__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__gpio_input_enable__descriptor) \
    , 0 }


struct  RpcReqGpioSetPullMode
{
  ProtobufCMessage base;
  int32_t gpio_num;
  RpcGpioPullMode pull;
};
#define RPC__REQ__GPIO_SET_PULL_MODE__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&rpc__req__gpio_set_pull_mode__descriptor) \
    , 0, RPC__GPIO_PULL_MODE__GPIO_PULL_NONE }


struct  RpcRespGpioSetPullMode
{
  ProtobufCMessage base;
  int32_t resp;
};
#define RPC__RESP__GPIO_SET_PULL_MODE__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__gpio_set_pull_mode__descriptor) \
    , 0 }


struct  RpcReqExtCoex
{
  ProtobufCMessage base;
  uint32_t cmd;
  uint32_t set_gpio_wire_type;
  int32_t set_gpio_request_pin;
  int32_t set_gpio_priority_pin;
  int32_t set_gpio_grant_pin;
  int32_t set_gpio_tx_line_pin;
  uint32_t set_work_mode;
  uint32_t set_grant_delay_us;
  protobuf_c_boolean set_validate_high;
};
#define RPC__REQ__EXT_COEX__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&rpc__req__ext_coex__descriptor) \
    , 0, 0, 0, 0, 0, 0, 0, 0, 0 }


struct  RpcRespExtCoex
{
  ProtobufCMessage base;
  int32_t resp;
};
#define RPC__RESP__EXT_COEX__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__ext_coex__descriptor) \
    , 0 }


struct  RpcEventDhcpDnsStatus
{
  ProtobufCMessage base;
  int32_t iface;
  int32_t net_link_up;
  int32_t dhcp_up;
  ProtobufCBinaryData dhcp_ip;
  ProtobufCBinaryData dhcp_nm;
  ProtobufCBinaryData dhcp_gw;
  int32_t dns_up;
  ProtobufCBinaryData dns_ip;
  int32_t dns_type;
  int32_t resp;
};
#define RPC__EVENT__DHCP_DNS_STATUS__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&rpc__event__dhcp_dns_status__descriptor) \
    , 0, 0, 0, {0,NULL}, {0,NULL}, {0,NULL}, 0, {0,NULL}, 0, 0 }


struct  RpcEventStaItwtSetup
{
  ProtobufCMessage base;
  int32_t resp;
  WifiItwtSetupConfig *config;
  int32_t status;
  uint32_t reason;
  uint64_t target_wake_time;
};
#define RPC__EVENT__STA_ITWT_SETUP__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&rpc__event__sta_itwt_setup__descriptor) \
    , 0, NULL, 0, 0, 0 }


struct  RpcEventStaItwtTeardown
{
  ProtobufCMessage base;
  int32_t resp;
  uint32_t flow_id;
  uint32_t status;
};
#define RPC__EVENT__STA_ITWT_TEARDOWN__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&rpc__event__sta_itwt_teardown__descriptor) \
    , 0, 0, 0 }


struct  RpcEventStaItwtSuspend
{
  ProtobufCMessage base;
  int32_t resp;
  int32_t status;
  uint32_t flow_id_bitmap;
  /*
   * represents uint32_t actual_suspend_time_ms[]
   */
  size_t n_actual_suspend_time_ms;
  uint32_t *actual_suspend_time_ms;
};
#define RPC__EVENT__STA_ITWT_SUSPEND__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&rpc__event__sta_itwt_suspend__descriptor) \
    , 0, 0, 0, 0,NULL }


struct  RpcEventStaItwtProbe
{
  ProtobufCMessage base;
  int32_t resp;
  int32_t status;
  uint32_t reason;
};
#define RPC__EVENT__STA_ITWT_PROBE__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&rpc__event__sta_itwt_probe__descriptor) \
    , 0, 0, 0 }


struct  RpcReqWifiStaEnterpriseEnable
{
  ProtobufCMessage base;
};
#define RPC__REQ__WIFI_STA_ENTERPRISE_ENABLE__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&rpc__req__wifi_sta_enterprise_enable__descriptor) \
     }


struct  RpcRespWifiStaEnterpriseEnable
{
  ProtobufCMessage base;
  int32_t resp;
};
#define RPC__RESP__WIFI_STA_ENTERPRISE_ENABLE__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__wifi_sta_enterprise_enable__descriptor) \
    , 0 }


struct  RpcReqWifiStaEnterpriseDisable
{
  ProtobufCMessage base;
};
#define RPC__REQ__WIFI_STA_ENTERPRISE_DISABLE__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&rpc__req__wifi_sta_enterprise_disable__descriptor) \
     }


struct  RpcRespWifiStaEnterpriseDisable
{
  ProtobufCMessage base;
  int32_t resp;
};
#define RPC__RESP__WIFI_STA_ENTERPRISE_DISABLE__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__wifi_sta_enterprise_disable__descriptor) \
    , 0 }


struct  RpcReqEapSetIdentity
{
  ProtobufCMessage base;
  ProtobufCBinaryData identity;
  int32_t len;
};
#define RPC__REQ__EAP_SET_IDENTITY__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&rpc__req__eap_set_identity__descriptor) \
    , {0,NULL}, 0 }


struct  RpcRespEapSetIdentity
{
  ProtobufCMessage base;
  int32_t resp;
};
#define RPC__RESP__EAP_SET_IDENTITY__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__eap_set_identity__descriptor) \
    , 0 }


struct  RpcReqEapClearIdentity
{
  ProtobufCMessage base;
};
#define RPC__REQ__EAP_CLEAR_IDENTITY__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&rpc__req__eap_clear_identity__descriptor) \
     }


struct  RpcRespEapClearIdentity
{
  ProtobufCMessage base;
  int32_t resp;
};
#define RPC__RESP__EAP_CLEAR_IDENTITY__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__eap_clear_identity__descriptor) \
    , 0 }


struct  RpcReqEapSetUsername
{
  ProtobufCMessage base;
  ProtobufCBinaryData username;
  int32_t len;
};
#define RPC__REQ__EAP_SET_USERNAME__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&rpc__req__eap_set_username__descriptor) \
    , {0,NULL}, 0 }


struct  RpcRespEapSetUsername
{
  ProtobufCMessage base;
  int32_t resp;
};
#define RPC__RESP__EAP_SET_USERNAME__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__eap_set_username__descriptor) \
    , 0 }


struct  RpcReqEapClearUsername
{
  ProtobufCMessage base;
};
#define RPC__REQ__EAP_CLEAR_USERNAME__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&rpc__req__eap_clear_username__descriptor) \
     }


struct  RpcRespEapClearUsername
{
  ProtobufCMessage base;
  int32_t resp;
};
#define RPC__RESP__EAP_CLEAR_USERNAME__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__eap_clear_username__descriptor) \
    , 0 }


struct  RpcReqEapSetPassword
{
  ProtobufCMessage base;
  ProtobufCBinaryData password;
  int32_t len;
};
#define RPC__REQ__EAP_SET_PASSWORD__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&rpc__req__eap_set_password__descriptor) \
    , {0,NULL}, 0 }


struct  RpcRespEapSetPassword
{
  ProtobufCMessage base;
  int32_t resp;
};
#define RPC__RESP__EAP_SET_PASSWORD__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__eap_set_password__descriptor) \
    , 0 }


struct  RpcReqEapClearPassword
{
  ProtobufCMessage base;
};
#define RPC__REQ__EAP_CLEAR_PASSWORD__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&rpc__req__eap_clear_password__descriptor) \
     }


struct  RpcRespEapClearPassword
{
  ProtobufCMessage base;
  int32_t resp;
};
#define RPC__RESP__EAP_CLEAR_PASSWORD__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__eap_clear_password__descriptor) \
    , 0 }


struct  RpcReqEapSetNewPassword
{
  ProtobufCMessage base;
  ProtobufCBinaryData new_password;
  int32_t len;
};
#define RPC__REQ__EAP_SET_NEW_PASSWORD__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&rpc__req__eap_set_new_password__descriptor) \
    , {0,NULL}, 0 }


struct  RpcRespEapSetNewPassword
{
  ProtobufCMessage base;
  int32_t resp;
};
#define RPC__RESP__EAP_SET_NEW_PASSWORD__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__eap_set_new_password__descriptor) \
    , 0 }


struct  RpcReqEapClearNewPassword
{
  ProtobufCMessage base;
};
#define RPC__REQ__EAP_CLEAR_NEW_PASSWORD__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&rpc__req__eap_clear_new_password__descriptor) \
     }


struct  RpcRespEapClearNewPassword
{
  ProtobufCMessage base;
  int32_t resp;
};
#define RPC__RESP__EAP_CLEAR_NEW_PASSWORD__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__eap_clear_new_password__descriptor) \
    , 0 }


struct  RpcReqEapSetCaCert
{
  ProtobufCMessage base;
  ProtobufCBinaryData ca_cert;
  int32_t ca_cert_len;
};
#define RPC__REQ__EAP_SET_CA_CERT__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&rpc__req__eap_set_ca_cert__descriptor) \
    , {0,NULL}, 0 }


struct  RpcRespEapSetCaCert
{
  ProtobufCMessage base;
  int32_t resp;
};
#define RPC__RESP__EAP_SET_CA_CERT__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__eap_set_ca_cert__descriptor) \
    , 0 }


struct  RpcReqEapClearCaCert
{
  ProtobufCMessage base;
};
#define RPC__REQ__EAP_CLEAR_CA_CERT__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&rpc__req__eap_clear_ca_cert__descriptor) \
     }


struct  RpcRespEapClearCaCert
{
  ProtobufCMessage base;
  int32_t resp;
};
#define RPC__RESP__EAP_CLEAR_CA_CERT__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__eap_clear_ca_cert__descriptor) \
    , 0 }


struct  RpcReqEapSetCertificateAndKey
{
  ProtobufCMessage base;
  ProtobufCBinaryData client_cert;
  int32_t client_cert_len;
  ProtobufCBinaryData private_key;
  int32_t private_key_len;
  ProtobufCBinaryData private_key_password;
  int32_t private_key_passwd_len;
};
#define RPC__REQ__EAP_SET_CERTIFICATE_AND_KEY__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&rpc__req__eap_set_certificate_and_key__descriptor) \
    , {0,NULL}, 0, {0,NULL}, 0, {0,NULL}, 0 }


struct  RpcRespEapSetCertificateAndKey
{
  ProtobufCMessage base;
  int32_t resp;
};
#define RPC__RESP__EAP_SET_CERTIFICATE_AND_KEY__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__eap_set_certificate_and_key__descriptor) \
    , 0 }


struct  RpcReqEapClearCertificateAndKey
{
  ProtobufCMessage base;
};
#define RPC__REQ__EAP_CLEAR_CERTIFICATE_AND_KEY__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&rpc__req__eap_clear_certificate_and_key__descriptor) \
     }


struct  RpcRespEapClearCertificateAndKey
{
  ProtobufCMessage base;
  int32_t resp;
};
#define RPC__RESP__EAP_CLEAR_CERTIFICATE_AND_KEY__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__eap_clear_certificate_and_key__descriptor) \
    , 0 }


struct  RpcReqEapSetDisableTimeCheck
{
  ProtobufCMessage base;
  protobuf_c_boolean disable;
};
#define RPC__REQ__EAP_SET_DISABLE_TIME_CHECK__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&rpc__req__eap_set_disable_time_check__descriptor) \
    , 0 }


struct  RpcRespEapSetDisableTimeCheck
{
  ProtobufCMessage base;
  int32_t resp;
};
#define RPC__RESP__EAP_SET_DISABLE_TIME_CHECK__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__eap_set_disable_time_check__descriptor) \
    , 0 }


struct  RpcReqEapGetDisableTimeCheck
{
  ProtobufCMessage base;
};
#define RPC__REQ__EAP_GET_DISABLE_TIME_CHECK__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&rpc__req__eap_get_disable_time_check__descriptor) \
     }


struct  RpcRespEapGetDisableTimeCheck
{
  ProtobufCMessage base;
  int32_t resp;
  protobuf_c_boolean disable;
};
#define RPC__RESP__EAP_GET_DISABLE_TIME_CHECK__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__eap_get_disable_time_check__descriptor) \
    , 0, 0 }


struct  RpcReqEapSetTtlsPhase2Method
{
  ProtobufCMessage base;
  int32_t type;
};
#define RPC__REQ__EAP_SET_TTLS_PHASE2_METHOD__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&rpc__req__eap_set_ttls_phase2_method__descriptor) \
    , 0 }


struct  RpcRespEapSetTtlsPhase2Method
{
  ProtobufCMessage base;
  int32_t resp;
};
#define RPC__RESP__EAP_SET_TTLS_PHASE2_METHOD__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__eap_set_ttls_phase2_method__descriptor) \
    , 0 }


struct  RpcReqEapSetSuiteb192bitCertification
{
  ProtobufCMessage base;
  protobuf_c_boolean enable;
};
#define RPC__REQ__EAP_SET_SUITEB192BIT_CERTIFICATION__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&rpc__req__eap_set_suiteb192bit_certification__descriptor) \
    , 0 }


struct  RpcRespEapSetSuiteb192bitCertification
{
  ProtobufCMessage base;
  int32_t resp;
};
#define RPC__RESP__EAP_SET_SUITEB192BIT_CERTIFICATION__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__eap_set_suiteb192bit_certification__descriptor) \
    , 0 }


struct  RpcReqEapSetPacFile
{
  ProtobufCMessage base;
  ProtobufCBinaryData pac_file;
  int32_t pac_file_len;
};
#define RPC__REQ__EAP_SET_PAC_FILE__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&rpc__req__eap_set_pac_file__descriptor) \
    , {0,NULL}, 0 }


struct  RpcRespEapSetPacFile
{
  ProtobufCMessage base;
  int32_t resp;
};
#define RPC__RESP__EAP_SET_PAC_FILE__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__eap_set_pac_file__descriptor) \
    , 0 }


struct  RpcReqEapSetFastParams
{
  ProtobufCMessage base;
  EapFastConfig *eap_fast_config;
};
#define RPC__REQ__EAP_SET_FAST_PARAMS__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&rpc__req__eap_set_fast_params__descriptor) \
    , NULL }


struct  RpcRespEapSetFastParams
{
  ProtobufCMessage base;
  int32_t resp;
};
#define RPC__RESP__EAP_SET_FAST_PARAMS__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__eap_set_fast_params__descriptor) \
    , 0 }


struct  RpcReqEapUseDefaultCertBundle
{
  ProtobufCMessage base;
  protobuf_c_boolean use_default_bundle;
};
#define RPC__REQ__EAP_USE_DEFAULT_CERT_BUNDLE__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&rpc__req__eap_use_default_cert_bundle__descriptor) \
    , 0 }


struct  RpcRespEapUseDefaultCertBundle
{
  ProtobufCMessage base;
  int32_t resp;
};
#define RPC__RESP__EAP_USE_DEFAULT_CERT_BUNDLE__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__eap_use_default_cert_bundle__descriptor) \
    , 0 }


struct  RpcReqWifiSetOkcSupport
{
  ProtobufCMessage base;
  protobuf_c_boolean enable;
};
#define RPC__REQ__WIFI_SET_OKC_SUPPORT__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&rpc__req__wifi_set_okc_support__descriptor) \
    , 0 }


struct  RpcRespWifiSetOkcSupport
{
  ProtobufCMessage base;
  int32_t resp;
};
#define RPC__RESP__WIFI_SET_OKC_SUPPORT__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__wifi_set_okc_support__descriptor) \
    , 0 }


struct  RpcReqEapSetDomainName
{
  ProtobufCMessage base;
  ProtobufCBinaryData domain_name;
};
#define RPC__REQ__EAP_SET_DOMAIN_NAME__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&rpc__req__eap_set_domain_name__descriptor) \
    , {0,NULL} }


struct  RpcRespEapSetDomainName
{
  ProtobufCMessage base;
  int32_t resp;
};
#define RPC__RESP__EAP_SET_DOMAIN_NAME__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__eap_set_domain_name__descriptor) \
    , 0 }


struct  RpcReqEapSetEapMethods
{
  ProtobufCMessage base;
  int32_t methods;
};
#define RPC__REQ__EAP_SET_EAP_METHODS__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&rpc__req__eap_set_eap_methods__descriptor) \
    , 0 }


struct  RpcRespEapSetEapMethods
{
  ProtobufCMessage base;
  int32_t resp;
};
#define RPC__RESP__EAP_SET_EAP_METHODS__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__eap_set_eap_methods__descriptor) \
    , 0 }


struct  RpcEventSuppDppUriReady
{
  ProtobufCMessage base;
  int32_t resp;
  /*
   * QR Code to configure the enrollee
   */
  ProtobufCBinaryData qrcode;
};
#define RPC__EVENT__SUPP_DPP_URI_READY__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&rpc__event__supp_dpp_uri_ready__descriptor) \
    , 0, {0,NULL} }


struct  RpcEventSuppDppCfgRecvd
{
  ProtobufCMessage base;
  int32_t resp;
  WifiConfig *cfg;
};
#define RPC__EVENT__SUPP_DPP_CFG_RECVD__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&rpc__event__supp_dpp_cfg_recvd__descriptor) \
    , 0, NULL }


struct  RpcEventSuppDppFail
{
  ProtobufCMessage base;
  int32_t resp;
  /*
   * failure reason
   */
  int32_t reason;
};
#define RPC__EVENT__SUPP_DPP_FAIL__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&rpc__event__supp_dpp_fail__descriptor) \
    , 0, 0 }


struct  RpcEventWifiDppUriReady
{
  ProtobufCMessage base;
  int32_t resp;
  /*
   * QR Code to configure the enrollee
   */
  ProtobufCBinaryData qrcode;
};
#define RPC__EVENT__WIFI_DPP_URI_READY__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&rpc__event__wifi_dpp_uri_ready__descriptor) \
    , 0, {0,NULL} }


struct  RpcEventWifiDppCfgRecvd
{
  ProtobufCMessage base;
  int32_t resp;
  WifiConfig *cfg;
};
#define RPC__EVENT__WIFI_DPP_CFG_RECVD__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&rpc__event__wifi_dpp_cfg_recvd__descriptor) \
    , 0, NULL }


struct  RpcEventWifiDppFail
{
  ProtobufCMessage base;
  int32_t resp;
  /*
   * failure reason
   */
  int32_t reason;
};
#define RPC__EVENT__WIFI_DPP_FAIL__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&rpc__event__wifi_dpp_fail__descriptor) \
    , 0, 0 }


/*
 * Custom RPC messages for user-defined packed structures 
 */
struct  RpcReqCustomRpc
{
  ProtobufCMessage base;
  /*
   * User-defined message ID 
   */
  uint32_t custom_msg_id;
  /*
   * Raw packed data 
   */
  ProtobufCBinaryData data;
};
#define RPC__REQ__CUSTOM_RPC__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&rpc__req__custom_rpc__descriptor) \
    , 0, {0,NULL} }


struct  RpcRespCustomRpc
{
  ProtobufCMessage base;
  /*
   * Response status 
   */
  int32_t resp;
  /*
   * User-defined message ID (echoed from request) 
   */
  uint32_t custom_msg_id;
  /*
   * Raw packed response data 
   */
  ProtobufCBinaryData data;
};
#define RPC__RESP__CUSTOM_RPC__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&rpc__resp__custom_rpc__descriptor) \
    , 0, 0, {0,NULL} }


struct  RpcEventCustomRpc
{
  ProtobufCMessage base;
  /*
   * Event status 
   */
  int32_t resp;
  /*
   * User-defined event ID 
   */
  uint32_t custom_event_id;
  /*
   * Raw packed event data 
   */
  ProtobufCBinaryData data;
};
#define RPC__EVENT__CUSTOM_RPC__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&rpc__event__custom_rpc__descriptor) \
    , 0, 0, {0,NULL} }


/*
 * Sent when heap size is below a set low level marks 
 */
struct  RpcEventMemMonitor
{
  ProtobufCMessage base;
  int32_t resp;
  /*
   * current total heap size
   */
  uint32_t curr_total_free_heap_size;
  /*
   * current minimum heap size
   */
  uint32_t curr_min_free_heap_size;
  /*
   * current heap levels for internal memory
   */
  HeapInfo *curr_internal;
  /*
   * current heap levels for external memory
   */
  HeapInfo *curr_external;
};
#define RPC__EVENT__MEM_MONITOR__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&rpc__event__mem_monitor__descriptor) \
    , 0, 0, 0, NULL, NULL }


typedef enum {
  RPC__PAYLOAD__NOT_SET = 0,
  RPC__PAYLOAD_REQ_GET_MAC_ADDRESS = 257,
  RPC__PAYLOAD_REQ_SET_MAC_ADDRESS = 258,
  RPC__PAYLOAD_REQ_GET_WIFI_MODE = 259,
  RPC__PAYLOAD_REQ_SET_WIFI_MODE = 260,
  RPC__PAYLOAD_REQ_SUPP_DPP_INIT = 261,
  RPC__PAYLOAD_REQ_SUPP_DPP_DEINIT = 262,
  RPC__PAYLOAD_REQ_SUPP_DPP_BOOTSTRAP_GEN = 263,
  RPC__PAYLOAD_REQ_SUPP_DPP_START_LISTEN = 264,
  RPC__PAYLOAD_REQ_SUPP_DPP_STOP_LISTEN = 265,
  RPC__PAYLOAD_REQ_OTA_ACTIVATE = 266,
  RPC__PAYLOAD_REQ_APP_GET_DESC = 267,
  RPC__PAYLOAD_REQ_MEM_MONITOR = 268,
  RPC__PAYLOAD_REQ_WIFI_SCAN_PARAMS = 269,
  RPC__PAYLOAD_REQ_WIFI_SET_PS = 270,
  RPC__PAYLOAD_REQ_WIFI_GET_PS = 271,
  RPC__PAYLOAD_REQ_OTA_BEGIN = 272,
  RPC__PAYLOAD_REQ_OTA_WRITE = 273,
  RPC__PAYLOAD_REQ_OTA_END = 274,
  RPC__PAYLOAD_REQ_SET_WIFI_MAX_TX_POWER = 275,
  RPC__PAYLOAD_REQ_GET_WIFI_MAX_TX_POWER = 276,
  RPC__PAYLOAD_REQ_CONFIG_HEARTBEAT = 277,
  RPC__PAYLOAD_REQ_WIFI_INIT = 278,
  RPC__PAYLOAD_REQ_WIFI_DEINIT = 279,
  RPC__PAYLOAD_REQ_WIFI_START = 280,
  RPC__PAYLOAD_REQ_WIFI_STOP = 281,
  RPC__PAYLOAD_REQ_WIFI_CONNECT = 282,
  RPC__PAYLOAD_REQ_WIFI_DISCONNECT = 283,
  RPC__PAYLOAD_REQ_WIFI_SET_CONFIG = 284,
  RPC__PAYLOAD_REQ_WIFI_GET_CONFIG = 285,
  RPC__PAYLOAD_REQ_WIFI_SCAN_START = 286,
  RPC__PAYLOAD_REQ_WIFI_SCAN_STOP = 287,
  RPC__PAYLOAD_REQ_WIFI_SCAN_GET_AP_NUM = 288,
  RPC__PAYLOAD_REQ_WIFI_SCAN_GET_AP_RECORDS = 289,
  RPC__PAYLOAD_REQ_WIFI_CLEAR_AP_LIST = 290,
  RPC__PAYLOAD_REQ_WIFI_RESTORE = 291,
  RPC__PAYLOAD_REQ_WIFI_CLEAR_FAST_CONNECT = 292,
  RPC__PAYLOAD_REQ_WIFI_DEAUTH_STA = 293,
  RPC__PAYLOAD_REQ_WIFI_STA_GET_AP_INFO = 294,
  RPC__PAYLOAD_REQ_WIFI_SET_PROTOCOL = 297,
  RPC__PAYLOAD_REQ_WIFI_GET_PROTOCOL = 298,
  RPC__PAYLOAD_REQ_WIFI_SET_BANDWIDTH = 299,
  RPC__PAYLOAD_REQ_WIFI_GET_BANDWIDTH = 300,
  RPC__PAYLOAD_REQ_WIFI_SET_CHANNEL = 301,
  RPC__PAYLOAD_REQ_WIFI_GET_CHANNEL = 302,
  RPC__PAYLOAD_REQ_WIFI_SET_COUNTRY = 303,
  RPC__PAYLOAD_REQ_WIFI_GET_COUNTRY = 304,
  RPC__PAYLOAD_REQ_WIFI_AP_GET_STA_LIST = 311,
  RPC__PAYLOAD_REQ_WIFI_AP_GET_STA_AID = 312,
  RPC__PAYLOAD_REQ_WIFI_SET_STORAGE = 313,
  RPC__PAYLOAD_REQ_WIFI_SET_INACTIVE_TIME = 325,
  RPC__PAYLOAD_REQ_WIFI_GET_INACTIVE_TIME = 326,
  RPC__PAYLOAD_REQ_WIFI_SET_COUNTRY_CODE = 334,
  RPC__PAYLOAD_REQ_WIFI_GET_COUNTRY_CODE = 335,
  RPC__PAYLOAD_REQ_WIFI_DISABLE_PMF_CONFIG = 337,
  RPC__PAYLOAD_REQ_WIFI_STA_GET_AID = 338,
  RPC__PAYLOAD_REQ_WIFI_STA_GET_NEGOTIATED_PHYMODE = 339,
  RPC__PAYLOAD_REQ_WIFI_STA_GET_RSSI = 341,
  RPC__PAYLOAD_REQ_WIFI_SET_PROTOCOLS = 342,
  RPC__PAYLOAD_REQ_WIFI_GET_PROTOCOLS = 343,
  RPC__PAYLOAD_REQ_WIFI_SET_BANDWIDTHS = 344,
  RPC__PAYLOAD_REQ_WIFI_GET_BANDWIDTHS = 345,
  RPC__PAYLOAD_REQ_WIFI_SET_BAND = 346,
  RPC__PAYLOAD_REQ_WIFI_GET_BAND = 347,
  RPC__PAYLOAD_REQ_WIFI_SET_BANDMODE = 348,
  RPC__PAYLOAD_REQ_WIFI_GET_BANDMODE = 349,
  RPC__PAYLOAD_REQ_GET_COPROCESSOR_FWVERSION = 350,
  RPC__PAYLOAD_REQ_WIFI_SCAN_GET_AP_RECORD = 351,
  RPC__PAYLOAD_REQ_SET_DHCP_DNS = 352,
  RPC__PAYLOAD_REQ_GET_DHCP_DNS = 353,
  RPC__PAYLOAD_REQ_WIFI_STA_TWT_CONFIG = 354,
  RPC__PAYLOAD_REQ_WIFI_STA_ITWT_SETUP = 355,
  RPC__PAYLOAD_REQ_WIFI_STA_ITWT_TEARDOWN = 356,
  RPC__PAYLOAD_REQ_WIFI_STA_ITWT_SUSPEND = 357,
  RPC__PAYLOAD_REQ_WIFI_STA_ITWT_GET_FLOW_ID_STATUS = 358,
  RPC__PAYLOAD_REQ_WIFI_STA_ITWT_SEND_PROBE_REQ = 359,
  RPC__PAYLOAD_REQ_WIFI_STA_ITWT_SET_TARGET_WAKE_TIME_OFFSET = 360,
  RPC__PAYLOAD_REQ_WIFI_STA_ENTERPRISE_ENABLE = 361,
  RPC__PAYLOAD_REQ_WIFI_STA_ENTERPRISE_DISABLE = 362,
  RPC__PAYLOAD_REQ_EAP_SET_IDENTITY = 363,
  RPC__PAYLOAD_REQ_EAP_CLEAR_IDENTITY = 364,
  RPC__PAYLOAD_REQ_EAP_SET_USERNAME = 365,
  RPC__PAYLOAD_REQ_EAP_CLEAR_USERNAME = 366,
  RPC__PAYLOAD_REQ_EAP_SET_PASSWORD = 367,
  RPC__PAYLOAD_REQ_EAP_CLEAR_PASSWORD = 368,
  RPC__PAYLOAD_REQ_EAP_SET_NEW_PASSWORD = 369,
  RPC__PAYLOAD_REQ_EAP_CLEAR_NEW_PASSWORD = 370,
  RPC__PAYLOAD_REQ_EAP_SET_CA_CERT = 371,
  RPC__PAYLOAD_REQ_EAP_CLEAR_CA_CERT = 372,
  RPC__PAYLOAD_REQ_EAP_SET_CERTIFICATE_AND_KEY = 373,
  RPC__PAYLOAD_REQ_EAP_CLEAR_CERTIFICATE_AND_KEY = 374,
  RPC__PAYLOAD_REQ_EAP_GET_DISABLE_TIME_CHECK = 375,
  RPC__PAYLOAD_REQ_EAP_SET_TTLS_PHASE2_METHOD = 376,
  RPC__PAYLOAD_REQ_EAP_SET_SUITEB_CERTIFICATION = 377,
  RPC__PAYLOAD_REQ_EAP_SET_PAC_FILE = 378,
  RPC__PAYLOAD_REQ_EAP_SET_FAST_PARAMS = 379,
  RPC__PAYLOAD_REQ_EAP_USE_DEFAULT_CERT_BUNDLE = 380,
  RPC__PAYLOAD_REQ_WIFI_SET_OKC_SUPPORT = 381,
  RPC__PAYLOAD_REQ_EAP_SET_DOMAIN_NAME = 382,
  RPC__PAYLOAD_REQ_EAP_SET_DISABLE_TIME_CHECK = 383,
  RPC__PAYLOAD_REQ_EAP_SET_EAP_METHODS = 384,
  RPC__PAYLOAD_REQ_IFACE_MAC_ADDR_SET_GET = 385,
  RPC__PAYLOAD_REQ_IFACE_MAC_ADDR_LEN_GET = 386,
  RPC__PAYLOAD_REQ_FEATURE_CONTROL = 387,
  RPC__PAYLOAD_REQ_CUSTOM_RPC = 388,
  RPC__PAYLOAD_REQ_GPIO_CONFIG = 389,
  RPC__PAYLOAD_REQ_GPIO_RESET_PIN = 390,
  RPC__PAYLOAD_REQ_GPIO_SET_LEVEL = 391,
  RPC__PAYLOAD_REQ_GPIO_GET_LEVEL = 392,
  RPC__PAYLOAD_REQ_GPIO_SET_DIRECTION = 393,
  RPC__PAYLOAD_REQ_GPIO_INPUT_ENABLE = 394,
  RPC__PAYLOAD_REQ_GPIO_SET_PULL_MODE = 395,
  RPC__PAYLOAD_REQ_EXT_COEX = 396,
  RPC__PAYLOAD_RESP_GET_MAC_ADDRESS = 513,
  RPC__PAYLOAD_RESP_SET_MAC_ADDRESS = 514,
  RPC__PAYLOAD_RESP_GET_WIFI_MODE = 515,
  RPC__PAYLOAD_RESP_SET_WIFI_MODE = 516,
  RPC__PAYLOAD_RESP_SUPP_DPP_INIT = 517,
  RPC__PAYLOAD_RESP_SUPP_DPP_DEINIT = 518,
  RPC__PAYLOAD_RESP_SUPP_DPP_BOOTSTRAP_GEN = 519,
  RPC__PAYLOAD_RESP_SUPP_DPP_START_LISTEN = 520,
  RPC__PAYLOAD_RESP_SUPP_DPP_STOP_LISTEN = 521,
  RPC__PAYLOAD_RESP_OTA_ACTIVATE = 522,
  RPC__PAYLOAD_RESP_APP_GET_DESC = 523,
  RPC__PAYLOAD_RESP_MEM_MONITOR = 524,
  RPC__PAYLOAD_RESP_WIFI_SCAN_PARAMS = 525,
  RPC__PAYLOAD_RESP_WIFI_SET_PS = 526,
  RPC__PAYLOAD_RESP_WIFI_GET_PS = 527,
  RPC__PAYLOAD_RESP_OTA_BEGIN = 528,
  RPC__PAYLOAD_RESP_OTA_WRITE = 529,
  RPC__PAYLOAD_RESP_OTA_END = 530,
  RPC__PAYLOAD_RESP_SET_WIFI_MAX_TX_POWER = 531,
  RPC__PAYLOAD_RESP_GET_WIFI_MAX_TX_POWER = 532,
  RPC__PAYLOAD_RESP_CONFIG_HEARTBEAT = 533,
  RPC__PAYLOAD_RESP_WIFI_INIT = 534,
  RPC__PAYLOAD_RESP_WIFI_DEINIT = 535,
  RPC__PAYLOAD_RESP_WIFI_START = 536,
  RPC__PAYLOAD_RESP_WIFI_STOP = 537,
  RPC__PAYLOAD_RESP_WIFI_CONNECT = 538,
  RPC__PAYLOAD_RESP_WIFI_DISCONNECT = 539,
  RPC__PAYLOAD_RESP_WIFI_SET_CONFIG = 540,
  RPC__PAYLOAD_RESP_WIFI_GET_CONFIG = 541,
  RPC__PAYLOAD_RESP_WIFI_SCAN_START = 542,
  RPC__PAYLOAD_RESP_WIFI_SCAN_STOP = 543,
  RPC__PAYLOAD_RESP_WIFI_SCAN_GET_AP_NUM = 544,
  RPC__PAYLOAD_RESP_WIFI_SCAN_GET_AP_RECORDS = 545,
  RPC__PAYLOAD_RESP_WIFI_CLEAR_AP_LIST = 546,
  RPC__PAYLOAD_RESP_WIFI_RESTORE = 547,
  RPC__PAYLOAD_RESP_WIFI_CLEAR_FAST_CONNECT = 548,
  RPC__PAYLOAD_RESP_WIFI_DEAUTH_STA = 549,
  RPC__PAYLOAD_RESP_WIFI_STA_GET_AP_INFO = 550,
  RPC__PAYLOAD_RESP_WIFI_SET_PROTOCOL = 553,
  RPC__PAYLOAD_RESP_WIFI_GET_PROTOCOL = 554,
  RPC__PAYLOAD_RESP_WIFI_SET_BANDWIDTH = 555,
  RPC__PAYLOAD_RESP_WIFI_GET_BANDWIDTH = 556,
  RPC__PAYLOAD_RESP_WIFI_SET_CHANNEL = 557,
  RPC__PAYLOAD_RESP_WIFI_GET_CHANNEL = 558,
  RPC__PAYLOAD_RESP_WIFI_SET_COUNTRY = 559,
  RPC__PAYLOAD_RESP_WIFI_GET_COUNTRY = 560,
  RPC__PAYLOAD_RESP_WIFI_AP_GET_STA_LIST = 567,
  RPC__PAYLOAD_RESP_WIFI_AP_GET_STA_AID = 568,
  RPC__PAYLOAD_RESP_WIFI_SET_STORAGE = 569,
  RPC__PAYLOAD_RESP_WIFI_SET_INACTIVE_TIME = 581,
  RPC__PAYLOAD_RESP_WIFI_GET_INACTIVE_TIME = 582,
  RPC__PAYLOAD_RESP_WIFI_SET_COUNTRY_CODE = 590,
  RPC__PAYLOAD_RESP_WIFI_GET_COUNTRY_CODE = 591,
  RPC__PAYLOAD_RESP_WIFI_DISABLE_PMF_CONFIG = 593,
  RPC__PAYLOAD_RESP_WIFI_STA_GET_AID = 594,
  RPC__PAYLOAD_RESP_WIFI_STA_GET_NEGOTIATED_PHYMODE = 595,
  RPC__PAYLOAD_RESP_WIFI_STA_GET_RSSI = 597,
  RPC__PAYLOAD_RESP_WIFI_SET_PROTOCOLS = 598,
  RPC__PAYLOAD_RESP_WIFI_GET_PROTOCOLS = 599,
  RPC__PAYLOAD_RESP_WIFI_SET_BANDWIDTHS = 600,
  RPC__PAYLOAD_RESP_WIFI_GET_BANDWIDTHS = 601,
  RPC__PAYLOAD_RESP_WIFI_SET_BAND = 602,
  RPC__PAYLOAD_RESP_WIFI_GET_BAND = 603,
  RPC__PAYLOAD_RESP_WIFI_SET_BANDMODE = 604,
  RPC__PAYLOAD_RESP_WIFI_GET_BANDMODE = 605,
  RPC__PAYLOAD_RESP_GET_COPROCESSOR_FWVERSION = 606,
  RPC__PAYLOAD_RESP_WIFI_SCAN_GET_AP_RECORD = 607,
  RPC__PAYLOAD_RESP_SET_DHCP_DNS = 608,
  RPC__PAYLOAD_RESP_GET_DHCP_DNS = 609,
  RPC__PAYLOAD_RESP_WIFI_STA_TWT_CONFIG = 610,
  RPC__PAYLOAD_RESP_WIFI_STA_ITWT_SETUP = 611,
  RPC__PAYLOAD_RESP_WIFI_STA_ITWT_TEARDOWN = 612,
  RPC__PAYLOAD_RESP_WIFI_STA_ITWT_SUSPEND = 613,
  RPC__PAYLOAD_RESP_WIFI_STA_ITWT_GET_FLOW_ID_STATUS = 614,
  RPC__PAYLOAD_RESP_WIFI_STA_ITWT_SEND_PROBE_REQ = 615,
  RPC__PAYLOAD_RESP_WIFI_STA_ITWT_SET_TARGET_WAKE_TIME_OFFSET = 616,
  RPC__PAYLOAD_RESP_WIFI_STA_ENTERPRISE_ENABLE = 617,
  RPC__PAYLOAD_RESP_WIFI_STA_ENTERPRISE_DISABLE = 618,
  RPC__PAYLOAD_RESP_EAP_SET_IDENTITY = 619,
  RPC__PAYLOAD_RESP_EAP_CLEAR_IDENTITY = 620,
  RPC__PAYLOAD_RESP_EAP_SET_USERNAME = 621,
  RPC__PAYLOAD_RESP_EAP_CLEAR_USERNAME = 622,
  RPC__PAYLOAD_RESP_EAP_SET_PASSWORD = 623,
  RPC__PAYLOAD_RESP_EAP_CLEAR_PASSWORD = 624,
  RPC__PAYLOAD_RESP_EAP_SET_NEW_PASSWORD = 625,
  RPC__PAYLOAD_RESP_EAP_CLEAR_NEW_PASSWORD = 626,
  RPC__PAYLOAD_RESP_EAP_SET_CA_CERT = 627,
  RPC__PAYLOAD_RESP_EAP_CLEAR_CA_CERT = 628,
  RPC__PAYLOAD_RESP_EAP_SET_CERTIFICATE_AND_KEY = 629,
  RPC__PAYLOAD_RESP_EAP_CLEAR_CERTIFICATE_AND_KEY = 630,
  RPC__PAYLOAD_RESP_EAP_GET_DISABLE_TIME_CHECK = 631,
  RPC__PAYLOAD_RESP_EAP_SET_TTLS_PHASE2_METHOD = 632,
  RPC__PAYLOAD_RESP_EAP_SET_SUITEB_CERTIFICATION = 633,
  RPC__PAYLOAD_RESP_EAP_SET_PAC_FILE = 634,
  RPC__PAYLOAD_RESP_EAP_SET_FAST_PARAMS = 635,
  RPC__PAYLOAD_RESP_EAP_USE_DEFAULT_CERT_BUNDLE = 636,
  RPC__PAYLOAD_RESP_WIFI_SET_OKC_SUPPORT = 637,
  RPC__PAYLOAD_RESP_EAP_SET_DOMAIN_NAME = 638,
  RPC__PAYLOAD_RESP_EAP_SET_DISABLE_TIME_CHECK = 639,
  RPC__PAYLOAD_RESP_EAP_SET_EAP_METHODS = 640,
  RPC__PAYLOAD_RESP_IFACE_MAC_ADDR_SET_GET = 641,
  RPC__PAYLOAD_RESP_IFACE_MAC_ADDR_LEN_GET = 642,
  RPC__PAYLOAD_RESP_FEATURE_CONTROL = 643,
  RPC__PAYLOAD_RESP_CUSTOM_RPC = 644,
  RPC__PAYLOAD_RESP_GPIO_CONFIG = 645,
  RPC__PAYLOAD_RESP_GPIO_RESET = 646,
  RPC__PAYLOAD_RESP_GPIO_SET_LEVEL = 647,
  RPC__PAYLOAD_RESP_GPIO_GET_LEVEL = 648,
  RPC__PAYLOAD_RESP_GPIO_SET_DIRECTION = 649,
  RPC__PAYLOAD_RESP_GPIO_INPUT_ENABLE = 650,
  RPC__PAYLOAD_RESP_GPIO_SET_PULL_MODE = 651,
  RPC__PAYLOAD_RESP_EXT_COEX = 652,
  RPC__PAYLOAD_EVENT_ESP_INIT = 769,
  RPC__PAYLOAD_EVENT_HEARTBEAT = 770,
  RPC__PAYLOAD_EVENT_AP_STA_CONNECTED = 771,
  RPC__PAYLOAD_EVENT_AP_STA_DISCONNECTED = 772,
  RPC__PAYLOAD_EVENT_WIFI_EVENT_NO_ARGS = 773,
  RPC__PAYLOAD_EVENT_STA_SCAN_DONE = 774,
  RPC__PAYLOAD_EVENT_STA_CONNECTED = 775,
  RPC__PAYLOAD_EVENT_STA_DISCONNECTED = 776,
  RPC__PAYLOAD_EVENT_DHCP_DNS = 777,
  RPC__PAYLOAD_EVENT_STA_ITWT_SETUP = 778,
  RPC__PAYLOAD_EVENT_STA_ITWT_TEARDOWN = 779,
  RPC__PAYLOAD_EVENT_STA_ITWT_SUSPEND = 780,
  RPC__PAYLOAD_EVENT_STA_ITWT_PROBE = 781,
  RPC__PAYLOAD_EVENT_SUPP_DPP_URI_READY = 782,
  RPC__PAYLOAD_EVENT_SUPP_DPP_CFG_RECVD = 783,
  RPC__PAYLOAD_EVENT_SUPP_DPP_FAIL = 784,
  RPC__PAYLOAD_EVENT_WIFI_DPP_URI_READY = 785,
  RPC__PAYLOAD_EVENT_WIFI_DPP_CFG_RECVD = 786,
  RPC__PAYLOAD_EVENT_WIFI_DPP_FAIL = 787,
  RPC__PAYLOAD_EVENT_CUSTOM_RPC = 788,
  RPC__PAYLOAD_EVENT_MEM_MONITOR = 789
    PROTOBUF_C__FORCE_ENUM_TO_BE_INT_SIZE(RPC__PAYLOAD__CASE)
} Rpc__PayloadCase;

struct  Rpc
{
  ProtobufCMessage base;
  /*
   * msg_type could be req, resp or Event 
   */
  RpcType msg_type;
  /*
   * msg id 
   */
  RpcId msg_id;
  /*
   * UID of message 
   */
  uint32_t uid;
  Rpc__PayloadCase payload_case;
  union {
    /*
     ** Requests *
     */
    RpcReqGetMacAddress *req_get_mac_address;
    RpcReqSetMacAddress *req_set_mac_address;
    RpcReqGetMode *req_get_wifi_mode;
    RpcReqSetMode *req_set_wifi_mode;
    RpcReqSuppDppInit *req_supp_dpp_init;
    RpcReqSuppDppDeinit *req_supp_dpp_deinit;
    RpcReqSuppDppBootstrapGen *req_supp_dpp_bootstrap_gen;
    RpcReqSuppDppStartListen *req_supp_dpp_start_listen;
    RpcReqSuppDppStopListen *req_supp_dpp_stop_listen;
    RpcReqOTAActivate *req_ota_activate;
    RpcReqAppGetDesc *req_app_get_desc;
    RpcReqMemMonitor *req_mem_monitor;
    RpcReqWifiScanParams *req_wifi_scan_params;
    RpcReqSetPs *req_wifi_set_ps;
    RpcReqGetPs *req_wifi_get_ps;
    RpcReqOTABegin *req_ota_begin;
    RpcReqOTAWrite *req_ota_write;
    RpcReqOTAEnd *req_ota_end;
    RpcReqWifiSetMaxTxPower *req_set_wifi_max_tx_power;
    RpcReqWifiGetMaxTxPower *req_get_wifi_max_tx_power;
    RpcReqConfigHeartbeat *req_config_heartbeat;
    RpcReqWifiInit *req_wifi_init;
    RpcReqWifiDeinit *req_wifi_deinit;
    RpcReqWifiStart *req_wifi_start;
    RpcReqWifiStop *req_wifi_stop;
    RpcReqWifiConnect *req_wifi_connect;
    RpcReqWifiDisconnect *req_wifi_disconnect;
    RpcReqWifiSetConfig *req_wifi_set_config;
    RpcReqWifiGetConfig *req_wifi_get_config;
    RpcReqWifiScanStart *req_wifi_scan_start;
    RpcReqWifiScanStop *req_wifi_scan_stop;
    RpcReqWifiScanGetApNum *req_wifi_scan_get_ap_num;
    RpcReqWifiScanGetApRecords *req_wifi_scan_get_ap_records;
    RpcReqWifiClearApList *req_wifi_clear_ap_list;
    RpcReqWifiRestore *req_wifi_restore;
    RpcReqWifiClearFastConnect *req_wifi_clear_fast_connect;
    RpcReqWifiDeauthSta *req_wifi_deauth_sta;
    RpcReqWifiStaGetApInfo *req_wifi_sta_get_ap_info;
    RpcReqWifiSetProtocol *req_wifi_set_protocol;
    RpcReqWifiGetProtocol *req_wifi_get_protocol;
    RpcReqWifiSetBandwidth *req_wifi_set_bandwidth;
    RpcReqWifiGetBandwidth *req_wifi_get_bandwidth;
    RpcReqWifiSetChannel *req_wifi_set_channel;
    RpcReqWifiGetChannel *req_wifi_get_channel;
    RpcReqWifiSetCountry *req_wifi_set_country;
    RpcReqWifiGetCountry *req_wifi_get_country;
    RpcReqWifiApGetStaList *req_wifi_ap_get_sta_list;
    RpcReqWifiApGetStaAid *req_wifi_ap_get_sta_aid;
    RpcReqWifiSetStorage *req_wifi_set_storage;
    RpcReqWifiSetInactiveTime *req_wifi_set_inactive_time;
    RpcReqWifiGetInactiveTime *req_wifi_get_inactive_time;
    RpcReqWifiSetCountryCode *req_wifi_set_country_code;
    RpcReqWifiGetCountryCode *req_wifi_get_country_code;
    RpcReqWifiDisablePmfConfig *req_wifi_disable_pmf_config;
    RpcReqWifiStaGetAid *req_wifi_sta_get_aid;
    RpcReqWifiStaGetNegotiatedPhymode *req_wifi_sta_get_negotiated_phymode;
    RpcReqWifiStaGetRssi *req_wifi_sta_get_rssi;
    RpcReqWifiSetProtocols *req_wifi_set_protocols;
    RpcReqWifiGetProtocols *req_wifi_get_protocols;
    RpcReqWifiSetBandwidths *req_wifi_set_bandwidths;
    RpcReqWifiGetBandwidths *req_wifi_get_bandwidths;
    RpcReqWifiSetBand *req_wifi_set_band;
    RpcReqWifiGetBand *req_wifi_get_band;
    RpcReqWifiSetBandMode *req_wifi_set_bandmode;
    RpcReqWifiGetBandMode *req_wifi_get_bandmode;
    RpcReqGetCoprocessorFwVersion *req_get_coprocessor_fwversion;
    RpcReqWifiScanGetApRecord *req_wifi_scan_get_ap_record;
    RpcReqSetDhcpDnsStatus *req_set_dhcp_dns;
    RpcReqGetDhcpDnsStatus *req_get_dhcp_dns;
    RpcReqWifiStaTwtConfig *req_wifi_sta_twt_config;
    RpcReqWifiStaItwtSetup *req_wifi_sta_itwt_setup;
    RpcReqWifiStaItwtTeardown *req_wifi_sta_itwt_teardown;
    RpcReqWifiStaItwtSuspend *req_wifi_sta_itwt_suspend;
    RpcReqWifiStaItwtGetFlowIdStatus *req_wifi_sta_itwt_get_flow_id_status;
    RpcReqWifiStaItwtSendProbeReq *req_wifi_sta_itwt_send_probe_req;
    RpcReqWifiStaItwtSetTargetWakeTimeOffset *req_wifi_sta_itwt_set_target_wake_time_offset;
    RpcReqWifiStaEnterpriseEnable *req_wifi_sta_enterprise_enable;
    RpcReqWifiStaEnterpriseDisable *req_wifi_sta_enterprise_disable;
    RpcReqEapSetIdentity *req_eap_set_identity;
    RpcReqEapClearIdentity *req_eap_clear_identity;
    RpcReqEapSetUsername *req_eap_set_username;
    RpcReqEapClearUsername *req_eap_clear_username;
    RpcReqEapSetPassword *req_eap_set_password;
    RpcReqEapClearPassword *req_eap_clear_password;
    RpcReqEapSetNewPassword *req_eap_set_new_password;
    RpcReqEapClearNewPassword *req_eap_clear_new_password;
    RpcReqEapSetCaCert *req_eap_set_ca_cert;
    RpcReqEapClearCaCert *req_eap_clear_ca_cert;
    RpcReqEapSetCertificateAndKey *req_eap_set_certificate_and_key;
    RpcReqEapClearCertificateAndKey *req_eap_clear_certificate_and_key;
    RpcReqEapGetDisableTimeCheck *req_eap_get_disable_time_check;
    RpcReqEapSetTtlsPhase2Method *req_eap_set_ttls_phase2_method;
    RpcReqEapSetSuiteb192bitCertification *req_eap_set_suiteb_certification;
    RpcReqEapSetPacFile *req_eap_set_pac_file;
    RpcReqEapSetFastParams *req_eap_set_fast_params;
    RpcReqEapUseDefaultCertBundle *req_eap_use_default_cert_bundle;
    RpcReqWifiSetOkcSupport *req_wifi_set_okc_support;
    RpcReqEapSetDomainName *req_eap_set_domain_name;
    RpcReqEapSetDisableTimeCheck *req_eap_set_disable_time_check;
    RpcReqEapSetEapMethods *req_eap_set_eap_methods;
    RpcReqIfaceMacAddrSetGet *req_iface_mac_addr_set_get;
    RpcReqIfaceMacAddrLenGet *req_iface_mac_addr_len_get;
    RpcReqFeatureControl *req_feature_control;
    RpcReqCustomRpc *req_custom_rpc;
    RpcReqGpioConfig *req_gpio_config;
    RpcReqGpioResetPin *req_gpio_reset_pin;
    RpcReqGpioSetLevel *req_gpio_set_level;
    RpcReqGpioGetLevel *req_gpio_get_level;
    RpcReqGpioSetDirection *req_gpio_set_direction;
    RpcReqGpioInputEnable *req_gpio_input_enable;
    RpcReqGpioSetPullMode *req_gpio_set_pull_mode;
    RpcReqExtCoex *req_ext_coex;
    /*
     ** Responses *
     */
    RpcRespGetMacAddress *resp_get_mac_address;
    RpcRespSetMacAddress *resp_set_mac_address;
    RpcRespGetMode *resp_get_wifi_mode;
    RpcRespSetMode *resp_set_wifi_mode;
    RpcRespSuppDppInit *resp_supp_dpp_init;
    RpcRespSuppDppDeinit *resp_supp_dpp_deinit;
    RpcRespSuppDppBootstrapGen *resp_supp_dpp_bootstrap_gen;
    RpcRespSuppDppStartListen *resp_supp_dpp_start_listen;
    RpcRespSuppDppStopListen *resp_supp_dpp_stop_listen;
    RpcRespOTAActivate *resp_ota_activate;
    RpcRespAppGetDesc *resp_app_get_desc;
    RpcRespMemMonitor *resp_mem_monitor;
    RpcRespWifiScanParams *resp_wifi_scan_params;
    RpcRespSetPs *resp_wifi_set_ps;
    RpcRespGetPs *resp_wifi_get_ps;
    RpcRespOTABegin *resp_ota_begin;
    RpcRespOTAWrite *resp_ota_write;
    RpcRespOTAEnd *resp_ota_end;
    RpcRespWifiSetMaxTxPower *resp_set_wifi_max_tx_power;
    RpcRespWifiGetMaxTxPower *resp_get_wifi_max_tx_power;
    RpcRespConfigHeartbeat *resp_config_heartbeat;
    RpcRespWifiInit *resp_wifi_init;
    RpcRespWifiDeinit *resp_wifi_deinit;
    RpcRespWifiStart *resp_wifi_start;
    RpcRespWifiStop *resp_wifi_stop;
    RpcRespWifiConnect *resp_wifi_connect;
    RpcRespWifiDisconnect *resp_wifi_disconnect;
    RpcRespWifiSetConfig *resp_wifi_set_config;
    RpcRespWifiGetConfig *resp_wifi_get_config;
    RpcRespWifiScanStart *resp_wifi_scan_start;
    RpcRespWifiScanStop *resp_wifi_scan_stop;
    RpcRespWifiScanGetApNum *resp_wifi_scan_get_ap_num;
    RpcRespWifiScanGetApRecords *resp_wifi_scan_get_ap_records;
    RpcRespWifiClearApList *resp_wifi_clear_ap_list;
    RpcRespWifiRestore *resp_wifi_restore;
    RpcRespWifiClearFastConnect *resp_wifi_clear_fast_connect;
    RpcRespWifiDeauthSta *resp_wifi_deauth_sta;
    RpcRespWifiStaGetApInfo *resp_wifi_sta_get_ap_info;
    RpcRespWifiSetProtocol *resp_wifi_set_protocol;
    RpcRespWifiGetProtocol *resp_wifi_get_protocol;
    RpcRespWifiSetBandwidth *resp_wifi_set_bandwidth;
    RpcRespWifiGetBandwidth *resp_wifi_get_bandwidth;
    RpcRespWifiSetChannel *resp_wifi_set_channel;
    RpcRespWifiGetChannel *resp_wifi_get_channel;
    RpcRespWifiSetCountry *resp_wifi_set_country;
    RpcRespWifiGetCountry *resp_wifi_get_country;
    RpcRespWifiApGetStaList *resp_wifi_ap_get_sta_list;
    RpcRespWifiApGetStaAid *resp_wifi_ap_get_sta_aid;
    RpcRespWifiSetStorage *resp_wifi_set_storage;
    RpcRespWifiSetInactiveTime *resp_wifi_set_inactive_time;
    RpcRespWifiGetInactiveTime *resp_wifi_get_inactive_time;
    RpcRespWifiSetCountryCode *resp_wifi_set_country_code;
    RpcRespWifiGetCountryCode *resp_wifi_get_country_code;
    RpcRespWifiDisablePmfConfig *resp_wifi_disable_pmf_config;
    RpcRespWifiStaGetAid *resp_wifi_sta_get_aid;
    RpcRespWifiStaGetNegotiatedPhymode *resp_wifi_sta_get_negotiated_phymode;
    RpcRespWifiStaGetRssi *resp_wifi_sta_get_rssi;
    RpcRespWifiSetProtocols *resp_wifi_set_protocols;
    RpcRespWifiGetProtocols *resp_wifi_get_protocols;
    RpcRespWifiSetBandwidths *resp_wifi_set_bandwidths;
    RpcRespWifiGetBandwidths *resp_wifi_get_bandwidths;
    RpcRespWifiSetBand *resp_wifi_set_band;
    RpcRespWifiGetBand *resp_wifi_get_band;
    RpcRespWifiSetBandMode *resp_wifi_set_bandmode;
    RpcRespWifiGetBandMode *resp_wifi_get_bandmode;
    RpcRespGetCoprocessorFwVersion *resp_get_coprocessor_fwversion;
    RpcRespWifiScanGetApRecord *resp_wifi_scan_get_ap_record;
    RpcRespSetDhcpDnsStatus *resp_set_dhcp_dns;
    RpcRespGetDhcpDnsStatus *resp_get_dhcp_dns;
    RpcRespWifiStaTwtConfig *resp_wifi_sta_twt_config;
    RpcRespWifiStaItwtSetup *resp_wifi_sta_itwt_setup;
    RpcRespWifiStaItwtTeardown *resp_wifi_sta_itwt_teardown;
    RpcRespWifiStaItwtSuspend *resp_wifi_sta_itwt_suspend;
    RpcRespWifiStaItwtGetFlowIdStatus *resp_wifi_sta_itwt_get_flow_id_status;
    RpcRespWifiStaItwtSendProbeReq *resp_wifi_sta_itwt_send_probe_req;
    RpcRespWifiStaItwtSetTargetWakeTimeOffset *resp_wifi_sta_itwt_set_target_wake_time_offset;
    RpcRespWifiStaEnterpriseEnable *resp_wifi_sta_enterprise_enable;
    RpcRespWifiStaEnterpriseDisable *resp_wifi_sta_enterprise_disable;
    RpcRespEapSetIdentity *resp_eap_set_identity;
    RpcRespEapClearIdentity *resp_eap_clear_identity;
    RpcRespEapSetUsername *resp_eap_set_username;
    RpcRespEapClearUsername *resp_eap_clear_username;
    RpcRespEapSetPassword *resp_eap_set_password;
    RpcRespEapClearPassword *resp_eap_clear_password;
    RpcRespEapSetNewPassword *resp_eap_set_new_password;
    RpcRespEapClearNewPassword *resp_eap_clear_new_password;
    RpcRespEapSetCaCert *resp_eap_set_ca_cert;
    RpcRespEapClearCaCert *resp_eap_clear_ca_cert;
    RpcRespEapSetCertificateAndKey *resp_eap_set_certificate_and_key;
    RpcRespEapClearCertificateAndKey *resp_eap_clear_certificate_and_key;
    RpcRespEapGetDisableTimeCheck *resp_eap_get_disable_time_check;
    RpcRespEapSetTtlsPhase2Method *resp_eap_set_ttls_phase2_method;
    RpcRespEapSetSuiteb192bitCertification *resp_eap_set_suiteb_certification;
    RpcRespEapSetPacFile *resp_eap_set_pac_file;
    RpcRespEapSetFastParams *resp_eap_set_fast_params;
    RpcRespEapUseDefaultCertBundle *resp_eap_use_default_cert_bundle;
    RpcRespWifiSetOkcSupport *resp_wifi_set_okc_support;
    RpcRespEapSetDomainName *resp_eap_set_domain_name;
    RpcRespEapSetDisableTimeCheck *resp_eap_set_disable_time_check;
    RpcRespEapSetEapMethods *resp_eap_set_eap_methods;
    RpcRespIfaceMacAddrSetGet *resp_iface_mac_addr_set_get;
    RpcRespIfaceMacAddrLenGet *resp_iface_mac_addr_len_get;
    RpcRespFeatureControl *resp_feature_control;
    RpcRespCustomRpc *resp_custom_rpc;
    RpcRespGpioConfig *resp_gpio_config;
    RpcRespGpioResetPin *resp_gpio_reset;
    RpcRespGpioSetLevel *resp_gpio_set_level;
    RpcRespGpioGetLevel *resp_gpio_get_level;
    RpcRespGpioSetDirection *resp_gpio_set_direction;
    RpcRespGpioInputEnable *resp_gpio_input_enable;
    RpcRespGpioSetPullMode *resp_gpio_set_pull_mode;
    RpcRespExtCoex *resp_ext_coex;
    /*
     ** Notifications *
     */
    RpcEventESPInit *event_esp_init;
    RpcEventHeartbeat *event_heartbeat;
    RpcEventAPStaConnected *event_ap_sta_connected;
    RpcEventAPStaDisconnected *event_ap_sta_disconnected;
    RpcEventWifiEventNoArgs *event_wifi_event_no_args;
    RpcEventStaScanDone *event_sta_scan_done;
    RpcEventStaConnected *event_sta_connected;
    RpcEventStaDisconnected *event_sta_disconnected;
    RpcEventDhcpDnsStatus *event_dhcp_dns;
    RpcEventStaItwtSetup *event_sta_itwt_setup;
    RpcEventStaItwtTeardown *event_sta_itwt_teardown;
    RpcEventStaItwtSuspend *event_sta_itwt_suspend;
    RpcEventStaItwtProbe *event_sta_itwt_probe;
    RpcEventSuppDppUriReady *event_supp_dpp_uri_ready;
    RpcEventSuppDppCfgRecvd *event_supp_dpp_cfg_recvd;
    RpcEventSuppDppFail *event_supp_dpp_fail;
    RpcEventWifiDppUriReady *event_wifi_dpp_uri_ready;
    RpcEventWifiDppCfgRecvd *event_wifi_dpp_cfg_recvd;
    RpcEventWifiDppFail *event_wifi_dpp_fail;
    RpcEventCustomRpc *event_custom_rpc;
    RpcEventMemMonitor *event_mem_monitor;
  };
};
#define RPC__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&rpc__descriptor) \
    , RPC_TYPE__MsgType_Invalid, RPC_ID__MsgId_Invalid, 0, RPC__PAYLOAD__NOT_SET, {0} }


/* WifiInitConfig methods */
void   wifi_init_config__init
                     (WifiInitConfig         *message);
size_t wifi_init_config__get_packed_size
                     (const WifiInitConfig   *message);
size_t wifi_init_config__pack
                     (const WifiInitConfig   *message,
                      uint8_t             *out);
size_t wifi_init_config__pack_to_buffer
                     (const WifiInitConfig   *message,
                      ProtobufCBuffer     *buffer);
WifiInitConfig *
       wifi_init_config__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   wifi_init_config__free_unpacked
                     (WifiInitConfig *message,
                      ProtobufCAllocator *allocator);
/* WifiCountry methods */
void   wifi_country__init
                     (WifiCountry         *message);
size_t wifi_country__get_packed_size
                     (const WifiCountry   *message);
size_t wifi_country__pack
                     (const WifiCountry   *message,
                      uint8_t             *out);
size_t wifi_country__pack_to_buffer
                     (const WifiCountry   *message,
                      ProtobufCBuffer     *buffer);
WifiCountry *
       wifi_country__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   wifi_country__free_unpacked
                     (WifiCountry *message,
                      ProtobufCAllocator *allocator);
/* WifiActiveScanTime methods */
void   wifi_active_scan_time__init
                     (WifiActiveScanTime         *message);
size_t wifi_active_scan_time__get_packed_size
                     (const WifiActiveScanTime   *message);
size_t wifi_active_scan_time__pack
                     (const WifiActiveScanTime   *message,
                      uint8_t             *out);
size_t wifi_active_scan_time__pack_to_buffer
                     (const WifiActiveScanTime   *message,
                      ProtobufCBuffer     *buffer);
WifiActiveScanTime *
       wifi_active_scan_time__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   wifi_active_scan_time__free_unpacked
                     (WifiActiveScanTime *message,
                      ProtobufCAllocator *allocator);
/* WifiScanTime methods */
void   wifi_scan_time__init
                     (WifiScanTime         *message);
size_t wifi_scan_time__get_packed_size
                     (const WifiScanTime   *message);
size_t wifi_scan_time__pack
                     (const WifiScanTime   *message,
                      uint8_t             *out);
size_t wifi_scan_time__pack_to_buffer
                     (const WifiScanTime   *message,
                      ProtobufCBuffer     *buffer);
WifiScanTime *
       wifi_scan_time__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   wifi_scan_time__free_unpacked
                     (WifiScanTime *message,
                      ProtobufCAllocator *allocator);
/* WifiScanChannelBitmap methods */
void   wifi_scan_channel_bitmap__init
                     (WifiScanChannelBitmap         *message);
size_t wifi_scan_channel_bitmap__get_packed_size
                     (const WifiScanChannelBitmap   *message);
size_t wifi_scan_channel_bitmap__pack
                     (const WifiScanChannelBitmap   *message,
                      uint8_t             *out);
size_t wifi_scan_channel_bitmap__pack_to_buffer
                     (const WifiScanChannelBitmap   *message,
                      ProtobufCBuffer     *buffer);
WifiScanChannelBitmap *
       wifi_scan_channel_bitmap__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   wifi_scan_channel_bitmap__free_unpacked
                     (WifiScanChannelBitmap *message,
                      ProtobufCAllocator *allocator);
/* WifiScanConfig methods */
void   wifi_scan_config__init
                     (WifiScanConfig         *message);
size_t wifi_scan_config__get_packed_size
                     (const WifiScanConfig   *message);
size_t wifi_scan_config__pack
                     (const WifiScanConfig   *message,
                      uint8_t             *out);
size_t wifi_scan_config__pack_to_buffer
                     (const WifiScanConfig   *message,
                      ProtobufCBuffer     *buffer);
WifiScanConfig *
       wifi_scan_config__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   wifi_scan_config__free_unpacked
                     (WifiScanConfig *message,
                      ProtobufCAllocator *allocator);
/* WifiScanDefaultParams methods */
void   wifi_scan_default_params__init
                     (WifiScanDefaultParams         *message);
size_t wifi_scan_default_params__get_packed_size
                     (const WifiScanDefaultParams   *message);
size_t wifi_scan_default_params__pack
                     (const WifiScanDefaultParams   *message,
                      uint8_t             *out);
size_t wifi_scan_default_params__pack_to_buffer
                     (const WifiScanDefaultParams   *message,
                      ProtobufCBuffer     *buffer);
WifiScanDefaultParams *
       wifi_scan_default_params__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   wifi_scan_default_params__free_unpacked
                     (WifiScanDefaultParams *message,
                      ProtobufCAllocator *allocator);
/* WifiHeApInfo methods */
void   wifi_he_ap_info__init
                     (WifiHeApInfo         *message);
size_t wifi_he_ap_info__get_packed_size
                     (const WifiHeApInfo   *message);
size_t wifi_he_ap_info__pack
                     (const WifiHeApInfo   *message,
                      uint8_t             *out);
size_t wifi_he_ap_info__pack_to_buffer
                     (const WifiHeApInfo   *message,
                      ProtobufCBuffer     *buffer);
WifiHeApInfo *
       wifi_he_ap_info__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   wifi_he_ap_info__free_unpacked
                     (WifiHeApInfo *message,
                      ProtobufCAllocator *allocator);
/* WifiApRecord methods */
void   wifi_ap_record__init
                     (WifiApRecord         *message);
size_t wifi_ap_record__get_packed_size
                     (const WifiApRecord   *message);
size_t wifi_ap_record__pack
                     (const WifiApRecord   *message,
                      uint8_t             *out);
size_t wifi_ap_record__pack_to_buffer
                     (const WifiApRecord   *message,
                      ProtobufCBuffer     *buffer);
WifiApRecord *
       wifi_ap_record__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   wifi_ap_record__free_unpacked
                     (WifiApRecord *message,
                      ProtobufCAllocator *allocator);
/* WifiScanThreshold methods */
void   wifi_scan_threshold__init
                     (WifiScanThreshold         *message);
size_t wifi_scan_threshold__get_packed_size
                     (const WifiScanThreshold   *message);
size_t wifi_scan_threshold__pack
                     (const WifiScanThreshold   *message,
                      uint8_t             *out);
size_t wifi_scan_threshold__pack_to_buffer
                     (const WifiScanThreshold   *message,
                      ProtobufCBuffer     *buffer);
WifiScanThreshold *
       wifi_scan_threshold__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   wifi_scan_threshold__free_unpacked
                     (WifiScanThreshold *message,
                      ProtobufCAllocator *allocator);
/* WifiPmfConfig methods */
void   wifi_pmf_config__init
                     (WifiPmfConfig         *message);
size_t wifi_pmf_config__get_packed_size
                     (const WifiPmfConfig   *message);
size_t wifi_pmf_config__pack
                     (const WifiPmfConfig   *message,
                      uint8_t             *out);
size_t wifi_pmf_config__pack_to_buffer
                     (const WifiPmfConfig   *message,
                      ProtobufCBuffer     *buffer);
WifiPmfConfig *
       wifi_pmf_config__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   wifi_pmf_config__free_unpacked
                     (WifiPmfConfig *message,
                      ProtobufCAllocator *allocator);
/* WifiBssMaxIdleConfig methods */
void   wifi_bss_max_idle_config__init
                     (WifiBssMaxIdleConfig         *message);
size_t wifi_bss_max_idle_config__get_packed_size
                     (const WifiBssMaxIdleConfig   *message);
size_t wifi_bss_max_idle_config__pack
                     (const WifiBssMaxIdleConfig   *message,
                      uint8_t             *out);
size_t wifi_bss_max_idle_config__pack_to_buffer
                     (const WifiBssMaxIdleConfig   *message,
                      ProtobufCBuffer     *buffer);
WifiBssMaxIdleConfig *
       wifi_bss_max_idle_config__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   wifi_bss_max_idle_config__free_unpacked
                     (WifiBssMaxIdleConfig *message,
                      ProtobufCAllocator *allocator);
/* WifiApConfig methods */
void   wifi_ap_config__init
                     (WifiApConfig         *message);
size_t wifi_ap_config__get_packed_size
                     (const WifiApConfig   *message);
size_t wifi_ap_config__pack
                     (const WifiApConfig   *message,
                      uint8_t             *out);
size_t wifi_ap_config__pack_to_buffer
                     (const WifiApConfig   *message,
                      ProtobufCBuffer     *buffer);
WifiApConfig *
       wifi_ap_config__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   wifi_ap_config__free_unpacked
                     (WifiApConfig *message,
                      ProtobufCAllocator *allocator);
/* WifiStaConfig methods */
void   wifi_sta_config__init
                     (WifiStaConfig         *message);
size_t wifi_sta_config__get_packed_size
                     (const WifiStaConfig   *message);
size_t wifi_sta_config__pack
                     (const WifiStaConfig   *message,
                      uint8_t             *out);
size_t wifi_sta_config__pack_to_buffer
                     (const WifiStaConfig   *message,
                      ProtobufCBuffer     *buffer);
WifiStaConfig *
       wifi_sta_config__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   wifi_sta_config__free_unpacked
                     (WifiStaConfig *message,
                      ProtobufCAllocator *allocator);
/* WifiConfig methods */
void   wifi_config__init
                     (WifiConfig         *message);
size_t wifi_config__get_packed_size
                     (const WifiConfig   *message);
size_t wifi_config__pack
                     (const WifiConfig   *message,
                      uint8_t             *out);
size_t wifi_config__pack_to_buffer
                     (const WifiConfig   *message,
                      ProtobufCBuffer     *buffer);
WifiConfig *
       wifi_config__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   wifi_config__free_unpacked
                     (WifiConfig *message,
                      ProtobufCAllocator *allocator);
/* WifiStaInfo methods */
void   wifi_sta_info__init
                     (WifiStaInfo         *message);
size_t wifi_sta_info__get_packed_size
                     (const WifiStaInfo   *message);
size_t wifi_sta_info__pack
                     (const WifiStaInfo   *message,
                      uint8_t             *out);
size_t wifi_sta_info__pack_to_buffer
                     (const WifiStaInfo   *message,
                      ProtobufCBuffer     *buffer);
WifiStaInfo *
       wifi_sta_info__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   wifi_sta_info__free_unpacked
                     (WifiStaInfo *message,
                      ProtobufCAllocator *allocator);
/* WifiStaList methods */
void   wifi_sta_list__init
                     (WifiStaList         *message);
size_t wifi_sta_list__get_packed_size
                     (const WifiStaList   *message);
size_t wifi_sta_list__pack
                     (const WifiStaList   *message,
                      uint8_t             *out);
size_t wifi_sta_list__pack_to_buffer
                     (const WifiStaList   *message,
                      ProtobufCBuffer     *buffer);
WifiStaList *
       wifi_sta_list__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   wifi_sta_list__free_unpacked
                     (WifiStaList *message,
                      ProtobufCAllocator *allocator);
/* WifiPktRxCtrl methods */
void   wifi_pkt_rx_ctrl__init
                     (WifiPktRxCtrl         *message);
size_t wifi_pkt_rx_ctrl__get_packed_size
                     (const WifiPktRxCtrl   *message);
size_t wifi_pkt_rx_ctrl__pack
                     (const WifiPktRxCtrl   *message,
                      uint8_t             *out);
size_t wifi_pkt_rx_ctrl__pack_to_buffer
                     (const WifiPktRxCtrl   *message,
                      ProtobufCBuffer     *buffer);
WifiPktRxCtrl *
       wifi_pkt_rx_ctrl__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   wifi_pkt_rx_ctrl__free_unpacked
                     (WifiPktRxCtrl *message,
                      ProtobufCAllocator *allocator);
/* WifiPromiscuousPkt methods */
void   wifi_promiscuous_pkt__init
                     (WifiPromiscuousPkt         *message);
size_t wifi_promiscuous_pkt__get_packed_size
                     (const WifiPromiscuousPkt   *message);
size_t wifi_promiscuous_pkt__pack
                     (const WifiPromiscuousPkt   *message,
                      uint8_t             *out);
size_t wifi_promiscuous_pkt__pack_to_buffer
                     (const WifiPromiscuousPkt   *message,
                      ProtobufCBuffer     *buffer);
WifiPromiscuousPkt *
       wifi_promiscuous_pkt__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   wifi_promiscuous_pkt__free_unpacked
                     (WifiPromiscuousPkt *message,
                      ProtobufCAllocator *allocator);
/* WifiPromiscuousFilter methods */
void   wifi_promiscuous_filter__init
                     (WifiPromiscuousFilter         *message);
size_t wifi_promiscuous_filter__get_packed_size
                     (const WifiPromiscuousFilter   *message);
size_t wifi_promiscuous_filter__pack
                     (const WifiPromiscuousFilter   *message,
                      uint8_t             *out);
size_t wifi_promiscuous_filter__pack_to_buffer
                     (const WifiPromiscuousFilter   *message,
                      ProtobufCBuffer     *buffer);
WifiPromiscuousFilter *
       wifi_promiscuous_filter__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   wifi_promiscuous_filter__free_unpacked
                     (WifiPromiscuousFilter *message,
                      ProtobufCAllocator *allocator);
/* WifiCsiConfig methods */
void   wifi_csi_config__init
                     (WifiCsiConfig         *message);
size_t wifi_csi_config__get_packed_size
                     (const WifiCsiConfig   *message);
size_t wifi_csi_config__pack
                     (const WifiCsiConfig   *message,
                      uint8_t             *out);
size_t wifi_csi_config__pack_to_buffer
                     (const WifiCsiConfig   *message,
                      ProtobufCBuffer     *buffer);
WifiCsiConfig *
       wifi_csi_config__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   wifi_csi_config__free_unpacked
                     (WifiCsiConfig *message,
                      ProtobufCAllocator *allocator);
/* WifiCsiInfo methods */
void   wifi_csi_info__init
                     (WifiCsiInfo         *message);
size_t wifi_csi_info__get_packed_size
                     (const WifiCsiInfo   *message);
size_t wifi_csi_info__pack
                     (const WifiCsiInfo   *message,
                      uint8_t             *out);
size_t wifi_csi_info__pack_to_buffer
                     (const WifiCsiInfo   *message,
                      ProtobufCBuffer     *buffer);
WifiCsiInfo *
       wifi_csi_info__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   wifi_csi_info__free_unpacked
                     (WifiCsiInfo *message,
                      ProtobufCAllocator *allocator);
/* WifiAntGpio methods */
void   wifi_ant_gpio__init
                     (WifiAntGpio         *message);
size_t wifi_ant_gpio__get_packed_size
                     (const WifiAntGpio   *message);
size_t wifi_ant_gpio__pack
                     (const WifiAntGpio   *message,
                      uint8_t             *out);
size_t wifi_ant_gpio__pack_to_buffer
                     (const WifiAntGpio   *message,
                      ProtobufCBuffer     *buffer);
WifiAntGpio *
       wifi_ant_gpio__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   wifi_ant_gpio__free_unpacked
                     (WifiAntGpio *message,
                      ProtobufCAllocator *allocator);
/* WifiAntGpioConfig methods */
void   wifi_ant_gpio_config__init
                     (WifiAntGpioConfig         *message);
size_t wifi_ant_gpio_config__get_packed_size
                     (const WifiAntGpioConfig   *message);
size_t wifi_ant_gpio_config__pack
                     (const WifiAntGpioConfig   *message,
                      uint8_t             *out);
size_t wifi_ant_gpio_config__pack_to_buffer
                     (const WifiAntGpioConfig   *message,
                      ProtobufCBuffer     *buffer);
WifiAntGpioConfig *
       wifi_ant_gpio_config__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   wifi_ant_gpio_config__free_unpacked
                     (WifiAntGpioConfig *message,
                      ProtobufCAllocator *allocator);
/* WifiAntConfig methods */
void   wifi_ant_config__init
                     (WifiAntConfig         *message);
size_t wifi_ant_config__get_packed_size
                     (const WifiAntConfig   *message);
size_t wifi_ant_config__pack
                     (const WifiAntConfig   *message,
                      uint8_t             *out);
size_t wifi_ant_config__pack_to_buffer
                     (const WifiAntConfig   *message,
                      ProtobufCBuffer     *buffer);
WifiAntConfig *
       wifi_ant_config__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   wifi_ant_config__free_unpacked
                     (WifiAntConfig *message,
                      ProtobufCAllocator *allocator);
/* WifiActionTxReq methods */
void   wifi_action_tx_req__init
                     (WifiActionTxReq         *message);
size_t wifi_action_tx_req__get_packed_size
                     (const WifiActionTxReq   *message);
size_t wifi_action_tx_req__pack
                     (const WifiActionTxReq   *message,
                      uint8_t             *out);
size_t wifi_action_tx_req__pack_to_buffer
                     (const WifiActionTxReq   *message,
                      ProtobufCBuffer     *buffer);
WifiActionTxReq *
       wifi_action_tx_req__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   wifi_action_tx_req__free_unpacked
                     (WifiActionTxReq *message,
                      ProtobufCAllocator *allocator);
/* WifiFtmInitiatorCfg methods */
void   wifi_ftm_initiator_cfg__init
                     (WifiFtmInitiatorCfg         *message);
size_t wifi_ftm_initiator_cfg__get_packed_size
                     (const WifiFtmInitiatorCfg   *message);
size_t wifi_ftm_initiator_cfg__pack
                     (const WifiFtmInitiatorCfg   *message,
                      uint8_t             *out);
size_t wifi_ftm_initiator_cfg__pack_to_buffer
                     (const WifiFtmInitiatorCfg   *message,
                      ProtobufCBuffer     *buffer);
WifiFtmInitiatorCfg *
       wifi_ftm_initiator_cfg__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   wifi_ftm_initiator_cfg__free_unpacked
                     (WifiFtmInitiatorCfg *message,
                      ProtobufCAllocator *allocator);
/* WifiEventStaScanDone methods */
void   wifi_event_sta_scan_done__init
                     (WifiEventStaScanDone         *message);
size_t wifi_event_sta_scan_done__get_packed_size
                     (const WifiEventStaScanDone   *message);
size_t wifi_event_sta_scan_done__pack
                     (const WifiEventStaScanDone   *message,
                      uint8_t             *out);
size_t wifi_event_sta_scan_done__pack_to_buffer
                     (const WifiEventStaScanDone   *message,
                      ProtobufCBuffer     *buffer);
WifiEventStaScanDone *
       wifi_event_sta_scan_done__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   wifi_event_sta_scan_done__free_unpacked
                     (WifiEventStaScanDone *message,
                      ProtobufCAllocator *allocator);
/* WifiEventStaConnected methods */
void   wifi_event_sta_connected__init
                     (WifiEventStaConnected         *message);
size_t wifi_event_sta_connected__get_packed_size
                     (const WifiEventStaConnected   *message);
size_t wifi_event_sta_connected__pack
                     (const WifiEventStaConnected   *message,
                      uint8_t             *out);
size_t wifi_event_sta_connected__pack_to_buffer
                     (const WifiEventStaConnected   *message,
                      ProtobufCBuffer     *buffer);
WifiEventStaConnected *
       wifi_event_sta_connected__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   wifi_event_sta_connected__free_unpacked
                     (WifiEventStaConnected *message,
                      ProtobufCAllocator *allocator);
/* WifiEventStaDisconnected methods */
void   wifi_event_sta_disconnected__init
                     (WifiEventStaDisconnected         *message);
size_t wifi_event_sta_disconnected__get_packed_size
                     (const WifiEventStaDisconnected   *message);
size_t wifi_event_sta_disconnected__pack
                     (const WifiEventStaDisconnected   *message,
                      uint8_t             *out);
size_t wifi_event_sta_disconnected__pack_to_buffer
                     (const WifiEventStaDisconnected   *message,
                      ProtobufCBuffer     *buffer);
WifiEventStaDisconnected *
       wifi_event_sta_disconnected__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   wifi_event_sta_disconnected__free_unpacked
                     (WifiEventStaDisconnected *message,
                      ProtobufCAllocator *allocator);
/* WifiEventStaAuthmodeChange methods */
void   wifi_event_sta_authmode_change__init
                     (WifiEventStaAuthmodeChange         *message);
size_t wifi_event_sta_authmode_change__get_packed_size
                     (const WifiEventStaAuthmodeChange   *message);
size_t wifi_event_sta_authmode_change__pack
                     (const WifiEventStaAuthmodeChange   *message,
                      uint8_t             *out);
size_t wifi_event_sta_authmode_change__pack_to_buffer
                     (const WifiEventStaAuthmodeChange   *message,
                      ProtobufCBuffer     *buffer);
WifiEventStaAuthmodeChange *
       wifi_event_sta_authmode_change__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   wifi_event_sta_authmode_change__free_unpacked
                     (WifiEventStaAuthmodeChange *message,
                      ProtobufCAllocator *allocator);
/* WifiEventStaWpsErPin methods */
void   wifi_event_sta_wps_er_pin__init
                     (WifiEventStaWpsErPin         *message);
size_t wifi_event_sta_wps_er_pin__get_packed_size
                     (const WifiEventStaWpsErPin   *message);
size_t wifi_event_sta_wps_er_pin__pack
                     (const WifiEventStaWpsErPin   *message,
                      uint8_t             *out);
size_t wifi_event_sta_wps_er_pin__pack_to_buffer
                     (const WifiEventStaWpsErPin   *message,
                      ProtobufCBuffer     *buffer);
WifiEventStaWpsErPin *
       wifi_event_sta_wps_er_pin__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   wifi_event_sta_wps_er_pin__free_unpacked
                     (WifiEventStaWpsErPin *message,
                      ProtobufCAllocator *allocator);
/* ApCred methods */
void   ap_cred__init
                     (ApCred         *message);
size_t ap_cred__get_packed_size
                     (const ApCred   *message);
size_t ap_cred__pack
                     (const ApCred   *message,
                      uint8_t             *out);
size_t ap_cred__pack_to_buffer
                     (const ApCred   *message,
                      ProtobufCBuffer     *buffer);
ApCred *
       ap_cred__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   ap_cred__free_unpacked
                     (ApCred *message,
                      ProtobufCAllocator *allocator);
/* WifiEventStaWpsErSuccess methods */
void   wifi_event_sta_wps_er_success__init
                     (WifiEventStaWpsErSuccess         *message);
size_t wifi_event_sta_wps_er_success__get_packed_size
                     (const WifiEventStaWpsErSuccess   *message);
size_t wifi_event_sta_wps_er_success__pack
                     (const WifiEventStaWpsErSuccess   *message,
                      uint8_t             *out);
size_t wifi_event_sta_wps_er_success__pack_to_buffer
                     (const WifiEventStaWpsErSuccess   *message,
                      ProtobufCBuffer     *buffer);
WifiEventStaWpsErSuccess *
       wifi_event_sta_wps_er_success__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   wifi_event_sta_wps_er_success__free_unpacked
                     (WifiEventStaWpsErSuccess *message,
                      ProtobufCAllocator *allocator);
/* WifiEventApProbeReqRx methods */
void   wifi_event_ap_probe_req_rx__init
                     (WifiEventApProbeReqRx         *message);
size_t wifi_event_ap_probe_req_rx__get_packed_size
                     (const WifiEventApProbeReqRx   *message);
size_t wifi_event_ap_probe_req_rx__pack
                     (const WifiEventApProbeReqRx   *message,
                      uint8_t             *out);
size_t wifi_event_ap_probe_req_rx__pack_to_buffer
                     (const WifiEventApProbeReqRx   *message,
                      ProtobufCBuffer     *buffer);
WifiEventApProbeReqRx *
       wifi_event_ap_probe_req_rx__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   wifi_event_ap_probe_req_rx__free_unpacked
                     (WifiEventApProbeReqRx *message,
                      ProtobufCAllocator *allocator);
/* WifiEventBssRssiLow methods */
void   wifi_event_bss_rssi_low__init
                     (WifiEventBssRssiLow         *message);
size_t wifi_event_bss_rssi_low__get_packed_size
                     (const WifiEventBssRssiLow   *message);
size_t wifi_event_bss_rssi_low__pack
                     (const WifiEventBssRssiLow   *message,
                      uint8_t             *out);
size_t wifi_event_bss_rssi_low__pack_to_buffer
                     (const WifiEventBssRssiLow   *message,
                      ProtobufCBuffer     *buffer);
WifiEventBssRssiLow *
       wifi_event_bss_rssi_low__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   wifi_event_bss_rssi_low__free_unpacked
                     (WifiEventBssRssiLow *message,
                      ProtobufCAllocator *allocator);
/* WifiFtmReportEntry methods */
void   wifi_ftm_report_entry__init
                     (WifiFtmReportEntry         *message);
size_t wifi_ftm_report_entry__get_packed_size
                     (const WifiFtmReportEntry   *message);
size_t wifi_ftm_report_entry__pack
                     (const WifiFtmReportEntry   *message,
                      uint8_t             *out);
size_t wifi_ftm_report_entry__pack_to_buffer
                     (const WifiFtmReportEntry   *message,
                      ProtobufCBuffer     *buffer);
WifiFtmReportEntry *
       wifi_ftm_report_entry__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   wifi_ftm_report_entry__free_unpacked
                     (WifiFtmReportEntry *message,
                      ProtobufCAllocator *allocator);
/* WifiEventFtmReport methods */
void   wifi_event_ftm_report__init
                     (WifiEventFtmReport         *message);
size_t wifi_event_ftm_report__get_packed_size
                     (const WifiEventFtmReport   *message);
size_t wifi_event_ftm_report__pack
                     (const WifiEventFtmReport   *message,
                      uint8_t             *out);
size_t wifi_event_ftm_report__pack_to_buffer
                     (const WifiEventFtmReport   *message,
                      ProtobufCBuffer     *buffer);
WifiEventFtmReport *
       wifi_event_ftm_report__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   wifi_event_ftm_report__free_unpacked
                     (WifiEventFtmReport *message,
                      ProtobufCAllocator *allocator);
/* WifiEventActionTxStatus methods */
void   wifi_event_action_tx_status__init
                     (WifiEventActionTxStatus         *message);
size_t wifi_event_action_tx_status__get_packed_size
                     (const WifiEventActionTxStatus   *message);
size_t wifi_event_action_tx_status__pack
                     (const WifiEventActionTxStatus   *message,
                      uint8_t             *out);
size_t wifi_event_action_tx_status__pack_to_buffer
                     (const WifiEventActionTxStatus   *message,
                      ProtobufCBuffer     *buffer);
WifiEventActionTxStatus *
       wifi_event_action_tx_status__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   wifi_event_action_tx_status__free_unpacked
                     (WifiEventActionTxStatus *message,
                      ProtobufCAllocator *allocator);
/* WifiEventRocDone methods */
void   wifi_event_roc_done__init
                     (WifiEventRocDone         *message);
size_t wifi_event_roc_done__get_packed_size
                     (const WifiEventRocDone   *message);
size_t wifi_event_roc_done__pack
                     (const WifiEventRocDone   *message,
                      uint8_t             *out);
size_t wifi_event_roc_done__pack_to_buffer
                     (const WifiEventRocDone   *message,
                      ProtobufCBuffer     *buffer);
WifiEventRocDone *
       wifi_event_roc_done__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   wifi_event_roc_done__free_unpacked
                     (WifiEventRocDone *message,
                      ProtobufCAllocator *allocator);
/* WifiEventApWpsRgPin methods */
void   wifi_event_ap_wps_rg_pin__init
                     (WifiEventApWpsRgPin         *message);
size_t wifi_event_ap_wps_rg_pin__get_packed_size
                     (const WifiEventApWpsRgPin   *message);
size_t wifi_event_ap_wps_rg_pin__pack
                     (const WifiEventApWpsRgPin   *message,
                      uint8_t             *out);
size_t wifi_event_ap_wps_rg_pin__pack_to_buffer
                     (const WifiEventApWpsRgPin   *message,
                      ProtobufCBuffer     *buffer);
WifiEventApWpsRgPin *
       wifi_event_ap_wps_rg_pin__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   wifi_event_ap_wps_rg_pin__free_unpacked
                     (WifiEventApWpsRgPin *message,
                      ProtobufCAllocator *allocator);
/* WifiEventApWpsRgFailReason methods */
void   wifi_event_ap_wps_rg_fail_reason__init
                     (WifiEventApWpsRgFailReason         *message);
size_t wifi_event_ap_wps_rg_fail_reason__get_packed_size
                     (const WifiEventApWpsRgFailReason   *message);
size_t wifi_event_ap_wps_rg_fail_reason__pack
                     (const WifiEventApWpsRgFailReason   *message,
                      uint8_t             *out);
size_t wifi_event_ap_wps_rg_fail_reason__pack_to_buffer
                     (const WifiEventApWpsRgFailReason   *message,
                      ProtobufCBuffer     *buffer);
WifiEventApWpsRgFailReason *
       wifi_event_ap_wps_rg_fail_reason__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   wifi_event_ap_wps_rg_fail_reason__free_unpacked
                     (WifiEventApWpsRgFailReason *message,
                      ProtobufCAllocator *allocator);
/* WifiEventApWpsRgSuccess methods */
void   wifi_event_ap_wps_rg_success__init
                     (WifiEventApWpsRgSuccess         *message);
size_t wifi_event_ap_wps_rg_success__get_packed_size
                     (const WifiEventApWpsRgSuccess   *message);
size_t wifi_event_ap_wps_rg_success__pack
                     (const WifiEventApWpsRgSuccess   *message,
                      uint8_t             *out);
size_t wifi_event_ap_wps_rg_success__pack_to_buffer
                     (const WifiEventApWpsRgSuccess   *message,
                      ProtobufCBuffer     *buffer);
WifiEventApWpsRgSuccess *
       wifi_event_ap_wps_rg_success__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   wifi_event_ap_wps_rg_success__free_unpacked
                     (WifiEventApWpsRgSuccess *message,
                      ProtobufCAllocator *allocator);
/* WifiProtocols methods */
void   wifi_protocols__init
                     (WifiProtocols         *message);
size_t wifi_protocols__get_packed_size
                     (const WifiProtocols   *message);
size_t wifi_protocols__pack
                     (const WifiProtocols   *message,
                      uint8_t             *out);
size_t wifi_protocols__pack_to_buffer
                     (const WifiProtocols   *message,
                      ProtobufCBuffer     *buffer);
WifiProtocols *
       wifi_protocols__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   wifi_protocols__free_unpacked
                     (WifiProtocols *message,
                      ProtobufCAllocator *allocator);
/* WifiBandwidths methods */
void   wifi_bandwidths__init
                     (WifiBandwidths         *message);
size_t wifi_bandwidths__get_packed_size
                     (const WifiBandwidths   *message);
size_t wifi_bandwidths__pack
                     (const WifiBandwidths   *message,
                      uint8_t             *out);
size_t wifi_bandwidths__pack_to_buffer
                     (const WifiBandwidths   *message,
                      ProtobufCBuffer     *buffer);
WifiBandwidths *
       wifi_bandwidths__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   wifi_bandwidths__free_unpacked
                     (WifiBandwidths *message,
                      ProtobufCAllocator *allocator);
/* WifiItwtSetupConfig methods */
void   wifi_itwt_setup_config__init
                     (WifiItwtSetupConfig         *message);
size_t wifi_itwt_setup_config__get_packed_size
                     (const WifiItwtSetupConfig   *message);
size_t wifi_itwt_setup_config__pack
                     (const WifiItwtSetupConfig   *message,
                      uint8_t             *out);
size_t wifi_itwt_setup_config__pack_to_buffer
                     (const WifiItwtSetupConfig   *message,
                      ProtobufCBuffer     *buffer);
WifiItwtSetupConfig *
       wifi_itwt_setup_config__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   wifi_itwt_setup_config__free_unpacked
                     (WifiItwtSetupConfig *message,
                      ProtobufCAllocator *allocator);
/* WifiTwtConfig methods */
void   wifi_twt_config__init
                     (WifiTwtConfig         *message);
size_t wifi_twt_config__get_packed_size
                     (const WifiTwtConfig   *message);
size_t wifi_twt_config__pack
                     (const WifiTwtConfig   *message,
                      uint8_t             *out);
size_t wifi_twt_config__pack_to_buffer
                     (const WifiTwtConfig   *message,
                      ProtobufCBuffer     *buffer);
WifiTwtConfig *
       wifi_twt_config__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   wifi_twt_config__free_unpacked
                     (WifiTwtConfig *message,
                      ProtobufCAllocator *allocator);
/* EspAppDesc methods */
void   esp_app_desc__init
                     (EspAppDesc         *message);
size_t esp_app_desc__get_packed_size
                     (const EspAppDesc   *message);
size_t esp_app_desc__pack
                     (const EspAppDesc   *message,
                      uint8_t             *out);
size_t esp_app_desc__pack_to_buffer
                     (const EspAppDesc   *message,
                      ProtobufCBuffer     *buffer);
EspAppDesc *
       esp_app_desc__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   esp_app_desc__free_unpacked
                     (EspAppDesc *message,
                      ProtobufCAllocator *allocator);
/* HeapSizeThreshold methods */
void   heap_size_threshold__init
                     (HeapSizeThreshold         *message);
size_t heap_size_threshold__get_packed_size
                     (const HeapSizeThreshold   *message);
size_t heap_size_threshold__pack
                     (const HeapSizeThreshold   *message,
                      uint8_t             *out);
size_t heap_size_threshold__pack_to_buffer
                     (const HeapSizeThreshold   *message,
                      ProtobufCBuffer     *buffer);
HeapSizeThreshold *
       heap_size_threshold__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   heap_size_threshold__free_unpacked
                     (HeapSizeThreshold *message,
                      ProtobufCAllocator *allocator);
/* MemInfo methods */
void   mem_info__init
                     (MemInfo         *message);
size_t mem_info__get_packed_size
                     (const MemInfo   *message);
size_t mem_info__pack
                     (const MemInfo   *message,
                      uint8_t             *out);
size_t mem_info__pack_to_buffer
                     (const MemInfo   *message,
                      ProtobufCBuffer     *buffer);
MemInfo *
       mem_info__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   mem_info__free_unpacked
                     (MemInfo *message,
                      ProtobufCAllocator *allocator);
/* HeapInfo methods */
void   heap_info__init
                     (HeapInfo         *message);
size_t heap_info__get_packed_size
                     (const HeapInfo   *message);
size_t heap_info__pack
                     (const HeapInfo   *message,
                      uint8_t             *out);
size_t heap_info__pack_to_buffer
                     (const HeapInfo   *message,
                      ProtobufCBuffer     *buffer);
HeapInfo *
       heap_info__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   heap_info__free_unpacked
                     (HeapInfo *message,
                      ProtobufCAllocator *allocator);
/* ConnectedSTAList methods */
void   connected_stalist__init
                     (ConnectedSTAList         *message);
size_t connected_stalist__get_packed_size
                     (const ConnectedSTAList   *message);
size_t connected_stalist__pack
                     (const ConnectedSTAList   *message,
                      uint8_t             *out);
size_t connected_stalist__pack_to_buffer
                     (const ConnectedSTAList   *message,
                      ProtobufCBuffer     *buffer);
ConnectedSTAList *
       connected_stalist__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   connected_stalist__free_unpacked
                     (ConnectedSTAList *message,
                      ProtobufCAllocator *allocator);
/* EapFastConfig methods */
void   eap_fast_config__init
                     (EapFastConfig         *message);
size_t eap_fast_config__get_packed_size
                     (const EapFastConfig   *message);
size_t eap_fast_config__pack
                     (const EapFastConfig   *message,
                      uint8_t             *out);
size_t eap_fast_config__pack_to_buffer
                     (const EapFastConfig   *message,
                      ProtobufCBuffer     *buffer);
EapFastConfig *
       eap_fast_config__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   eap_fast_config__free_unpacked
                     (EapFastConfig *message,
                      ProtobufCAllocator *allocator);
/* RpcReqGetMacAddress methods */
void   rpc__req__get_mac_address__init
                     (RpcReqGetMacAddress         *message);
size_t rpc__req__get_mac_address__get_packed_size
                     (const RpcReqGetMacAddress   *message);
size_t rpc__req__get_mac_address__pack
                     (const RpcReqGetMacAddress   *message,
                      uint8_t             *out);
size_t rpc__req__get_mac_address__pack_to_buffer
                     (const RpcReqGetMacAddress   *message,
                      ProtobufCBuffer     *buffer);
RpcReqGetMacAddress *
       rpc__req__get_mac_address__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   rpc__req__get_mac_address__free_unpacked
                     (RpcReqGetMacAddress *message,
                      ProtobufCAllocator *allocator);
/* RpcRespGetMacAddress methods */
void   rpc__resp__get_mac_address__init
                     (RpcRespGetMacAddress         *message);
size_t rpc__resp__get_mac_address__get_packed_size
                     (const RpcRespGetMacAddress   *message);
size_t rpc__resp__get_mac_address__pack
                     (const RpcRespGetMacAddress   *message,
                      uint8_t             *out);
size_t rpc__resp__get_mac_address__pack_to_buffer
                     (const RpcRespGetMacAddress   *message,
                      ProtobufCBuffer     *buffer);
RpcRespGetMacAddress *
       rpc__resp__get_mac_address__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   rpc__resp__get_mac_address__free_unpacked
                     (RpcRespGetMacAddress *message,
                      ProtobufCAllocator *allocator);
/* RpcReqGetMode methods */
void   rpc__req__get_mode__init
                     (RpcReqGetMode         *message);
size_t rpc__req__get_mode__get_packed_size
                     (const RpcReqGetMode   *message);
size_t rpc__req__get_mode__pack
                     (const RpcReqGetMode   *message,
                      uint8_t             *out);
size_t rpc__req__get_mode__pack_to_buffer
                     (const RpcReqGetMode   *message,
                      ProtobufCBuffer     *buffer);
RpcReqGetMode *
       rpc__req__get_mode__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   rpc__req__get_mode__free_unpacked
                     (RpcReqGetMode *message,
                      ProtobufCAllocator *allocator);
/* RpcRespGetMode methods */
void   rpc__resp__get_mode__init
                     (RpcRespGetMode         *message);
size_t rpc__resp__get_mode__get_packed_size
                     (const RpcRespGetMode   *message);
size_t rpc__resp__get_mode__pack
                     (const RpcRespGetMode   *message,
                      uint8_t             *out);
size_t rpc__resp__get_mode__pack_to_buffer
                     (const RpcRespGetMode   *message,
                      ProtobufCBuffer     *buffer);
RpcRespGetMode *
       rpc__resp__get_mode__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   rpc__resp__get_mode__free_unpacked
                     (RpcRespGetMode *message,
                      ProtobufCAllocator *allocator);
/* RpcReqSetMode methods */
void   rpc__req__set_mode__init
                     (RpcReqSetMode         *message);
size_t rpc__req__set_mode__get_packed_size
                     (const RpcReqSetMode   *message);
size_t rpc__req__set_mode__pack
                     (const RpcReqSetMode   *message,
                      uint8_t             *out);
size_t rpc__req__set_mode__pack_to_buffer
                     (const RpcReqSetMode   *message,
                      ProtobufCBuffer     *buffer);
RpcReqSetMode *
       rpc__req__set_mode__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   rpc__req__set_mode__free_unpacked
                     (RpcReqSetMode *message,
                      ProtobufCAllocator *allocator);
/* RpcRespSetMode methods */
void   rpc__resp__set_mode__init
                     (RpcRespSetMode         *message);
size_t rpc__resp__set_mode__get_packed_size
                     (const RpcRespSetMode   *message);
size_t rpc__resp__set_mode__pack
                     (const RpcRespSetMode   *message,
                      uint8_t             *out);
size_t rpc__resp__set_mode__pack_to_buffer
                     (const RpcRespSetMode   *message,
                      ProtobufCBuffer     *buffer);
RpcRespSetMode *
       rpc__resp__set_mode__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   rpc__resp__set_mode__free_unpacked
                     (RpcRespSetMode *message,
                      ProtobufCAllocator *allocator);
/* RpcReqGetPs methods */
void   rpc__req__get_ps__init
                     (RpcReqGetPs         *message);
size_t rpc__req__get_ps__get_packed_size
                     (const RpcReqGetPs   *message);
size_t rpc__req__get_ps__pack
                     (const RpcReqGetPs   *message,
                      uint8_t             *out);
size_t rpc__req__get_ps__pack_to_buffer
                     (const RpcReqGetPs   *message,
                      ProtobufCBuffer     *buffer);
RpcReqGetPs *
       rpc__req__get_ps__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   rpc__req__get_ps__free_unpacked
                     (RpcReqGetPs *message,
                      ProtobufCAllocator *allocator);
/* RpcRespGetPs methods */
void   rpc__resp__get_ps__init
                     (RpcRespGetPs         *message);
size_t rpc__resp__get_ps__get_packed_size
                     (const RpcRespGetPs   *message);
size_t rpc__resp__get_ps__pack
                     (const RpcRespGetPs   *message,
                      uint8_t             *out);
size_t rpc__resp__get_ps__pack_to_buffer
                     (const RpcRespGetPs   *message,
                      ProtobufCBuffer     *buffer);
RpcRespGetPs *
       rpc__resp__get_ps__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   rpc__resp__get_ps__free_unpacked
                     (RpcRespGetPs *message,
                      ProtobufCAllocator *allocator);
/* RpcReqSetPs methods */
void   rpc__req__set_ps__init
                     (RpcReqSetPs         *message);
size_t rpc__req__set_ps__get_packed_size
                     (const RpcReqSetPs   *message);
size_t rpc__req__set_ps__pack
                     (const RpcReqSetPs   *message,
                      uint8_t             *out);
size_t rpc__req__set_ps__pack_to_buffer
                     (const RpcReqSetPs   *message,
                      ProtobufCBuffer     *buffer);
RpcReqSetPs *
       rpc__req__set_ps__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   rpc__req__set_ps__free_unpacked
                     (RpcReqSetPs *message,
                      ProtobufCAllocator *allocator);
/* RpcRespSetPs methods */
void   rpc__resp__set_ps__init
                     (RpcRespSetPs         *message);
size_t rpc__resp__set_ps__get_packed_size
                     (const RpcRespSetPs   *message);
size_t rpc__resp__set_ps__pack
                     (const RpcRespSetPs   *message,
                      uint8_t             *out);
size_t rpc__resp__set_ps__pack_to_buffer
                     (const RpcRespSetPs   *message,
                      ProtobufCBuffer     *buffer);
RpcRespSetPs *
       rpc__resp__set_ps__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   rpc__resp__set_ps__free_unpacked
                     (RpcRespSetPs *message,
                      ProtobufCAllocator *allocator);
/* RpcReqSetMacAddress methods */
void   rpc__req__set_mac_address__init
                     (RpcReqSetMacAddress         *message);
size_t rpc__req__set_mac_address__get_packed_size
                     (const RpcReqSetMacAddress   *message);
size_t rpc__req__set_mac_address__pack
                     (const RpcReqSetMacAddress   *message,
                      uint8_t             *out);
size_t rpc__req__set_mac_address__pack_to_buffer
                     (const RpcReqSetMacAddress   *message,
                      ProtobufCBuffer     *buffer);
RpcReqSetMacAddress *
       rpc__req__set_mac_address__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   rpc__req__set_mac_address__free_unpacked
                     (RpcReqSetMacAddress *message,
                      ProtobufCAllocator *allocator);
/* RpcRespSetMacAddress methods */
void   rpc__resp__set_mac_address__init
                     (RpcRespSetMacAddress         *message);
size_t rpc__resp__set_mac_address__get_packed_size
                     (const RpcRespSetMacAddress   *message);
size_t rpc__resp__set_mac_address__pack
                     (const RpcRespSetMacAddress   *message,
                      uint8_t             *out);
size_t rpc__resp__set_mac_address__pack_to_buffer
                     (const RpcRespSetMacAddress   *message,
                      ProtobufCBuffer     *buffer);
RpcRespSetMacAddress *
       rpc__resp__set_mac_address__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   rpc__resp__set_mac_address__free_unpacked
                     (RpcRespSetMacAddress *message,
                      ProtobufCAllocator *allocator);
/* RpcReqOTABegin methods */
void   rpc__req__otabegin__init
                     (RpcReqOTABegin         *message);
size_t rpc__req__otabegin__get_packed_size
                     (const RpcReqOTABegin   *message);
size_t rpc__req__otabegin__pack
                     (const RpcReqOTABegin   *message,
                      uint8_t             *out);
size_t rpc__req__otabegin__pack_to_buffer
                     (const RpcReqOTABegin   *message,
                      ProtobufCBuffer     *buffer);
RpcReqOTABegin *
       rpc__req__otabegin__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   rpc__req__otabegin__free_unpacked
                     (RpcReqOTABegin *message,
                      ProtobufCAllocator *allocator);
/* RpcRespOTABegin methods */
void   rpc__resp__otabegin__init
                     (RpcRespOTABegin         *message);
size_t rpc__resp__otabegin__get_packed_size
                     (const RpcRespOTABegin   *message);
size_t rpc__resp__otabegin__pack
                     (const RpcRespOTABegin   *message,
                      uint8_t             *out);
size_t rpc__resp__otabegin__pack_to_buffer
                     (const RpcRespOTABegin   *message,
                      ProtobufCBuffer     *buffer);
RpcRespOTABegin *
       rpc__resp__otabegin__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   rpc__resp__otabegin__free_unpacked
                     (RpcRespOTABegin *message,
                      ProtobufCAllocator *allocator);
/* RpcReqOTAWrite methods */
void   rpc__req__otawrite__init
                     (RpcReqOTAWrite         *message);
size_t rpc__req__otawrite__get_packed_size
                     (const RpcReqOTAWrite   *message);
size_t rpc__req__otawrite__pack
                     (const RpcReqOTAWrite   *message,
                      uint8_t             *out);
size_t rpc__req__otawrite__pack_to_buffer
                     (const RpcReqOTAWrite   *message,
                      ProtobufCBuffer     *buffer);
RpcReqOTAWrite *
       rpc__req__otawrite__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   rpc__req__otawrite__free_unpacked
                     (RpcReqOTAWrite *message,
                      ProtobufCAllocator *allocator);
/* RpcRespOTAWrite methods */
void   rpc__resp__otawrite__init
                     (RpcRespOTAWrite         *message);
size_t rpc__resp__otawrite__get_packed_size
                     (const RpcRespOTAWrite   *message);
size_t rpc__resp__otawrite__pack
                     (const RpcRespOTAWrite   *message,
                      uint8_t             *out);
size_t rpc__resp__otawrite__pack_to_buffer
                     (const RpcRespOTAWrite   *message,
                      ProtobufCBuffer     *buffer);
RpcRespOTAWrite *
       rpc__resp__otawrite__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   rpc__resp__otawrite__free_unpacked
                     (RpcRespOTAWrite *message,
                      ProtobufCAllocator *allocator);
/* RpcReqOTAEnd methods */
void   rpc__req__otaend__init
                     (RpcReqOTAEnd         *message);
size_t rpc__req__otaend__get_packed_size
                     (const RpcReqOTAEnd   *message);
size_t rpc__req__otaend__pack
                     (const RpcReqOTAEnd   *message,
                      uint8_t             *out);
size_t rpc__req__otaend__pack_to_buffer
                     (const RpcReqOTAEnd   *message,
                      ProtobufCBuffer     *buffer);
RpcReqOTAEnd *
       rpc__req__otaend__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   rpc__req__otaend__free_unpacked
                     (RpcReqOTAEnd *message,
                      ProtobufCAllocator *allocator);
/* RpcRespOTAEnd methods */
void   rpc__resp__otaend__init
                     (RpcRespOTAEnd         *message);
size_t rpc__resp__otaend__get_packed_size
                     (const RpcRespOTAEnd   *message);
size_t rpc__resp__otaend__pack
                     (const RpcRespOTAEnd   *message,
                      uint8_t             *out);
size_t rpc__resp__otaend__pack_to_buffer
                     (const RpcRespOTAEnd   *message,
                      ProtobufCBuffer     *buffer);
RpcRespOTAEnd *
       rpc__resp__otaend__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   rpc__resp__otaend__free_unpacked
                     (RpcRespOTAEnd *message,
                      ProtobufCAllocator *allocator);
/* RpcReqOTAActivate methods */
void   rpc__req__otaactivate__init
                     (RpcReqOTAActivate         *message);
size_t rpc__req__otaactivate__get_packed_size
                     (const RpcReqOTAActivate   *message);
size_t rpc__req__otaactivate__pack
                     (const RpcReqOTAActivate   *message,
                      uint8_t             *out);
size_t rpc__req__otaactivate__pack_to_buffer
                     (const RpcReqOTAActivate   *message,
                      ProtobufCBuffer     *buffer);
RpcReqOTAActivate *
       rpc__req__otaactivate__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   rpc__req__otaactivate__free_unpacked
                     (RpcReqOTAActivate *message,
                      ProtobufCAllocator *allocator);
/* RpcRespOTAActivate methods */
void   rpc__resp__otaactivate__init
                     (RpcRespOTAActivate         *message);
size_t rpc__resp__otaactivate__get_packed_size
                     (const RpcRespOTAActivate   *message);
size_t rpc__resp__otaactivate__pack
                     (const RpcRespOTAActivate   *message,
                      uint8_t             *out);
size_t rpc__resp__otaactivate__pack_to_buffer
                     (const RpcRespOTAActivate   *message,
                      ProtobufCBuffer     *buffer);
RpcRespOTAActivate *
       rpc__resp__otaactivate__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   rpc__resp__otaactivate__free_unpacked
                     (RpcRespOTAActivate *message,
                      ProtobufCAllocator *allocator);
/* RpcReqAppGetDesc methods */
void   rpc__req__app_get_desc__init
                     (RpcReqAppGetDesc         *message);
size_t rpc__req__app_get_desc__get_packed_size
                     (const RpcReqAppGetDesc   *message);
size_t rpc__req__app_get_desc__pack
                     (const RpcReqAppGetDesc   *message,
                      uint8_t             *out);
size_t rpc__req__app_get_desc__pack_to_buffer
                     (const RpcReqAppGetDesc   *message,
                      ProtobufCBuffer     *buffer);
RpcReqAppGetDesc *
       rpc__req__app_get_desc__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   rpc__req__app_get_desc__free_unpacked
                     (RpcReqAppGetDesc *message,
                      ProtobufCAllocator *allocator);
/* RpcRespAppGetDesc methods */
void   rpc__resp__app_get_desc__init
                     (RpcRespAppGetDesc         *message);
size_t rpc__resp__app_get_desc__get_packed_size
                     (const RpcRespAppGetDesc   *message);
size_t rpc__resp__app_get_desc__pack
                     (const RpcRespAppGetDesc   *message,
                      uint8_t             *out);
size_t rpc__resp__app_get_desc__pack_to_buffer
                     (const RpcRespAppGetDesc   *message,
                      ProtobufCBuffer     *buffer);
RpcRespAppGetDesc *
       rpc__resp__app_get_desc__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   rpc__resp__app_get_desc__free_unpacked
                     (RpcRespAppGetDesc *message,
                      ProtobufCAllocator *allocator);
/* RpcReqWifiSetMaxTxPower methods */
void   rpc__req__wifi_set_max_tx_power__init
                     (RpcReqWifiSetMaxTxPower         *message);
size_t rpc__req__wifi_set_max_tx_power__get_packed_size
                     (const RpcReqWifiSetMaxTxPower   *message);
size_t rpc__req__wifi_set_max_tx_power__pack
                     (const RpcReqWifiSetMaxTxPower   *message,
                      uint8_t             *out);
size_t rpc__req__wifi_set_max_tx_power__pack_to_buffer
                     (const RpcReqWifiSetMaxTxPower   *message,
                      ProtobufCBuffer     *buffer);
RpcReqWifiSetMaxTxPower *
       rpc__req__wifi_set_max_tx_power__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   rpc__req__wifi_set_max_tx_power__free_unpacked
                     (RpcReqWifiSetMaxTxPower *message,
                      ProtobufCAllocator *allocator);
/* RpcRespWifiSetMaxTxPower methods */
void   rpc__resp__wifi_set_max_tx_power__init
                     (RpcRespWifiSetMaxTxPower         *message);
size_t rpc__resp__wifi_set_max_tx_power__get_packed_size
                     (const RpcRespWifiSetMaxTxPower   *message);
size_t rpc__resp__wifi_set_max_tx_power__pack
                     (const RpcRespWifiSetMaxTxPower   *message,
                      uint8_t             *out);
size_t rpc__resp__wifi_set_max_tx_power__pack_to_buffer
                     (const RpcRespWifiSetMaxTxPower   *message,
                      ProtobufCBuffer     *buffer);
RpcRespWifiSetMaxTxPower *
       rpc__resp__wifi_set_max_tx_power__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   rpc__resp__wifi_set_max_tx_power__free_unpacked
                     (RpcRespWifiSetMaxTxPower *message,
                      ProtobufCAllocator *allocator);
/* RpcReqWifiGetMaxTxPower methods */
void   rpc__req__wifi_get_max_tx_power__init
                     (RpcReqWifiGetMaxTxPower         *message);
size_t rpc__req__wifi_get_max_tx_power__get_packed_size
                     (const RpcReqWifiGetMaxTxPower   *message);
size_t rpc__req__wifi_get_max_tx_power__pack
                     (const RpcReqWifiGetMaxTxPower   *message,
                      uint8_t             *out);
size_t rpc__req__wifi_get_max_tx_power__pack_to_buffer
                     (const RpcReqWifiGetMaxTxPower   *message,
                      ProtobufCBuffer     *buffer);
RpcReqWifiGetMaxTxPower *
       rpc__req__wifi_get_max_tx_power__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   rpc__req__wifi_get_max_tx_power__free_unpacked
                     (RpcReqWifiGetMaxTxPower *message,
                      ProtobufCAllocator *allocator);
/* RpcRespWifiGetMaxTxPower methods */
void   rpc__resp__wifi_get_max_tx_power__init
                     (RpcRespWifiGetMaxTxPower         *message);
size_t rpc__resp__wifi_get_max_tx_power__get_packed_size
                     (const RpcRespWifiGetMaxTxPower   *message);
size_t rpc__resp__wifi_get_max_tx_power__pack
                     (const RpcRespWifiGetMaxTxPower   *message,
                      uint8_t             *out);
size_t rpc__resp__wifi_get_max_tx_power__pack_to_buffer
                     (const RpcRespWifiGetMaxTxPower   *message,
                      ProtobufCBuffer     *buffer);
RpcRespWifiGetMaxTxPower *
       rpc__resp__wifi_get_max_tx_power__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   rpc__resp__wifi_get_max_tx_power__free_unpacked
                     (RpcRespWifiGetMaxTxPower *message,
                      ProtobufCAllocator *allocator);
/* RpcReqConfigHeartbeat methods */
void   rpc__req__config_heartbeat__init
                     (RpcReqConfigHeartbeat         *message);
size_t rpc__req__config_heartbeat__get_packed_size
                     (const RpcReqConfigHeartbeat   *message);
size_t rpc__req__config_heartbeat__pack
                     (const RpcReqConfigHeartbeat   *message,
                      uint8_t             *out);
size_t rpc__req__config_heartbeat__pack_to_buffer
                     (const RpcReqConfigHeartbeat   *message,
                      ProtobufCBuffer     *buffer);
RpcReqConfigHeartbeat *
       rpc__req__config_heartbeat__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   rpc__req__config_heartbeat__free_unpacked
                     (RpcReqConfigHeartbeat *message,
                      ProtobufCAllocator *allocator);
/* RpcRespConfigHeartbeat methods */
void   rpc__resp__config_heartbeat__init
                     (RpcRespConfigHeartbeat         *message);
size_t rpc__resp__config_heartbeat__get_packed_size
                     (const RpcRespConfigHeartbeat   *message);
size_t rpc__resp__config_heartbeat__pack
                     (const RpcRespConfigHeartbeat   *message,
                      uint8_t             *out);
size_t rpc__resp__config_heartbeat__pack_to_buffer
                     (const RpcRespConfigHeartbeat   *message,
                      ProtobufCBuffer     *buffer);
RpcRespConfigHeartbeat *
       rpc__resp__config_heartbeat__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   rpc__resp__config_heartbeat__free_unpacked
                     (RpcRespConfigHeartbeat *message,
                      ProtobufCAllocator *allocator);
/* RpcReqWifiInit methods */
void   rpc__req__wifi_init__init
                     (RpcReqWifiInit         *message);
size_t rpc__req__wifi_init__get_packed_size
                     (const RpcReqWifiInit   *message);
size_t rpc__req__wifi_init__pack
                     (const RpcReqWifiInit   *message,
                      uint8_t             *out);
size_t rpc__req__wifi_init__pack_to_buffer
                     (const RpcReqWifiInit   *message,
                      ProtobufCBuffer     *buffer);
RpcReqWifiInit *
       rpc__req__wifi_init__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   rpc__req__wifi_init__free_unpacked
                     (RpcReqWifiInit *message,
                      ProtobufCAllocator *allocator);
/* RpcRespWifiInit methods */
void   rpc__resp__wifi_init__init
                     (RpcRespWifiInit         *message);
size_t rpc__resp__wifi_init__get_packed_size
                     (const RpcRespWifiInit   *message);
size_t rpc__resp__wifi_init__pack
                     (const RpcRespWifiInit   *message,
                      uint8_t             *out);
size_t rpc__resp__wifi_init__pack_to_buffer
                     (const RpcRespWifiInit   *message,
                      ProtobufCBuffer     *buffer);
RpcRespWifiInit *
       rpc__resp__wifi_init__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   rpc__resp__wifi_init__free_unpacked
                     (RpcRespWifiInit *message,
                      ProtobufCAllocator *allocator);
/* RpcReqWifiDeinit methods */
void   rpc__req__wifi_deinit__init
                     (RpcReqWifiDeinit         *message);
size_t rpc__req__wifi_deinit__get_packed_size
                     (const RpcReqWifiDeinit   *message);
size_t rpc__req__wifi_deinit__pack
                     (const RpcReqWifiDeinit   *message,
                      uint8_t             *out);
size_t rpc__req__wifi_deinit__pack_to_buffer
                     (const RpcReqWifiDeinit   *message,
                      ProtobufCBuffer     *buffer);
RpcReqWifiDeinit *
       rpc__req__wifi_deinit__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   rpc__req__wifi_deinit__free_unpacked
                     (RpcReqWifiDeinit *message,
                      ProtobufCAllocator *allocator);
/* RpcRespWifiDeinit methods */
void   rpc__resp__wifi_deinit__init
                     (RpcRespWifiDeinit         *message);
size_t rpc__resp__wifi_deinit__get_packed_size
                     (const RpcRespWifiDeinit   *message);
size_t rpc__resp__wifi_deinit__pack
                     (const RpcRespWifiDeinit   *message,
                      uint8_t             *out);
size_t rpc__resp__wifi_deinit__pack_to_buffer
                     (const RpcRespWifiDeinit   *message,
                      ProtobufCBuffer     *buffer);
RpcRespWifiDeinit *
       rpc__resp__wifi_deinit__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   rpc__resp__wifi_deinit__free_unpacked
                     (RpcRespWifiDeinit *message,
                      ProtobufCAllocator *allocator);
/* RpcReqWifiSetConfig methods */
void   rpc__req__wifi_set_config__init
                     (RpcReqWifiSetConfig         *message);
size_t rpc__req__wifi_set_config__get_packed_size
                     (const RpcReqWifiSetConfig   *message);
size_t rpc__req__wifi_set_config__pack
                     (const RpcReqWifiSetConfig   *message,
                      uint8_t             *out);
size_t rpc__req__wifi_set_config__pack_to_buffer
                     (const RpcReqWifiSetConfig   *message,
                      ProtobufCBuffer     *buffer);
RpcReqWifiSetConfig *
       rpc__req__wifi_set_config__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   rpc__req__wifi_set_config__free_unpacked
                     (RpcReqWifiSetConfig *message,
                      ProtobufCAllocator *allocator);
/* RpcRespWifiSetConfig methods */
void   rpc__resp__wifi_set_config__init
                     (RpcRespWifiSetConfig         *message);
size_t rpc__resp__wifi_set_config__get_packed_size
                     (const RpcRespWifiSetConfig   *message);
size_t rpc__resp__wifi_set_config__pack
                     (const RpcRespWifiSetConfig   *message,
                      uint8_t             *out);
size_t rpc__resp__wifi_set_config__pack_to_buffer
                     (const RpcRespWifiSetConfig   *message,
                      ProtobufCBuffer     *buffer);
RpcRespWifiSetConfig *
       rpc__resp__wifi_set_config__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   rpc__resp__wifi_set_config__free_unpacked
                     (RpcRespWifiSetConfig *message,
                      ProtobufCAllocator *allocator);
/* RpcReqWifiGetConfig methods */
void   rpc__req__wifi_get_config__init
                     (RpcReqWifiGetConfig         *message);
size_t rpc__req__wifi_get_config__get_packed_size
                     (const RpcReqWifiGetConfig   *message);
size_t rpc__req__wifi_get_config__pack
                     (const RpcReqWifiGetConfig   *message,
                      uint8_t             *out);
size_t rpc__req__wifi_get_config__pack_to_buffer
                     (const RpcReqWifiGetConfig   *message,
                      ProtobufCBuffer     *buffer);
RpcReqWifiGetConfig *
       rpc__req__wifi_get_config__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   rpc__req__wifi_get_config__free_unpacked
                     (RpcReqWifiGetConfig *message,
                      ProtobufCAllocator *allocator);
/* RpcRespWifiGetConfig methods */
void   rpc__resp__wifi_get_config__init
                     (RpcRespWifiGetConfig         *message);
size_t rpc__resp__wifi_get_config__get_packed_size
                     (const RpcRespWifiGetConfig   *message);
size_t rpc__resp__wifi_get_config__pack
                     (const RpcRespWifiGetConfig   *message,
                      uint8_t             *out);
size_t rpc__resp__wifi_get_config__pack_to_buffer
                     (const RpcRespWifiGetConfig   *message,
                      ProtobufCBuffer     *buffer);
RpcRespWifiGetConfig *
       rpc__resp__wifi_get_config__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   rpc__resp__wifi_get_config__free_unpacked
                     (RpcRespWifiGetConfig *message,
                      ProtobufCAllocator *allocator);
/* RpcReqWifiConnect methods */
void   rpc__req__wifi_connect__init
                     (RpcReqWifiConnect         *message);
size_t rpc__req__wifi_connect__get_packed_size
                     (const RpcReqWifiConnect   *message);
size_t rpc__req__wifi_connect__pack
                     (const RpcReqWifiConnect   *message,
                      uint8_t             *out);
size_t rpc__req__wifi_connect__pack_to_buffer
                     (const RpcReqWifiConnect   *message,
                      ProtobufCBuffer     *buffer);
RpcReqWifiConnect *
       rpc__req__wifi_connect__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   rpc__req__wifi_connect__free_unpacked
                     (RpcReqWifiConnect *message,
                      ProtobufCAllocator *allocator);
/* RpcRespWifiConnect methods */
void   rpc__resp__wifi_connect__init
                     (RpcRespWifiConnect         *message);
size_t rpc__resp__wifi_connect__get_packed_size
                     (const RpcRespWifiConnect   *message);
size_t rpc__resp__wifi_connect__pack
                     (const RpcRespWifiConnect   *message,
                      uint8_t             *out);
size_t rpc__resp__wifi_connect__pack_to_buffer
                     (const RpcRespWifiConnect   *message,
                      ProtobufCBuffer     *buffer);
RpcRespWifiConnect *
       rpc__resp__wifi_connect__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   rpc__resp__wifi_connect__free_unpacked
                     (RpcRespWifiConnect *message,
                      ProtobufCAllocator *allocator);
/* RpcReqWifiDisconnect methods */
void   rpc__req__wifi_disconnect__init
                     (RpcReqWifiDisconnect         *message);
size_t rpc__req__wifi_disconnect__get_packed_size
                     (const RpcReqWifiDisconnect   *message);
size_t rpc__req__wifi_disconnect__pack
                     (const RpcReqWifiDisconnect   *message,
                      uint8_t             *out);
size_t rpc__req__wifi_disconnect__pack_to_buffer
                     (const RpcReqWifiDisconnect   *message,
                      ProtobufCBuffer     *buffer);
RpcReqWifiDisconnect *
       rpc__req__wifi_disconnect__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   rpc__req__wifi_disconnect__free_unpacked
                     (RpcReqWifiDisconnect *message,
                      ProtobufCAllocator *allocator);
/* RpcRespWifiDisconnect methods */
void   rpc__resp__wifi_disconnect__init
                     (RpcRespWifiDisconnect         *message);
size_t rpc__resp__wifi_disconnect__get_packed_size
                     (const RpcRespWifiDisconnect   *message);
size_t rpc__resp__wifi_disconnect__pack
                     (const RpcRespWifiDisconnect   *message,
                      uint8_t             *out);
size_t rpc__resp__wifi_disconnect__pack_to_buffer
                     (const RpcRespWifiDisconnect   *message,
                      ProtobufCBuffer     *buffer);
RpcRespWifiDisconnect *
       rpc__resp__wifi_disconnect__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   rpc__resp__wifi_disconnect__free_unpacked
                     (RpcRespWifiDisconnect *message,
                      ProtobufCAllocator *allocator);
/* RpcReqWifiStart methods */
void   rpc__req__wifi_start__init
                     (RpcReqWifiStart         *message);
size_t rpc__req__wifi_start__get_packed_size
                     (const RpcReqWifiStart   *message);
size_t rpc__req__wifi_start__pack
                     (const RpcReqWifiStart   *message,
                      uint8_t             *out);
size_t rpc__req__wifi_start__pack_to_buffer
                     (const RpcReqWifiStart   *message,
                      ProtobufCBuffer     *buffer);
RpcReqWifiStart *
       rpc__req__wifi_start__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   rpc__req__wifi_start__free_unpacked
                     (RpcReqWifiStart *message,
                      ProtobufCAllocator *allocator);
/* RpcRespWifiStart methods */
void   rpc__resp__wifi_start__init
                     (RpcRespWifiStart         *message);
size_t rpc__resp__wifi_start__get_packed_size
                     (const RpcRespWifiStart   *message);
size_t rpc__resp__wifi_start__pack
                     (const RpcRespWifiStart   *message,
                      uint8_t             *out);
size_t rpc__resp__wifi_start__pack_to_buffer
                     (const RpcRespWifiStart   *message,
                      ProtobufCBuffer     *buffer);
RpcRespWifiStart *
       rpc__resp__wifi_start__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   rpc__resp__wifi_start__free_unpacked
                     (RpcRespWifiStart *message,
                      ProtobufCAllocator *allocator);
/* RpcReqWifiStop methods */
void   rpc__req__wifi_stop__init
                     (RpcReqWifiStop         *message);
size_t rpc__req__wifi_stop__get_packed_size
                     (const RpcReqWifiStop   *message);
size_t rpc__req__wifi_stop__pack
                     (const RpcReqWifiStop   *message,
                      uint8_t             *out);
size_t rpc__req__wifi_stop__pack_to_buffer
                     (const RpcReqWifiStop   *message,
                      ProtobufCBuffer     *buffer);
RpcReqWifiStop *
       rpc__req__wifi_stop__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   rpc__req__wifi_stop__free_unpacked
                     (RpcReqWifiStop *message,
                      ProtobufCAllocator *allocator);
/* RpcRespWifiStop methods */
void   rpc__resp__wifi_stop__init
                     (RpcRespWifiStop         *message);
size_t rpc__resp__wifi_stop__get_packed_size
                     (const RpcRespWifiStop   *message);
size_t rpc__resp__wifi_stop__pack
                     (const RpcRespWifiStop   *message,
                      uint8_t             *out);
size_t rpc__resp__wifi_stop__pack_to_buffer
                     (const RpcRespWifiStop   *message,
                      ProtobufCBuffer     *buffer);
RpcRespWifiStop *
       rpc__resp__wifi_stop__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   rpc__resp__wifi_stop__free_unpacked
                     (RpcRespWifiStop *message,
                      ProtobufCAllocator *allocator);
/* RpcReqWifiScanStart methods */
void   rpc__req__wifi_scan_start__init
                     (RpcReqWifiScanStart         *message);
size_t rpc__req__wifi_scan_start__get_packed_size
                     (const RpcReqWifiScanStart   *message);
size_t rpc__req__wifi_scan_start__pack
                     (const RpcReqWifiScanStart   *message,
                      uint8_t             *out);
size_t rpc__req__wifi_scan_start__pack_to_buffer
                     (const RpcReqWifiScanStart   *message,
                      ProtobufCBuffer     *buffer);
RpcReqWifiScanStart *
       rpc__req__wifi_scan_start__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   rpc__req__wifi_scan_start__free_unpacked
                     (RpcReqWifiScanStart *message,
                      ProtobufCAllocator *allocator);
/* RpcRespWifiScanStart methods */
void   rpc__resp__wifi_scan_start__init
                     (RpcRespWifiScanStart         *message);
size_t rpc__resp__wifi_scan_start__get_packed_size
                     (const RpcRespWifiScanStart   *message);
size_t rpc__resp__wifi_scan_start__pack
                     (const RpcRespWifiScanStart   *message,
                      uint8_t             *out);
size_t rpc__resp__wifi_scan_start__pack_to_buffer
                     (const RpcRespWifiScanStart   *message,
                      ProtobufCBuffer     *buffer);
RpcRespWifiScanStart *
       rpc__resp__wifi_scan_start__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   rpc__resp__wifi_scan_start__free_unpacked
                     (RpcRespWifiScanStart *message,
                      ProtobufCAllocator *allocator);
/* RpcReqWifiScanStop methods */
void   rpc__req__wifi_scan_stop__init
                     (RpcReqWifiScanStop         *message);
size_t rpc__req__wifi_scan_stop__get_packed_size
                     (const RpcReqWifiScanStop   *message);
size_t rpc__req__wifi_scan_stop__pack
                     (const RpcReqWifiScanStop   *message,
                      uint8_t             *out);
size_t rpc__req__wifi_scan_stop__pack_to_buffer
                     (const RpcReqWifiScanStop   *message,
                      ProtobufCBuffer     *buffer);
RpcReqWifiScanStop *
       rpc__req__wifi_scan_stop__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   rpc__req__wifi_scan_stop__free_unpacked
                     (RpcReqWifiScanStop *message,
                      ProtobufCAllocator *allocator);
/* RpcRespWifiScanStop methods */
void   rpc__resp__wifi_scan_stop__init
                     (RpcRespWifiScanStop         *message);
size_t rpc__resp__wifi_scan_stop__get_packed_size
                     (const RpcRespWifiScanStop   *message);
size_t rpc__resp__wifi_scan_stop__pack
                     (const RpcRespWifiScanStop   *message,
                      uint8_t             *out);
size_t rpc__resp__wifi_scan_stop__pack_to_buffer
                     (const RpcRespWifiScanStop   *message,
                      ProtobufCBuffer     *buffer);
RpcRespWifiScanStop *
       rpc__resp__wifi_scan_stop__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   rpc__resp__wifi_scan_stop__free_unpacked
                     (RpcRespWifiScanStop *message,
                      ProtobufCAllocator *allocator);
/* RpcReqWifiScanGetApNum methods */
void   rpc__req__wifi_scan_get_ap_num__init
                     (RpcReqWifiScanGetApNum         *message);
size_t rpc__req__wifi_scan_get_ap_num__get_packed_size
                     (const RpcReqWifiScanGetApNum   *message);
size_t rpc__req__wifi_scan_get_ap_num__pack
                     (const RpcReqWifiScanGetApNum   *message,
                      uint8_t             *out);
size_t rpc__req__wifi_scan_get_ap_num__pack_to_buffer
                     (const RpcReqWifiScanGetApNum   *message,
                      ProtobufCBuffer     *buffer);
RpcReqWifiScanGetApNum *
       rpc__req__wifi_scan_get_ap_num__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   rpc__req__wifi_scan_get_ap_num__free_unpacked
                     (RpcReqWifiScanGetApNum *message,
                      ProtobufCAllocator *allocator);
/* RpcRespWifiScanGetApNum methods */
void   rpc__resp__wifi_scan_get_ap_num__init
                     (RpcRespWifiScanGetApNum         *message);
size_t rpc__resp__wifi_scan_get_ap_num__get_packed_size
                     (const RpcRespWifiScanGetApNum   *message);
size_t rpc__resp__wifi_scan_get_ap_num__pack
                     (const RpcRespWifiScanGetApNum   *message,
                      uint8_t             *out);
size_t rpc__resp__wifi_scan_get_ap_num__pack_to_buffer
                     (const RpcRespWifiScanGetApNum   *message,
                      ProtobufCBuffer     *buffer);
RpcRespWifiScanGetApNum *
       rpc__resp__wifi_scan_get_ap_num__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   rpc__resp__wifi_scan_get_ap_num__free_unpacked
                     (RpcRespWifiScanGetApNum *message,
                      ProtobufCAllocator *allocator);
/* RpcReqWifiScanGetApRecords methods */
void   rpc__req__wifi_scan_get_ap_records__init
                     (RpcReqWifiScanGetApRecords         *message);
size_t rpc__req__wifi_scan_get_ap_records__get_packed_size
                     (const RpcReqWifiScanGetApRecords   *message);
size_t rpc__req__wifi_scan_get_ap_records__pack
                     (const RpcReqWifiScanGetApRecords   *message,
                      uint8_t             *out);
size_t rpc__req__wifi_scan_get_ap_records__pack_to_buffer
                     (const RpcReqWifiScanGetApRecords   *message,
                      ProtobufCBuffer     *buffer);
RpcReqWifiScanGetApRecords *
       rpc__req__wifi_scan_get_ap_records__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   rpc__req__wifi_scan_get_ap_records__free_unpacked
                     (RpcReqWifiScanGetApRecords *message,
                      ProtobufCAllocator *allocator);
/* RpcRespWifiScanGetApRecords methods */
void   rpc__resp__wifi_scan_get_ap_records__init
                     (RpcRespWifiScanGetApRecords         *message);
size_t rpc__resp__wifi_scan_get_ap_records__get_packed_size
                     (const RpcRespWifiScanGetApRecords   *message);
size_t rpc__resp__wifi_scan_get_ap_records__pack
                     (const RpcRespWifiScanGetApRecords   *message,
                      uint8_t             *out);
size_t rpc__resp__wifi_scan_get_ap_records__pack_to_buffer
                     (const RpcRespWifiScanGetApRecords   *message,
                      ProtobufCBuffer     *buffer);
RpcRespWifiScanGetApRecords *
       rpc__resp__wifi_scan_get_ap_records__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   rpc__resp__wifi_scan_get_ap_records__free_unpacked
                     (RpcRespWifiScanGetApRecords *message,
                      ProtobufCAllocator *allocator);
/* RpcReqWifiScanGetApRecord methods */
void   rpc__req__wifi_scan_get_ap_record__init
                     (RpcReqWifiScanGetApRecord         *message);
size_t rpc__req__wifi_scan_get_ap_record__get_packed_size
                     (const RpcReqWifiScanGetApRecord   *message);
size_t rpc__req__wifi_scan_get_ap_record__pack
                     (const RpcReqWifiScanGetApRecord   *message,
                      uint8_t             *out);
size_t rpc__req__wifi_scan_get_ap_record__pack_to_buffer
                     (const RpcReqWifiScanGetApRecord   *message,
                      ProtobufCBuffer     *buffer);
RpcReqWifiScanGetApRecord *
       rpc__req__wifi_scan_get_ap_record__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   rpc__req__wifi_scan_get_ap_record__free_unpacked
                     (RpcReqWifiScanGetApRecord *message,
                      ProtobufCAllocator *allocator);
/* RpcRespWifiScanGetApRecord methods */
void   rpc__resp__wifi_scan_get_ap_record__init
                     (RpcRespWifiScanGetApRecord         *message);
size_t rpc__resp__wifi_scan_get_ap_record__get_packed_size
                     (const RpcRespWifiScanGetApRecord   *message);
size_t rpc__resp__wifi_scan_get_ap_record__pack
                     (const RpcRespWifiScanGetApRecord   *message,
                      uint8_t             *out);
size_t rpc__resp__wifi_scan_get_ap_record__pack_to_buffer
                     (const RpcRespWifiScanGetApRecord   *message,
                      ProtobufCBuffer     *buffer);
RpcRespWifiScanGetApRecord *
       rpc__resp__wifi_scan_get_ap_record__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   rpc__resp__wifi_scan_get_ap_record__free_unpacked
                     (RpcRespWifiScanGetApRecord *message,
                      ProtobufCAllocator *allocator);
/* RpcReqWifiClearApList methods */
void   rpc__req__wifi_clear_ap_list__init
                     (RpcReqWifiClearApList         *message);
size_t rpc__req__wifi_clear_ap_list__get_packed_size
                     (const RpcReqWifiClearApList   *message);
size_t rpc__req__wifi_clear_ap_list__pack
                     (const RpcReqWifiClearApList   *message,
                      uint8_t             *out);
size_t rpc__req__wifi_clear_ap_list__pack_to_buffer
                     (const RpcReqWifiClearApList   *message,
                      ProtobufCBuffer     *buffer);
RpcReqWifiClearApList *
       rpc__req__wifi_clear_ap_list__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   rpc__req__wifi_clear_ap_list__free_unpacked
                     (RpcReqWifiClearApList *message,
                      ProtobufCAllocator *allocator);
/* RpcRespWifiClearApList methods */
void   rpc__resp__wifi_clear_ap_list__init
                     (RpcRespWifiClearApList         *message);
size_t rpc__resp__wifi_clear_ap_list__get_packed_size
                     (const RpcRespWifiClearApList   *message);
size_t rpc__resp__wifi_clear_ap_list__pack
                     (const RpcRespWifiClearApList   *message,
                      uint8_t             *out);
size_t rpc__resp__wifi_clear_ap_list__pack_to_buffer
                     (const RpcRespWifiClearApList   *message,
                      ProtobufCBuffer     *buffer);
RpcRespWifiClearApList *
       rpc__resp__wifi_clear_ap_list__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   rpc__resp__wifi_clear_ap_list__free_unpacked
                     (RpcRespWifiClearApList *message,
                      ProtobufCAllocator *allocator);
/* RpcReqWifiRestore methods */
void   rpc__req__wifi_restore__init
                     (RpcReqWifiRestore         *message);
size_t rpc__req__wifi_restore__get_packed_size
                     (const RpcReqWifiRestore   *message);
size_t rpc__req__wifi_restore__pack
                     (const RpcReqWifiRestore   *message,
                      uint8_t             *out);
size_t rpc__req__wifi_restore__pack_to_buffer
                     (const RpcReqWifiRestore   *message,
                      ProtobufCBuffer     *buffer);
RpcReqWifiRestore *
       rpc__req__wifi_restore__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   rpc__req__wifi_restore__free_unpacked
                     (RpcReqWifiRestore *message,
                      ProtobufCAllocator *allocator);
/* RpcRespWifiRestore methods */
void   rpc__resp__wifi_restore__init
                     (RpcRespWifiRestore         *message);
size_t rpc__resp__wifi_restore__get_packed_size
                     (const RpcRespWifiRestore   *message);
size_t rpc__resp__wifi_restore__pack
                     (const RpcRespWifiRestore   *message,
                      uint8_t             *out);
size_t rpc__resp__wifi_restore__pack_to_buffer
                     (const RpcRespWifiRestore   *message,
                      ProtobufCBuffer     *buffer);
RpcRespWifiRestore *
       rpc__resp__wifi_restore__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   rpc__resp__wifi_restore__free_unpacked
                     (RpcRespWifiRestore *message,
                      ProtobufCAllocator *allocator);
/* RpcReqWifiClearFastConnect methods */
void   rpc__req__wifi_clear_fast_connect__init
                     (RpcReqWifiClearFastConnect         *message);
size_t rpc__req__wifi_clear_fast_connect__get_packed_size
                     (const RpcReqWifiClearFastConnect   *message);
size_t rpc__req__wifi_clear_fast_connect__pack
                     (const RpcReqWifiClearFastConnect   *message,
                      uint8_t             *out);
size_t rpc__req__wifi_clear_fast_connect__pack_to_buffer
                     (const RpcReqWifiClearFastConnect   *message,
                      ProtobufCBuffer     *buffer);
RpcReqWifiClearFastConnect *
       rpc__req__wifi_clear_fast_connect__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   rpc__req__wifi_clear_fast_connect__free_unpacked
                     (RpcReqWifiClearFastConnect *message,
                      ProtobufCAllocator *allocator);
/* RpcRespWifiClearFastConnect methods */
void   rpc__resp__wifi_clear_fast_connect__init
                     (RpcRespWifiClearFastConnect         *message);
size_t rpc__resp__wifi_clear_fast_connect__get_packed_size
                     (const RpcRespWifiClearFastConnect   *message);
size_t rpc__resp__wifi_clear_fast_connect__pack
                     (const RpcRespWifiClearFastConnect   *message,
                      uint8_t             *out);
size_t rpc__resp__wifi_clear_fast_connect__pack_to_buffer
                     (const RpcRespWifiClearFastConnect   *message,
                      ProtobufCBuffer     *buffer);
RpcRespWifiClearFastConnect *
       rpc__resp__wifi_clear_fast_connect__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   rpc__resp__wifi_clear_fast_connect__free_unpacked
                     (RpcRespWifiClearFastConnect *message,
                      ProtobufCAllocator *allocator);
/* RpcReqWifiDeauthSta methods */
void   rpc__req__wifi_deauth_sta__init
                     (RpcReqWifiDeauthSta         *message);
size_t rpc__req__wifi_deauth_sta__get_packed_size
                     (const RpcReqWifiDeauthSta   *message);
size_t rpc__req__wifi_deauth_sta__pack
                     (const RpcReqWifiDeauthSta   *message,
                      uint8_t             *out);
size_t rpc__req__wifi_deauth_sta__pack_to_buffer
                     (const RpcReqWifiDeauthSta   *message,
                      ProtobufCBuffer     *buffer);
RpcReqWifiDeauthSta *
       rpc__req__wifi_deauth_sta__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   rpc__req__wifi_deauth_sta__free_unpacked
                     (RpcReqWifiDeauthSta *message,
                      ProtobufCAllocator *allocator);
/* RpcRespWifiDeauthSta methods */
void   rpc__resp__wifi_deauth_sta__init
                     (RpcRespWifiDeauthSta         *message);
size_t rpc__resp__wifi_deauth_sta__get_packed_size
                     (const RpcRespWifiDeauthSta   *message);
size_t rpc__resp__wifi_deauth_sta__pack
                     (const RpcRespWifiDeauthSta   *message,
                      uint8_t             *out);
size_t rpc__resp__wifi_deauth_sta__pack_to_buffer
                     (const RpcRespWifiDeauthSta   *message,
                      ProtobufCBuffer     *buffer);
RpcRespWifiDeauthSta *
       rpc__resp__wifi_deauth_sta__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   rpc__resp__wifi_deauth_sta__free_unpacked
                     (RpcRespWifiDeauthSta *message,
                      ProtobufCAllocator *allocator);
/* RpcReqWifiStaGetApInfo methods */
void   rpc__req__wifi_sta_get_ap_info__init
                     (RpcReqWifiStaGetApInfo         *message);
size_t rpc__req__wifi_sta_get_ap_info__get_packed_size
                     (const RpcReqWifiStaGetApInfo   *message);
size_t rpc__req__wifi_sta_get_ap_info__pack
                     (const RpcReqWifiStaGetApInfo   *message,
                      uint8_t             *out);
size_t rpc__req__wifi_sta_get_ap_info__pack_to_buffer
                     (const RpcReqWifiStaGetApInfo   *message,
                      ProtobufCBuffer     *buffer);
RpcReqWifiStaGetApInfo *
       rpc__req__wifi_sta_get_ap_info__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   rpc__req__wifi_sta_get_ap_info__free_unpacked
                     (RpcReqWifiStaGetApInfo *message,
                      ProtobufCAllocator *allocator);
/* RpcRespWifiStaGetApInfo methods */
void   rpc__resp__wifi_sta_get_ap_info__init
                     (RpcRespWifiStaGetApInfo         *message);
size_t rpc__resp__wifi_sta_get_ap_info__get_packed_size
                     (const RpcRespWifiStaGetApInfo   *message);
size_t rpc__resp__wifi_sta_get_ap_info__pack
                     (const RpcRespWifiStaGetApInfo   *message,
                      uint8_t             *out);
size_t rpc__resp__wifi_sta_get_ap_info__pack_to_buffer
                     (const RpcRespWifiStaGetApInfo   *message,
                      ProtobufCBuffer     *buffer);
RpcRespWifiStaGetApInfo *
       rpc__resp__wifi_sta_get_ap_info__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   rpc__resp__wifi_sta_get_ap_info__free_unpacked
                     (RpcRespWifiStaGetApInfo *message,
                      ProtobufCAllocator *allocator);
/* RpcReqWifiSetProtocol methods */
void   rpc__req__wifi_set_protocol__init
                     (RpcReqWifiSetProtocol         *message);
size_t rpc__req__wifi_set_protocol__get_packed_size
                     (const RpcReqWifiSetProtocol   *message);
size_t rpc__req__wifi_set_protocol__pack
                     (const RpcReqWifiSetProtocol   *message,
                      uint8_t             *out);
size_t rpc__req__wifi_set_protocol__pack_to_buffer
                     (const RpcReqWifiSetProtocol   *message,
                      ProtobufCBuffer     *buffer);
RpcReqWifiSetProtocol *
       rpc__req__wifi_set_protocol__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   rpc__req__wifi_set_protocol__free_unpacked
                     (RpcReqWifiSetProtocol *message,
                      ProtobufCAllocator *allocator);
/* RpcRespWifiSetProtocol methods */
void   rpc__resp__wifi_set_protocol__init
                     (RpcRespWifiSetProtocol         *message);
size_t rpc__resp__wifi_set_protocol__get_packed_size
                     (const RpcRespWifiSetProtocol   *message);
size_t rpc__resp__wifi_set_protocol__pack
                     (const RpcRespWifiSetProtocol   *message,
                      uint8_t             *out);
size_t rpc__resp__wifi_set_protocol__pack_to_buffer
                     (const RpcRespWifiSetProtocol   *message,
                      ProtobufCBuffer     *buffer);
RpcRespWifiSetProtocol *
       rpc__resp__wifi_set_protocol__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   rpc__resp__wifi_set_protocol__free_unpacked
                     (RpcRespWifiSetProtocol *message,
                      ProtobufCAllocator *allocator);
/* RpcReqWifiGetProtocol methods */
void   rpc__req__wifi_get_protocol__init
                     (RpcReqWifiGetProtocol         *message);
size_t rpc__req__wifi_get_protocol__get_packed_size
                     (const RpcReqWifiGetProtocol   *message);
size_t rpc__req__wifi_get_protocol__pack
                     (const RpcReqWifiGetProtocol   *message,
                      uint8_t             *out);
size_t rpc__req__wifi_get_protocol__pack_to_buffer
                     (const RpcReqWifiGetProtocol   *message,
                      ProtobufCBuffer     *buffer);
RpcReqWifiGetProtocol *
       rpc__req__wifi_get_protocol__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   rpc__req__wifi_get_protocol__free_unpacked
                     (RpcReqWifiGetProtocol *message,
                      ProtobufCAllocator *allocator);
/* RpcRespWifiGetProtocol methods */
void   rpc__resp__wifi_get_protocol__init
                     (RpcRespWifiGetProtocol         *message);
size_t rpc__resp__wifi_get_protocol__get_packed_size
                     (const RpcRespWifiGetProtocol   *message);
size_t rpc__resp__wifi_get_protocol__pack
                     (const RpcRespWifiGetProtocol   *message,
                      uint8_t             *out);
size_t rpc__resp__wifi_get_protocol__pack_to_buffer
                     (const RpcRespWifiGetProtocol   *message,
                      ProtobufCBuffer     *buffer);
RpcRespWifiGetProtocol *
       rpc__resp__wifi_get_protocol__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   rpc__resp__wifi_get_protocol__free_unpacked
                     (RpcRespWifiGetProtocol *message,
                      ProtobufCAllocator *allocator);
/* RpcReqWifiSetBandwidth methods */
void   rpc__req__wifi_set_bandwidth__init
                     (RpcReqWifiSetBandwidth         *message);
size_t rpc__req__wifi_set_bandwidth__get_packed_size
                     (const RpcReqWifiSetBandwidth   *message);
size_t rpc__req__wifi_set_bandwidth__pack
                     (const RpcReqWifiSetBandwidth   *message,
                      uint8_t             *out);
size_t rpc__req__wifi_set_bandwidth__pack_to_buffer
                     (const RpcReqWifiSetBandwidth   *message,
                      ProtobufCBuffer     *buffer);
RpcReqWifiSetBandwidth *
       rpc__req__wifi_set_bandwidth__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   rpc__req__wifi_set_bandwidth__free_unpacked
                     (RpcReqWifiSetBandwidth *message,
                      ProtobufCAllocator *allocator);
/* RpcRespWifiSetBandwidth methods */
void   rpc__resp__wifi_set_bandwidth__init
                     (RpcRespWifiSetBandwidth         *message);
size_t rpc__resp__wifi_set_bandwidth__get_packed_size
                     (const RpcRespWifiSetBandwidth   *message);
size_t rpc__resp__wifi_set_bandwidth__pack
                     (const RpcRespWifiSetBandwidth   *message,
                      uint8_t             *out);
size_t rpc__resp__wifi_set_bandwidth__pack_to_buffer
                     (const RpcRespWifiSetBandwidth   *message,
                      ProtobufCBuffer     *buffer);
RpcRespWifiSetBandwidth *
       rpc__resp__wifi_set_bandwidth__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   rpc__resp__wifi_set_bandwidth__free_unpacked
                     (RpcRespWifiSetBandwidth *message,
                      ProtobufCAllocator *allocator);
/* RpcReqWifiGetBandwidth methods */
void   rpc__req__wifi_get_bandwidth__init
                     (RpcReqWifiGetBandwidth         *message);
size_t rpc__req__wifi_get_bandwidth__get_packed_size
                     (const RpcReqWifiGetBandwidth   *message);
size_t rpc__req__wifi_get_bandwidth__pack
                     (const RpcReqWifiGetBandwidth   *message,
                      uint8_t             *out);
size_t rpc__req__wifi_get_bandwidth__pack_to_buffer
                     (const RpcReqWifiGetBandwidth   *message,
                      ProtobufCBuffer     *buffer);
RpcReqWifiGetBandwidth *
       rpc__req__wifi_get_bandwidth__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   rpc__req__wifi_get_bandwidth__free_unpacked
                     (RpcReqWifiGetBandwidth *message,
                      ProtobufCAllocator *allocator);
/* RpcRespWifiGetBandwidth methods */
void   rpc__resp__wifi_get_bandwidth__init
                     (RpcRespWifiGetBandwidth         *message);
size_t rpc__resp__wifi_get_bandwidth__get_packed_size
                     (const RpcRespWifiGetBandwidth   *message);
size_t rpc__resp__wifi_get_bandwidth__pack
                     (const RpcRespWifiGetBandwidth   *message,
                      uint8_t             *out);
size_t rpc__resp__wifi_get_bandwidth__pack_to_buffer
                     (const RpcRespWifiGetBandwidth   *message,
                      ProtobufCBuffer     *buffer);
RpcRespWifiGetBandwidth *
       rpc__resp__wifi_get_bandwidth__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   rpc__resp__wifi_get_bandwidth__free_unpacked
                     (RpcRespWifiGetBandwidth *message,
                      ProtobufCAllocator *allocator);
/* RpcReqWifiSetChannel methods */
void   rpc__req__wifi_set_channel__init
                     (RpcReqWifiSetChannel         *message);
size_t rpc__req__wifi_set_channel__get_packed_size
                     (const RpcReqWifiSetChannel   *message);
size_t rpc__req__wifi_set_channel__pack
                     (const RpcReqWifiSetChannel   *message,
                      uint8_t             *out);
size_t rpc__req__wifi_set_channel__pack_to_buffer
                     (const RpcReqWifiSetChannel   *message,
                      ProtobufCBuffer     *buffer);
RpcReqWifiSetChannel *
       rpc__req__wifi_set_channel__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   rpc__req__wifi_set_channel__free_unpacked
                     (RpcReqWifiSetChannel *message,
                      ProtobufCAllocator *allocator);
/* RpcRespWifiSetChannel methods */
void   rpc__resp__wifi_set_channel__init
                     (RpcRespWifiSetChannel         *message);
size_t rpc__resp__wifi_set_channel__get_packed_size
                     (const RpcRespWifiSetChannel   *message);
size_t rpc__resp__wifi_set_channel__pack
                     (const RpcRespWifiSetChannel   *message,
                      uint8_t             *out);
size_t rpc__resp__wifi_set_channel__pack_to_buffer
                     (const RpcRespWifiSetChannel   *message,
                      ProtobufCBuffer     *buffer);
RpcRespWifiSetChannel *
       rpc__resp__wifi_set_channel__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   rpc__resp__wifi_set_channel__free_unpacked
                     (RpcRespWifiSetChannel *message,
                      ProtobufCAllocator *allocator);
/* RpcReqWifiGetChannel methods */
void   rpc__req__wifi_get_channel__init
                     (RpcReqWifiGetChannel         *message);
size_t rpc__req__wifi_get_channel__get_packed_size
                     (const RpcReqWifiGetChannel   *message);
size_t rpc__req__wifi_get_channel__pack
                     (const RpcReqWifiGetChannel   *message,
                      uint8_t             *out);
size_t rpc__req__wifi_get_channel__pack_to_buffer
                     (const RpcReqWifiGetChannel   *message,
                      ProtobufCBuffer     *buffer);
RpcReqWifiGetChannel *
       rpc__req__wifi_get_channel__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   rpc__req__wifi_get_channel__free_unpacked
                     (RpcReqWifiGetChannel *message,
                      ProtobufCAllocator *allocator);
/* RpcRespWifiGetChannel methods */
void   rpc__resp__wifi_get_channel__init
                     (RpcRespWifiGetChannel         *message);
size_t rpc__resp__wifi_get_channel__get_packed_size
                     (const RpcRespWifiGetChannel   *message);
size_t rpc__resp__wifi_get_channel__pack
                     (const RpcRespWifiGetChannel   *message,
                      uint8_t             *out);
size_t rpc__resp__wifi_get_channel__pack_to_buffer
                     (const RpcRespWifiGetChannel   *message,
                      ProtobufCBuffer     *buffer);
RpcRespWifiGetChannel *
       rpc__resp__wifi_get_channel__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   rpc__resp__wifi_get_channel__free_unpacked
                     (RpcRespWifiGetChannel *message,
                      ProtobufCAllocator *allocator);
/* RpcReqWifiSetStorage methods */
void   rpc__req__wifi_set_storage__init
                     (RpcReqWifiSetStorage         *message);
size_t rpc__req__wifi_set_storage__get_packed_size
                     (const RpcReqWifiSetStorage   *message);
size_t rpc__req__wifi_set_storage__pack
                     (const RpcReqWifiSetStorage   *message,
                      uint8_t             *out);
size_t rpc__req__wifi_set_storage__pack_to_buffer
                     (const RpcReqWifiSetStorage   *message,
                      ProtobufCBuffer     *buffer);
RpcReqWifiSetStorage *
       rpc__req__wifi_set_storage__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   rpc__req__wifi_set_storage__free_unpacked
                     (RpcReqWifiSetStorage *message,
                      ProtobufCAllocator *allocator);
/* RpcRespWifiSetStorage methods */
void   rpc__resp__wifi_set_storage__init
                     (RpcRespWifiSetStorage         *message);
size_t rpc__resp__wifi_set_storage__get_packed_size
                     (const RpcRespWifiSetStorage   *message);
size_t rpc__resp__wifi_set_storage__pack
                     (const RpcRespWifiSetStorage   *message,
                      uint8_t             *out);
size_t rpc__resp__wifi_set_storage__pack_to_buffer
                     (const RpcRespWifiSetStorage   *message,
                      ProtobufCBuffer     *buffer);
RpcRespWifiSetStorage *
       rpc__resp__wifi_set_storage__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   rpc__resp__wifi_set_storage__free_unpacked
                     (RpcRespWifiSetStorage *message,
                      ProtobufCAllocator *allocator);
/* RpcReqWifiSetCountryCode methods */
void   rpc__req__wifi_set_country_code__init
                     (RpcReqWifiSetCountryCode         *message);
size_t rpc__req__wifi_set_country_code__get_packed_size
                     (const RpcReqWifiSetCountryCode   *message);
size_t rpc__req__wifi_set_country_code__pack
                     (const RpcReqWifiSetCountryCode   *message,
                      uint8_t             *out);
size_t rpc__req__wifi_set_country_code__pack_to_buffer
                     (const RpcReqWifiSetCountryCode   *message,
                      ProtobufCBuffer     *buffer);
RpcReqWifiSetCountryCode *
       rpc__req__wifi_set_country_code__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   rpc__req__wifi_set_country_code__free_unpacked
                     (RpcReqWifiSetCountryCode *message,
                      ProtobufCAllocator *allocator);
/* RpcRespWifiSetCountryCode methods */
void   rpc__resp__wifi_set_country_code__init
                     (RpcRespWifiSetCountryCode         *message);
size_t rpc__resp__wifi_set_country_code__get_packed_size
                     (const RpcRespWifiSetCountryCode   *message);
size_t rpc__resp__wifi_set_country_code__pack
                     (const RpcRespWifiSetCountryCode   *message,
                      uint8_t             *out);
size_t rpc__resp__wifi_set_country_code__pack_to_buffer
                     (const RpcRespWifiSetCountryCode   *message,
                      ProtobufCBuffer     *buffer);
RpcRespWifiSetCountryCode *
       rpc__resp__wifi_set_country_code__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   rpc__resp__wifi_set_country_code__free_unpacked
                     (RpcRespWifiSetCountryCode *message,
                      ProtobufCAllocator *allocator);
/* RpcReqWifiGetCountryCode methods */
void   rpc__req__wifi_get_country_code__init
                     (RpcReqWifiGetCountryCode         *message);
size_t rpc__req__wifi_get_country_code__get_packed_size
                     (const RpcReqWifiGetCountryCode   *message);
size_t rpc__req__wifi_get_country_code__pack
                     (const RpcReqWifiGetCountryCode   *message,
                      uint8_t             *out);
size_t rpc__req__wifi_get_country_code__pack_to_buffer
                     (const RpcReqWifiGetCountryCode   *message,
                      ProtobufCBuffer     *buffer);
RpcReqWifiGetCountryCode *
       rpc__req__wifi_get_country_code__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   rpc__req__wifi_get_country_code__free_unpacked
                     (RpcReqWifiGetCountryCode *message,
                      ProtobufCAllocator *allocator);
/* RpcRespWifiGetCountryCode methods */
void   rpc__resp__wifi_get_country_code__init
                     (RpcRespWifiGetCountryCode         *message);
size_t rpc__resp__wifi_get_country_code__get_packed_size
                     (const RpcRespWifiGetCountryCode   *message);
size_t rpc__resp__wifi_get_country_code__pack
                     (const RpcRespWifiGetCountryCode   *message,
                      uint8_t             *out);
size_t rpc__resp__wifi_get_country_code__pack_to_buffer
                     (const RpcRespWifiGetCountryCode   *message,
                      ProtobufCBuffer     *buffer);
RpcRespWifiGetCountryCode *
       rpc__resp__wifi_get_country_code__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   rpc__resp__wifi_get_country_code__free_unpacked
                     (RpcRespWifiGetCountryCode *message,
                      ProtobufCAllocator *allocator);
/* RpcReqWifiSetCountry methods */
void   rpc__req__wifi_set_country__init
                     (RpcReqWifiSetCountry         *message);
size_t rpc__req__wifi_set_country__get_packed_size
                     (const RpcReqWifiSetCountry   *message);
size_t rpc__req__wifi_set_country__pack
                     (const RpcReqWifiSetCountry   *message,
                      uint8_t             *out);
size_t rpc__req__wifi_set_country__pack_to_buffer
                     (const RpcReqWifiSetCountry   *message,
                      ProtobufCBuffer     *buffer);
RpcReqWifiSetCountry *
       rpc__req__wifi_set_country__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   rpc__req__wifi_set_country__free_unpacked
                     (RpcReqWifiSetCountry *message,
                      ProtobufCAllocator *allocator);
/* RpcRespWifiSetCountry methods */
void   rpc__resp__wifi_set_country__init
                     (RpcRespWifiSetCountry         *message);
size_t rpc__resp__wifi_set_country__get_packed_size
                     (const RpcRespWifiSetCountry   *message);
size_t rpc__resp__wifi_set_country__pack
                     (const RpcRespWifiSetCountry   *message,
                      uint8_t             *out);
size_t rpc__resp__wifi_set_country__pack_to_buffer
                     (const RpcRespWifiSetCountry   *message,
                      ProtobufCBuffer     *buffer);
RpcRespWifiSetCountry *
       rpc__resp__wifi_set_country__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   rpc__resp__wifi_set_country__free_unpacked
                     (RpcRespWifiSetCountry *message,
                      ProtobufCAllocator *allocator);
/* RpcReqWifiGetCountry methods */
void   rpc__req__wifi_get_country__init
                     (RpcReqWifiGetCountry         *message);
size_t rpc__req__wifi_get_country__get_packed_size
                     (const RpcReqWifiGetCountry   *message);
size_t rpc__req__wifi_get_country__pack
                     (const RpcReqWifiGetCountry   *message,
                      uint8_t             *out);
size_t rpc__req__wifi_get_country__pack_to_buffer
                     (const RpcReqWifiGetCountry   *message,
                      ProtobufCBuffer     *buffer);
RpcReqWifiGetCountry *
       rpc__req__wifi_get_country__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   rpc__req__wifi_get_country__free_unpacked
                     (RpcReqWifiGetCountry *message,
                      ProtobufCAllocator *allocator);
/* RpcRespWifiGetCountry methods */
void   rpc__resp__wifi_get_country__init
                     (RpcRespWifiGetCountry         *message);
size_t rpc__resp__wifi_get_country__get_packed_size
                     (const RpcRespWifiGetCountry   *message);
size_t rpc__resp__wifi_get_country__pack
                     (const RpcRespWifiGetCountry   *message,
                      uint8_t             *out);
size_t rpc__resp__wifi_get_country__pack_to_buffer
                     (const RpcRespWifiGetCountry   *message,
                      ProtobufCBuffer     *buffer);
RpcRespWifiGetCountry *
       rpc__resp__wifi_get_country__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   rpc__resp__wifi_get_country__free_unpacked
                     (RpcRespWifiGetCountry *message,
                      ProtobufCAllocator *allocator);
/* RpcReqWifiApGetStaList methods */
void   rpc__req__wifi_ap_get_sta_list__init
                     (RpcReqWifiApGetStaList         *message);
size_t rpc__req__wifi_ap_get_sta_list__get_packed_size
                     (const RpcReqWifiApGetStaList   *message);
size_t rpc__req__wifi_ap_get_sta_list__pack
                     (const RpcReqWifiApGetStaList   *message,
                      uint8_t             *out);
size_t rpc__req__wifi_ap_get_sta_list__pack_to_buffer
                     (const RpcReqWifiApGetStaList   *message,
                      ProtobufCBuffer     *buffer);
RpcReqWifiApGetStaList *
       rpc__req__wifi_ap_get_sta_list__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   rpc__req__wifi_ap_get_sta_list__free_unpacked
                     (RpcReqWifiApGetStaList *message,
                      ProtobufCAllocator *allocator);
/* RpcRespWifiApGetStaList methods */
void   rpc__resp__wifi_ap_get_sta_list__init
                     (RpcRespWifiApGetStaList         *message);
size_t rpc__resp__wifi_ap_get_sta_list__get_packed_size
                     (const RpcRespWifiApGetStaList   *message);
size_t rpc__resp__wifi_ap_get_sta_list__pack
                     (const RpcRespWifiApGetStaList   *message,
                      uint8_t             *out);
size_t rpc__resp__wifi_ap_get_sta_list__pack_to_buffer
                     (const RpcRespWifiApGetStaList   *message,
                      ProtobufCBuffer     *buffer);
RpcRespWifiApGetStaList *
       rpc__resp__wifi_ap_get_sta_list__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   rpc__resp__wifi_ap_get_sta_list__free_unpacked
                     (RpcRespWifiApGetStaList *message,
                      ProtobufCAllocator *allocator);
/* RpcReqWifiApGetStaAid methods */
void   rpc__req__wifi_ap_get_sta_aid__init
                     (RpcReqWifiApGetStaAid         *message);
size_t rpc__req__wifi_ap_get_sta_aid__get_packed_size
                     (const RpcReqWifiApGetStaAid   *message);
size_t rpc__req__wifi_ap_get_sta_aid__pack
                     (const RpcReqWifiApGetStaAid   *message,
                      uint8_t             *out);
size_t rpc__req__wifi_ap_get_sta_aid__pack_to_buffer
                     (const RpcReqWifiApGetStaAid   *message,
                      ProtobufCBuffer     *buffer);
RpcReqWifiApGetStaAid *
       rpc__req__wifi_ap_get_sta_aid__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   rpc__req__wifi_ap_get_sta_aid__free_unpacked
                     (RpcReqWifiApGetStaAid *message,
                      ProtobufCAllocator *allocator);
/* RpcReqWifiStaGetNegotiatedPhymode methods */
void   rpc__req__wifi_sta_get_negotiated_phymode__init
                     (RpcReqWifiStaGetNegotiatedPhymode         *message);
size_t rpc__req__wifi_sta_get_negotiated_phymode__get_packed_size
                     (const RpcReqWifiStaGetNegotiatedPhymode   *message);
size_t rpc__req__wifi_sta_get_negotiated_phymode__pack
                     (const RpcReqWifiStaGetNegotiatedPhymode   *message,
                      uint8_t             *out);
size_t rpc__req__wifi_sta_get_negotiated_phymode__pack_to_buffer
                     (const RpcReqWifiStaGetNegotiatedPhymode   *message,
                      ProtobufCBuffer     *buffer);
RpcReqWifiStaGetNegotiatedPhymode *
       rpc__req__wifi_sta_get_negotiated_phymode__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   rpc__req__wifi_sta_get_negotiated_phymode__free_unpacked
                     (RpcReqWifiStaGetNegotiatedPhymode *message,
                      ProtobufCAllocator *allocator);
/* RpcRespWifiStaGetNegotiatedPhymode methods */
void   rpc__resp__wifi_sta_get_negotiated_phymode__init
                     (RpcRespWifiStaGetNegotiatedPhymode         *message);
size_t rpc__resp__wifi_sta_get_negotiated_phymode__get_packed_size
                     (const RpcRespWifiStaGetNegotiatedPhymode   *message);
size_t rpc__resp__wifi_sta_get_negotiated_phymode__pack
                     (const RpcRespWifiStaGetNegotiatedPhymode   *message,
                      uint8_t             *out);
size_t rpc__resp__wifi_sta_get_negotiated_phymode__pack_to_buffer
                     (const RpcRespWifiStaGetNegotiatedPhymode   *message,
                      ProtobufCBuffer     *buffer);
RpcRespWifiStaGetNegotiatedPhymode *
       rpc__resp__wifi_sta_get_negotiated_phymode__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   rpc__resp__wifi_sta_get_negotiated_phymode__free_unpacked
                     (RpcRespWifiStaGetNegotiatedPhymode *message,
                      ProtobufCAllocator *allocator);
/* RpcRespWifiApGetStaAid methods */
void   rpc__resp__wifi_ap_get_sta_aid__init
                     (RpcRespWifiApGetStaAid         *message);
size_t rpc__resp__wifi_ap_get_sta_aid__get_packed_size
                     (const RpcRespWifiApGetStaAid   *message);
size_t rpc__resp__wifi_ap_get_sta_aid__pack
                     (const RpcRespWifiApGetStaAid   *message,
                      uint8_t             *out);
size_t rpc__resp__wifi_ap_get_sta_aid__pack_to_buffer
                     (const RpcRespWifiApGetStaAid   *message,
                      ProtobufCBuffer     *buffer);
RpcRespWifiApGetStaAid *
       rpc__resp__wifi_ap_get_sta_aid__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   rpc__resp__wifi_ap_get_sta_aid__free_unpacked
                     (RpcRespWifiApGetStaAid *message,
                      ProtobufCAllocator *allocator);
/* RpcReqWifiStaGetRssi methods */
void   rpc__req__wifi_sta_get_rssi__init
                     (RpcReqWifiStaGetRssi         *message);
size_t rpc__req__wifi_sta_get_rssi__get_packed_size
                     (const RpcReqWifiStaGetRssi   *message);
size_t rpc__req__wifi_sta_get_rssi__pack
                     (const RpcReqWifiStaGetRssi   *message,
                      uint8_t             *out);
size_t rpc__req__wifi_sta_get_rssi__pack_to_buffer
                     (const RpcReqWifiStaGetRssi   *message,
                      ProtobufCBuffer     *buffer);
RpcReqWifiStaGetRssi *
       rpc__req__wifi_sta_get_rssi__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   rpc__req__wifi_sta_get_rssi__free_unpacked
                     (RpcReqWifiStaGetRssi *message,
                      ProtobufCAllocator *allocator);
/* RpcRespWifiStaGetRssi methods */
void   rpc__resp__wifi_sta_get_rssi__init
                     (RpcRespWifiStaGetRssi         *message);
size_t rpc__resp__wifi_sta_get_rssi__get_packed_size
                     (const RpcRespWifiStaGetRssi   *message);
size_t rpc__resp__wifi_sta_get_rssi__pack
                     (const RpcRespWifiStaGetRssi   *message,
                      uint8_t             *out);
size_t rpc__resp__wifi_sta_get_rssi__pack_to_buffer
                     (const RpcRespWifiStaGetRssi   *message,
                      ProtobufCBuffer     *buffer);
RpcRespWifiStaGetRssi *
       rpc__resp__wifi_sta_get_rssi__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   rpc__resp__wifi_sta_get_rssi__free_unpacked
                     (RpcRespWifiStaGetRssi *message,
                      ProtobufCAllocator *allocator);
/* RpcReqWifiScanParams methods */
void   rpc__req__wifi_scan_params__init
                     (RpcReqWifiScanParams         *message);
size_t rpc__req__wifi_scan_params__get_packed_size
                     (const RpcReqWifiScanParams   *message);
size_t rpc__req__wifi_scan_params__pack
                     (const RpcReqWifiScanParams   *message,
                      uint8_t             *out);
size_t rpc__req__wifi_scan_params__pack_to_buffer
                     (const RpcReqWifiScanParams   *message,
                      ProtobufCBuffer     *buffer);
RpcReqWifiScanParams *
       rpc__req__wifi_scan_params__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   rpc__req__wifi_scan_params__free_unpacked
                     (RpcReqWifiScanParams *message,
                      ProtobufCAllocator *allocator);
/* RpcRespWifiScanParams methods */
void   rpc__resp__wifi_scan_params__init
                     (RpcRespWifiScanParams         *message);
size_t rpc__resp__wifi_scan_params__get_packed_size
                     (const RpcRespWifiScanParams   *message);
size_t rpc__resp__wifi_scan_params__pack
                     (const RpcRespWifiScanParams   *message,
                      uint8_t             *out);
size_t rpc__resp__wifi_scan_params__pack_to_buffer
                     (const RpcRespWifiScanParams   *message,
                      ProtobufCBuffer     *buffer);
RpcRespWifiScanParams *
       rpc__resp__wifi_scan_params__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   rpc__resp__wifi_scan_params__free_unpacked
                     (RpcRespWifiScanParams *message,
                      ProtobufCAllocator *allocator);
/* RpcReqWifiStaGetAid methods */
void   rpc__req__wifi_sta_get_aid__init
                     (RpcReqWifiStaGetAid         *message);
size_t rpc__req__wifi_sta_get_aid__get_packed_size
                     (const RpcReqWifiStaGetAid   *message);
size_t rpc__req__wifi_sta_get_aid__pack
                     (const RpcReqWifiStaGetAid   *message,
                      uint8_t             *out);
size_t rpc__req__wifi_sta_get_aid__pack_to_buffer
                     (const RpcReqWifiStaGetAid   *message,
                      ProtobufCBuffer     *buffer);
RpcReqWifiStaGetAid *
       rpc__req__wifi_sta_get_aid__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   rpc__req__wifi_sta_get_aid__free_unpacked
                     (RpcReqWifiStaGetAid *message,
                      ProtobufCAllocator *allocator);
/* RpcRespWifiStaGetAid methods */
void   rpc__resp__wifi_sta_get_aid__init
                     (RpcRespWifiStaGetAid         *message);
size_t rpc__resp__wifi_sta_get_aid__get_packed_size
                     (const RpcRespWifiStaGetAid   *message);
size_t rpc__resp__wifi_sta_get_aid__pack
                     (const RpcRespWifiStaGetAid   *message,
                      uint8_t             *out);
size_t rpc__resp__wifi_sta_get_aid__pack_to_buffer
                     (const RpcRespWifiStaGetAid   *message,
                      ProtobufCBuffer     *buffer);
RpcRespWifiStaGetAid *
       rpc__resp__wifi_sta_get_aid__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   rpc__resp__wifi_sta_get_aid__free_unpacked
                     (RpcRespWifiStaGetAid *message,
                      ProtobufCAllocator *allocator);
/* RpcReqWifiSetProtocols methods */
void   rpc__req__wifi_set_protocols__init
                     (RpcReqWifiSetProtocols         *message);
size_t rpc__req__wifi_set_protocols__get_packed_size
                     (const RpcReqWifiSetProtocols   *message);
size_t rpc__req__wifi_set_protocols__pack
                     (const RpcReqWifiSetProtocols   *message,
                      uint8_t             *out);
size_t rpc__req__wifi_set_protocols__pack_to_buffer
                     (const RpcReqWifiSetProtocols   *message,
                      ProtobufCBuffer     *buffer);
RpcReqWifiSetProtocols *
       rpc__req__wifi_set_protocols__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   rpc__req__wifi_set_protocols__free_unpacked
                     (RpcReqWifiSetProtocols *message,
                      ProtobufCAllocator *allocator);
/* RpcRespWifiSetProtocols methods */
void   rpc__resp__wifi_set_protocols__init
                     (RpcRespWifiSetProtocols         *message);
size_t rpc__resp__wifi_set_protocols__get_packed_size
                     (const RpcRespWifiSetProtocols   *message);
size_t rpc__resp__wifi_set_protocols__pack
                     (const RpcRespWifiSetProtocols   *message,
                      uint8_t             *out);
size_t rpc__resp__wifi_set_protocols__pack_to_buffer
                     (const RpcRespWifiSetProtocols   *message,
                      ProtobufCBuffer     *buffer);
RpcRespWifiSetProtocols *
       rpc__resp__wifi_set_protocols__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   rpc__resp__wifi_set_protocols__free_unpacked
                     (RpcRespWifiSetProtocols *message,
                      ProtobufCAllocator *allocator);
/* RpcReqWifiGetProtocols methods */
void   rpc__req__wifi_get_protocols__init
                     (RpcReqWifiGetProtocols         *message);
size_t rpc__req__wifi_get_protocols__get_packed_size
                     (const RpcReqWifiGetProtocols   *message);
size_t rpc__req__wifi_get_protocols__pack
                     (const RpcReqWifiGetProtocols   *message,
                      uint8_t             *out);
size_t rpc__req__wifi_get_protocols__pack_to_buffer
                     (const RpcReqWifiGetProtocols   *message,
                      ProtobufCBuffer     *buffer);
RpcReqWifiGetProtocols *
       rpc__req__wifi_get_protocols__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   rpc__req__wifi_get_protocols__free_unpacked
                     (RpcReqWifiGetProtocols *message,
                      ProtobufCAllocator *allocator);
/* RpcRespWifiGetProtocols methods */
void   rpc__resp__wifi_get_protocols__init
                     (RpcRespWifiGetProtocols         *message);
size_t rpc__resp__wifi_get_protocols__get_packed_size
                     (const RpcRespWifiGetProtocols   *message);
size_t rpc__resp__wifi_get_protocols__pack
                     (const RpcRespWifiGetProtocols   *message,
                      uint8_t             *out);
size_t rpc__resp__wifi_get_protocols__pack_to_buffer
                     (const RpcRespWifiGetProtocols   *message,
                      ProtobufCBuffer     *buffer);
RpcRespWifiGetProtocols *
       rpc__resp__wifi_get_protocols__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   rpc__resp__wifi_get_protocols__free_unpacked
                     (RpcRespWifiGetProtocols *message,
                      ProtobufCAllocator *allocator);
/* RpcReqWifiSetBandwidths methods */
void   rpc__req__wifi_set_bandwidths__init
                     (RpcReqWifiSetBandwidths         *message);
size_t rpc__req__wifi_set_bandwidths__get_packed_size
                     (const RpcReqWifiSetBandwidths   *message);
size_t rpc__req__wifi_set_bandwidths__pack
                     (const RpcReqWifiSetBandwidths   *message,
                      uint8_t             *out);
size_t rpc__req__wifi_set_bandwidths__pack_to_buffer
                     (const RpcReqWifiSetBandwidths   *message,
                      ProtobufCBuffer     *buffer);
RpcReqWifiSetBandwidths *
       rpc__req__wifi_set_bandwidths__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   rpc__req__wifi_set_bandwidths__free_unpacked
                     (RpcReqWifiSetBandwidths *message,
                      ProtobufCAllocator *allocator);
/* RpcRespWifiSetBandwidths methods */
void   rpc__resp__wifi_set_bandwidths__init
                     (RpcRespWifiSetBandwidths         *message);
size_t rpc__resp__wifi_set_bandwidths__get_packed_size
                     (const RpcRespWifiSetBandwidths   *message);
size_t rpc__resp__wifi_set_bandwidths__pack
                     (const RpcRespWifiSetBandwidths   *message,
                      uint8_t             *out);
size_t rpc__resp__wifi_set_bandwidths__pack_to_buffer
                     (const RpcRespWifiSetBandwidths   *message,
                      ProtobufCBuffer     *buffer);
RpcRespWifiSetBandwidths *
       rpc__resp__wifi_set_bandwidths__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   rpc__resp__wifi_set_bandwidths__free_unpacked
                     (RpcRespWifiSetBandwidths *message,
                      ProtobufCAllocator *allocator);
/* RpcReqWifiGetBandwidths methods */
void   rpc__req__wifi_get_bandwidths__init
                     (RpcReqWifiGetBandwidths         *message);
size_t rpc__req__wifi_get_bandwidths__get_packed_size
                     (const RpcReqWifiGetBandwidths   *message);
size_t rpc__req__wifi_get_bandwidths__pack
                     (const RpcReqWifiGetBandwidths   *message,
                      uint8_t             *out);
size_t rpc__req__wifi_get_bandwidths__pack_to_buffer
                     (const RpcReqWifiGetBandwidths   *message,
                      ProtobufCBuffer     *buffer);
RpcReqWifiGetBandwidths *
       rpc__req__wifi_get_bandwidths__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   rpc__req__wifi_get_bandwidths__free_unpacked
                     (RpcReqWifiGetBandwidths *message,
                      ProtobufCAllocator *allocator);
/* RpcRespWifiGetBandwidths methods */
void   rpc__resp__wifi_get_bandwidths__init
                     (RpcRespWifiGetBandwidths         *message);
size_t rpc__resp__wifi_get_bandwidths__get_packed_size
                     (const RpcRespWifiGetBandwidths   *message);
size_t rpc__resp__wifi_get_bandwidths__pack
                     (const RpcRespWifiGetBandwidths   *message,
                      uint8_t             *out);
size_t rpc__resp__wifi_get_bandwidths__pack_to_buffer
                     (const RpcRespWifiGetBandwidths   *message,
                      ProtobufCBuffer     *buffer);
RpcRespWifiGetBandwidths *
       rpc__resp__wifi_get_bandwidths__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   rpc__resp__wifi_get_bandwidths__free_unpacked
                     (RpcRespWifiGetBandwidths *message,
                      ProtobufCAllocator *allocator);
/* RpcReqWifiSetBand methods */
void   rpc__req__wifi_set_band__init
                     (RpcReqWifiSetBand         *message);
size_t rpc__req__wifi_set_band__get_packed_size
                     (const RpcReqWifiSetBand   *message);
size_t rpc__req__wifi_set_band__pack
                     (const RpcReqWifiSetBand   *message,
                      uint8_t             *out);
size_t rpc__req__wifi_set_band__pack_to_buffer
                     (const RpcReqWifiSetBand   *message,
                      ProtobufCBuffer     *buffer);
RpcReqWifiSetBand *
       rpc__req__wifi_set_band__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   rpc__req__wifi_set_band__free_unpacked
                     (RpcReqWifiSetBand *message,
                      ProtobufCAllocator *allocator);
/* RpcRespWifiSetBand methods */
void   rpc__resp__wifi_set_band__init
                     (RpcRespWifiSetBand         *message);
size_t rpc__resp__wifi_set_band__get_packed_size
                     (const RpcRespWifiSetBand   *message);
size_t rpc__resp__wifi_set_band__pack
                     (const RpcRespWifiSetBand   *message,
                      uint8_t             *out);
size_t rpc__resp__wifi_set_band__pack_to_buffer
                     (const RpcRespWifiSetBand   *message,
                      ProtobufCBuffer     *buffer);
RpcRespWifiSetBand *
       rpc__resp__wifi_set_band__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   rpc__resp__wifi_set_band__free_unpacked
                     (RpcRespWifiSetBand *message,
                      ProtobufCAllocator *allocator);
/* RpcReqWifiGetBand methods */
void   rpc__req__wifi_get_band__init
                     (RpcReqWifiGetBand         *message);
size_t rpc__req__wifi_get_band__get_packed_size
                     (const RpcReqWifiGetBand   *message);
size_t rpc__req__wifi_get_band__pack
                     (const RpcReqWifiGetBand   *message,
                      uint8_t             *out);
size_t rpc__req__wifi_get_band__pack_to_buffer
                     (const RpcReqWifiGetBand   *message,
                      ProtobufCBuffer     *buffer);
RpcReqWifiGetBand *
       rpc__req__wifi_get_band__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   rpc__req__wifi_get_band__free_unpacked
                     (RpcReqWifiGetBand *message,
                      ProtobufCAllocator *allocator);
/* RpcRespWifiGetBand methods */
void   rpc__resp__wifi_get_band__init
                     (RpcRespWifiGetBand         *message);
size_t rpc__resp__wifi_get_band__get_packed_size
                     (const RpcRespWifiGetBand   *message);
size_t rpc__resp__wifi_get_band__pack
                     (const RpcRespWifiGetBand   *message,
                      uint8_t             *out);
size_t rpc__resp__wifi_get_band__pack_to_buffer
                     (const RpcRespWifiGetBand   *message,
                      ProtobufCBuffer     *buffer);
RpcRespWifiGetBand *
       rpc__resp__wifi_get_band__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   rpc__resp__wifi_get_band__free_unpacked
                     (RpcRespWifiGetBand *message,
                      ProtobufCAllocator *allocator);
/* RpcReqWifiSetBandMode methods */
void   rpc__req__wifi_set_band_mode__init
                     (RpcReqWifiSetBandMode         *message);
size_t rpc__req__wifi_set_band_mode__get_packed_size
                     (const RpcReqWifiSetBandMode   *message);
size_t rpc__req__wifi_set_band_mode__pack
                     (const RpcReqWifiSetBandMode   *message,
                      uint8_t             *out);
size_t rpc__req__wifi_set_band_mode__pack_to_buffer
                     (const RpcReqWifiSetBandMode   *message,
                      ProtobufCBuffer     *buffer);
RpcReqWifiSetBandMode *
       rpc__req__wifi_set_band_mode__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   rpc__req__wifi_set_band_mode__free_unpacked
                     (RpcReqWifiSetBandMode *message,
                      ProtobufCAllocator *allocator);
/* RpcRespWifiSetBandMode methods */
void   rpc__resp__wifi_set_band_mode__init
                     (RpcRespWifiSetBandMode         *message);
size_t rpc__resp__wifi_set_band_mode__get_packed_size
                     (const RpcRespWifiSetBandMode   *message);
size_t rpc__resp__wifi_set_band_mode__pack
                     (const RpcRespWifiSetBandMode   *message,
                      uint8_t             *out);
size_t rpc__resp__wifi_set_band_mode__pack_to_buffer
                     (const RpcRespWifiSetBandMode   *message,
                      ProtobufCBuffer     *buffer);
RpcRespWifiSetBandMode *
       rpc__resp__wifi_set_band_mode__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   rpc__resp__wifi_set_band_mode__free_unpacked
                     (RpcRespWifiSetBandMode *message,
                      ProtobufCAllocator *allocator);
/* RpcReqWifiGetBandMode methods */
void   rpc__req__wifi_get_band_mode__init
                     (RpcReqWifiGetBandMode         *message);
size_t rpc__req__wifi_get_band_mode__get_packed_size
                     (const RpcReqWifiGetBandMode   *message);
size_t rpc__req__wifi_get_band_mode__pack
                     (const RpcReqWifiGetBandMode   *message,
                      uint8_t             *out);
size_t rpc__req__wifi_get_band_mode__pack_to_buffer
                     (const RpcReqWifiGetBandMode   *message,
                      ProtobufCBuffer     *buffer);
RpcReqWifiGetBandMode *
       rpc__req__wifi_get_band_mode__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   rpc__req__wifi_get_band_mode__free_unpacked
                     (RpcReqWifiGetBandMode *message,
                      ProtobufCAllocator *allocator);
/* RpcRespWifiGetBandMode methods */
void   rpc__resp__wifi_get_band_mode__init
                     (RpcRespWifiGetBandMode         *message);
size_t rpc__resp__wifi_get_band_mode__get_packed_size
                     (const RpcRespWifiGetBandMode   *message);
size_t rpc__resp__wifi_get_band_mode__pack
                     (const RpcRespWifiGetBandMode   *message,
                      uint8_t             *out);
size_t rpc__resp__wifi_get_band_mode__pack_to_buffer
                     (const RpcRespWifiGetBandMode   *message,
                      ProtobufCBuffer     *buffer);
RpcRespWifiGetBandMode *
       rpc__resp__wifi_get_band_mode__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   rpc__resp__wifi_get_band_mode__free_unpacked
                     (RpcRespWifiGetBandMode *message,
                      ProtobufCAllocator *allocator);
/* RpcReqWifiSetInactiveTime methods */
void   rpc__req__wifi_set_inactive_time__init
                     (RpcReqWifiSetInactiveTime         *message);
size_t rpc__req__wifi_set_inactive_time__get_packed_size
                     (const RpcReqWifiSetInactiveTime   *message);
size_t rpc__req__wifi_set_inactive_time__pack
                     (const RpcReqWifiSetInactiveTime   *message,
                      uint8_t             *out);
size_t rpc__req__wifi_set_inactive_time__pack_to_buffer
                     (const RpcReqWifiSetInactiveTime   *message,
                      ProtobufCBuffer     *buffer);
RpcReqWifiSetInactiveTime *
       rpc__req__wifi_set_inactive_time__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   rpc__req__wifi_set_inactive_time__free_unpacked
                     (RpcReqWifiSetInactiveTime *message,
                      ProtobufCAllocator *allocator);
/* RpcRespWifiSetInactiveTime methods */
void   rpc__resp__wifi_set_inactive_time__init
                     (RpcRespWifiSetInactiveTime         *message);
size_t rpc__resp__wifi_set_inactive_time__get_packed_size
                     (const RpcRespWifiSetInactiveTime   *message);
size_t rpc__resp__wifi_set_inactive_time__pack
                     (const RpcRespWifiSetInactiveTime   *message,
                      uint8_t             *out);
size_t rpc__resp__wifi_set_inactive_time__pack_to_buffer
                     (const RpcRespWifiSetInactiveTime   *message,
                      ProtobufCBuffer     *buffer);
RpcRespWifiSetInactiveTime *
       rpc__resp__wifi_set_inactive_time__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   rpc__resp__wifi_set_inactive_time__free_unpacked
                     (RpcRespWifiSetInactiveTime *message,
                      ProtobufCAllocator *allocator);
/* RpcReqWifiGetInactiveTime methods */
void   rpc__req__wifi_get_inactive_time__init
                     (RpcReqWifiGetInactiveTime         *message);
size_t rpc__req__wifi_get_inactive_time__get_packed_size
                     (const RpcReqWifiGetInactiveTime   *message);
size_t rpc__req__wifi_get_inactive_time__pack
                     (const RpcReqWifiGetInactiveTime   *message,
                      uint8_t             *out);
size_t rpc__req__wifi_get_inactive_time__pack_to_buffer
                     (const RpcReqWifiGetInactiveTime   *message,
                      ProtobufCBuffer     *buffer);
RpcReqWifiGetInactiveTime *
       rpc__req__wifi_get_inactive_time__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   rpc__req__wifi_get_inactive_time__free_unpacked
                     (RpcReqWifiGetInactiveTime *message,
                      ProtobufCAllocator *allocator);
/* RpcRespWifiGetInactiveTime methods */
void   rpc__resp__wifi_get_inactive_time__init
                     (RpcRespWifiGetInactiveTime         *message);
size_t rpc__resp__wifi_get_inactive_time__get_packed_size
                     (const RpcRespWifiGetInactiveTime   *message);
size_t rpc__resp__wifi_get_inactive_time__pack
                     (const RpcRespWifiGetInactiveTime   *message,
                      uint8_t             *out);
size_t rpc__resp__wifi_get_inactive_time__pack_to_buffer
                     (const RpcRespWifiGetInactiveTime   *message,
                      ProtobufCBuffer     *buffer);
RpcRespWifiGetInactiveTime *
       rpc__resp__wifi_get_inactive_time__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   rpc__resp__wifi_get_inactive_time__free_unpacked
                     (RpcRespWifiGetInactiveTime *message,
                      ProtobufCAllocator *allocator);
/* RpcReqWifiDisablePmfConfig methods */
void   rpc__req__wifi_disable_pmf_config__init
                     (RpcReqWifiDisablePmfConfig         *message);
size_t rpc__req__wifi_disable_pmf_config__get_packed_size
                     (const RpcReqWifiDisablePmfConfig   *message);
size_t rpc__req__wifi_disable_pmf_config__pack
                     (const RpcReqWifiDisablePmfConfig   *message,
                      uint8_t             *out);
size_t rpc__req__wifi_disable_pmf_config__pack_to_buffer
                     (const RpcReqWifiDisablePmfConfig   *message,
                      ProtobufCBuffer     *buffer);
RpcReqWifiDisablePmfConfig *
       rpc__req__wifi_disable_pmf_config__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   rpc__req__wifi_disable_pmf_config__free_unpacked
                     (RpcReqWifiDisablePmfConfig *message,
                      ProtobufCAllocator *allocator);
/* RpcRespWifiDisablePmfConfig methods */
void   rpc__resp__wifi_disable_pmf_config__init
                     (RpcRespWifiDisablePmfConfig         *message);
size_t rpc__resp__wifi_disable_pmf_config__get_packed_size
                     (const RpcRespWifiDisablePmfConfig   *message);
size_t rpc__resp__wifi_disable_pmf_config__pack
                     (const RpcRespWifiDisablePmfConfig   *message,
                      uint8_t             *out);
size_t rpc__resp__wifi_disable_pmf_config__pack_to_buffer
                     (const RpcRespWifiDisablePmfConfig   *message,
                      ProtobufCBuffer     *buffer);
RpcRespWifiDisablePmfConfig *
       rpc__resp__wifi_disable_pmf_config__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   rpc__resp__wifi_disable_pmf_config__free_unpacked
                     (RpcRespWifiDisablePmfConfig *message,
                      ProtobufCAllocator *allocator);
/* RpcReqWifiStaItwtSetup methods */
void   rpc__req__wifi_sta_itwt_setup__init
                     (RpcReqWifiStaItwtSetup         *message);
size_t rpc__req__wifi_sta_itwt_setup__get_packed_size
                     (const RpcReqWifiStaItwtSetup   *message);
size_t rpc__req__wifi_sta_itwt_setup__pack
                     (const RpcReqWifiStaItwtSetup   *message,
                      uint8_t             *out);
size_t rpc__req__wifi_sta_itwt_setup__pack_to_buffer
                     (const RpcReqWifiStaItwtSetup   *message,
                      ProtobufCBuffer     *buffer);
RpcReqWifiStaItwtSetup *
       rpc__req__wifi_sta_itwt_setup__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   rpc__req__wifi_sta_itwt_setup__free_unpacked
                     (RpcReqWifiStaItwtSetup *message,
                      ProtobufCAllocator *allocator);
/* RpcRespWifiStaItwtSetup methods */
void   rpc__resp__wifi_sta_itwt_setup__init
                     (RpcRespWifiStaItwtSetup         *message);
size_t rpc__resp__wifi_sta_itwt_setup__get_packed_size
                     (const RpcRespWifiStaItwtSetup   *message);
size_t rpc__resp__wifi_sta_itwt_setup__pack
                     (const RpcRespWifiStaItwtSetup   *message,
                      uint8_t             *out);
size_t rpc__resp__wifi_sta_itwt_setup__pack_to_buffer
                     (const RpcRespWifiStaItwtSetup   *message,
                      ProtobufCBuffer     *buffer);
RpcRespWifiStaItwtSetup *
       rpc__resp__wifi_sta_itwt_setup__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   rpc__resp__wifi_sta_itwt_setup__free_unpacked
                     (RpcRespWifiStaItwtSetup *message,
                      ProtobufCAllocator *allocator);
/* RpcReqWifiStaItwtTeardown methods */
void   rpc__req__wifi_sta_itwt_teardown__init
                     (RpcReqWifiStaItwtTeardown         *message);
size_t rpc__req__wifi_sta_itwt_teardown__get_packed_size
                     (const RpcReqWifiStaItwtTeardown   *message);
size_t rpc__req__wifi_sta_itwt_teardown__pack
                     (const RpcReqWifiStaItwtTeardown   *message,
                      uint8_t             *out);
size_t rpc__req__wifi_sta_itwt_teardown__pack_to_buffer
                     (const RpcReqWifiStaItwtTeardown   *message,
                      ProtobufCBuffer     *buffer);
RpcReqWifiStaItwtTeardown *
       rpc__req__wifi_sta_itwt_teardown__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   rpc__req__wifi_sta_itwt_teardown__free_unpacked
                     (RpcReqWifiStaItwtTeardown *message,
                      ProtobufCAllocator *allocator);
/* RpcRespWifiStaItwtTeardown methods */
void   rpc__resp__wifi_sta_itwt_teardown__init
                     (RpcRespWifiStaItwtTeardown         *message);
size_t rpc__resp__wifi_sta_itwt_teardown__get_packed_size
                     (const RpcRespWifiStaItwtTeardown   *message);
size_t rpc__resp__wifi_sta_itwt_teardown__pack
                     (const RpcRespWifiStaItwtTeardown   *message,
                      uint8_t             *out);
size_t rpc__resp__wifi_sta_itwt_teardown__pack_to_buffer
                     (const RpcRespWifiStaItwtTeardown   *message,
                      ProtobufCBuffer     *buffer);
RpcRespWifiStaItwtTeardown *
       rpc__resp__wifi_sta_itwt_teardown__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   rpc__resp__wifi_sta_itwt_teardown__free_unpacked
                     (RpcRespWifiStaItwtTeardown *message,
                      ProtobufCAllocator *allocator);
/* RpcReqWifiStaItwtSuspend methods */
void   rpc__req__wifi_sta_itwt_suspend__init
                     (RpcReqWifiStaItwtSuspend         *message);
size_t rpc__req__wifi_sta_itwt_suspend__get_packed_size
                     (const RpcReqWifiStaItwtSuspend   *message);
size_t rpc__req__wifi_sta_itwt_suspend__pack
                     (const RpcReqWifiStaItwtSuspend   *message,
                      uint8_t             *out);
size_t rpc__req__wifi_sta_itwt_suspend__pack_to_buffer
                     (const RpcReqWifiStaItwtSuspend   *message,
                      ProtobufCBuffer     *buffer);
RpcReqWifiStaItwtSuspend *
       rpc__req__wifi_sta_itwt_suspend__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   rpc__req__wifi_sta_itwt_suspend__free_unpacked
                     (RpcReqWifiStaItwtSuspend *message,
                      ProtobufCAllocator *allocator);
/* RpcRespWifiStaItwtSuspend methods */
void   rpc__resp__wifi_sta_itwt_suspend__init
                     (RpcRespWifiStaItwtSuspend         *message);
size_t rpc__resp__wifi_sta_itwt_suspend__get_packed_size
                     (const RpcRespWifiStaItwtSuspend   *message);
size_t rpc__resp__wifi_sta_itwt_suspend__pack
                     (const RpcRespWifiStaItwtSuspend   *message,
                      uint8_t             *out);
size_t rpc__resp__wifi_sta_itwt_suspend__pack_to_buffer
                     (const RpcRespWifiStaItwtSuspend   *message,
                      ProtobufCBuffer     *buffer);
RpcRespWifiStaItwtSuspend *
       rpc__resp__wifi_sta_itwt_suspend__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   rpc__resp__wifi_sta_itwt_suspend__free_unpacked
                     (RpcRespWifiStaItwtSuspend *message,
                      ProtobufCAllocator *allocator);
/* RpcReqWifiStaItwtGetFlowIdStatus methods */
void   rpc__req__wifi_sta_itwt_get_flow_id_status__init
                     (RpcReqWifiStaItwtGetFlowIdStatus         *message);
size_t rpc__req__wifi_sta_itwt_get_flow_id_status__get_packed_size
                     (const RpcReqWifiStaItwtGetFlowIdStatus   *message);
size_t rpc__req__wifi_sta_itwt_get_flow_id_status__pack
                     (const RpcReqWifiStaItwtGetFlowIdStatus   *message,
                      uint8_t             *out);
size_t rpc__req__wifi_sta_itwt_get_flow_id_status__pack_to_buffer
                     (const RpcReqWifiStaItwtGetFlowIdStatus   *message,
                      ProtobufCBuffer     *buffer);
RpcReqWifiStaItwtGetFlowIdStatus *
       rpc__req__wifi_sta_itwt_get_flow_id_status__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   rpc__req__wifi_sta_itwt_get_flow_id_status__free_unpacked
                     (RpcReqWifiStaItwtGetFlowIdStatus *message,
                      ProtobufCAllocator *allocator);
/* RpcRespWifiStaItwtGetFlowIdStatus methods */
void   rpc__resp__wifi_sta_itwt_get_flow_id_status__init
                     (RpcRespWifiStaItwtGetFlowIdStatus         *message);
size_t rpc__resp__wifi_sta_itwt_get_flow_id_status__get_packed_size
                     (const RpcRespWifiStaItwtGetFlowIdStatus   *message);
size_t rpc__resp__wifi_sta_itwt_get_flow_id_status__pack
                     (const RpcRespWifiStaItwtGetFlowIdStatus   *message,
                      uint8_t             *out);
size_t rpc__resp__wifi_sta_itwt_get_flow_id_status__pack_to_buffer
                     (const RpcRespWifiStaItwtGetFlowIdStatus   *message,
                      ProtobufCBuffer     *buffer);
RpcRespWifiStaItwtGetFlowIdStatus *
       rpc__resp__wifi_sta_itwt_get_flow_id_status__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   rpc__resp__wifi_sta_itwt_get_flow_id_status__free_unpacked
                     (RpcRespWifiStaItwtGetFlowIdStatus *message,
                      ProtobufCAllocator *allocator);
/* RpcReqWifiStaItwtSendProbeReq methods */
void   rpc__req__wifi_sta_itwt_send_probe_req__init
                     (RpcReqWifiStaItwtSendProbeReq         *message);
size_t rpc__req__wifi_sta_itwt_send_probe_req__get_packed_size
                     (const RpcReqWifiStaItwtSendProbeReq   *message);
size_t rpc__req__wifi_sta_itwt_send_probe_req__pack
                     (const RpcReqWifiStaItwtSendProbeReq   *message,
                      uint8_t             *out);
size_t rpc__req__wifi_sta_itwt_send_probe_req__pack_to_buffer
                     (const RpcReqWifiStaItwtSendProbeReq   *message,
                      ProtobufCBuffer     *buffer);
RpcReqWifiStaItwtSendProbeReq *
       rpc__req__wifi_sta_itwt_send_probe_req__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   rpc__req__wifi_sta_itwt_send_probe_req__free_unpacked
                     (RpcReqWifiStaItwtSendProbeReq *message,
                      ProtobufCAllocator *allocator);
/* RpcRespWifiStaItwtSendProbeReq methods */
void   rpc__resp__wifi_sta_itwt_send_probe_req__init
                     (RpcRespWifiStaItwtSendProbeReq         *message);
size_t rpc__resp__wifi_sta_itwt_send_probe_req__get_packed_size
                     (const RpcRespWifiStaItwtSendProbeReq   *message);
size_t rpc__resp__wifi_sta_itwt_send_probe_req__pack
                     (const RpcRespWifiStaItwtSendProbeReq   *message,
                      uint8_t             *out);
size_t rpc__resp__wifi_sta_itwt_send_probe_req__pack_to_buffer
                     (const RpcRespWifiStaItwtSendProbeReq   *message,
                      ProtobufCBuffer     *buffer);
RpcRespWifiStaItwtSendProbeReq *
       rpc__resp__wifi_sta_itwt_send_probe_req__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   rpc__resp__wifi_sta_itwt_send_probe_req__free_unpacked
                     (RpcRespWifiStaItwtSendProbeReq *message,
                      ProtobufCAllocator *allocator);
/* RpcReqWifiStaItwtSetTargetWakeTimeOffset methods */
void   rpc__req__wifi_sta_itwt_set_target_wake_time_offset__init
                     (RpcReqWifiStaItwtSetTargetWakeTimeOffset         *message);
size_t rpc__req__wifi_sta_itwt_set_target_wake_time_offset__get_packed_size
                     (const RpcReqWifiStaItwtSetTargetWakeTimeOffset   *message);
size_t rpc__req__wifi_sta_itwt_set_target_wake_time_offset__pack
                     (const RpcReqWifiStaItwtSetTargetWakeTimeOffset   *message,
                      uint8_t             *out);
size_t rpc__req__wifi_sta_itwt_set_target_wake_time_offset__pack_to_buffer
                     (const RpcReqWifiStaItwtSetTargetWakeTimeOffset   *message,
                      ProtobufCBuffer     *buffer);
RpcReqWifiStaItwtSetTargetWakeTimeOffset *
       rpc__req__wifi_sta_itwt_set_target_wake_time_offset__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   rpc__req__wifi_sta_itwt_set_target_wake_time_offset__free_unpacked
                     (RpcReqWifiStaItwtSetTargetWakeTimeOffset *message,
                      ProtobufCAllocator *allocator);
/* RpcRespWifiStaItwtSetTargetWakeTimeOffset methods */
void   rpc__resp__wifi_sta_itwt_set_target_wake_time_offset__init
                     (RpcRespWifiStaItwtSetTargetWakeTimeOffset         *message);
size_t rpc__resp__wifi_sta_itwt_set_target_wake_time_offset__get_packed_size
                     (const RpcRespWifiStaItwtSetTargetWakeTimeOffset   *message);
size_t rpc__resp__wifi_sta_itwt_set_target_wake_time_offset__pack
                     (const RpcRespWifiStaItwtSetTargetWakeTimeOffset   *message,
                      uint8_t             *out);
size_t rpc__resp__wifi_sta_itwt_set_target_wake_time_offset__pack_to_buffer
                     (const RpcRespWifiStaItwtSetTargetWakeTimeOffset   *message,
                      ProtobufCBuffer     *buffer);
RpcRespWifiStaItwtSetTargetWakeTimeOffset *
       rpc__resp__wifi_sta_itwt_set_target_wake_time_offset__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   rpc__resp__wifi_sta_itwt_set_target_wake_time_offset__free_unpacked
                     (RpcRespWifiStaItwtSetTargetWakeTimeOffset *message,
                      ProtobufCAllocator *allocator);
/* RpcReqWifiStaTwtConfig methods */
void   rpc__req__wifi_sta_twt_config__init
                     (RpcReqWifiStaTwtConfig         *message);
size_t rpc__req__wifi_sta_twt_config__get_packed_size
                     (const RpcReqWifiStaTwtConfig   *message);
size_t rpc__req__wifi_sta_twt_config__pack
                     (const RpcReqWifiStaTwtConfig   *message,
                      uint8_t             *out);
size_t rpc__req__wifi_sta_twt_config__pack_to_buffer
                     (const RpcReqWifiStaTwtConfig   *message,
                      ProtobufCBuffer     *buffer);
RpcReqWifiStaTwtConfig *
       rpc__req__wifi_sta_twt_config__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   rpc__req__wifi_sta_twt_config__free_unpacked
                     (RpcReqWifiStaTwtConfig *message,
                      ProtobufCAllocator *allocator);
/* RpcRespWifiStaTwtConfig methods */
void   rpc__resp__wifi_sta_twt_config__init
                     (RpcRespWifiStaTwtConfig         *message);
size_t rpc__resp__wifi_sta_twt_config__get_packed_size
                     (const RpcRespWifiStaTwtConfig   *message);
size_t rpc__resp__wifi_sta_twt_config__pack
                     (const RpcRespWifiStaTwtConfig   *message,
                      uint8_t             *out);
size_t rpc__resp__wifi_sta_twt_config__pack_to_buffer
                     (const RpcRespWifiStaTwtConfig   *message,
                      ProtobufCBuffer     *buffer);
RpcRespWifiStaTwtConfig *
       rpc__resp__wifi_sta_twt_config__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   rpc__resp__wifi_sta_twt_config__free_unpacked
                     (RpcRespWifiStaTwtConfig *message,
                      ProtobufCAllocator *allocator);
/* RpcReqGetCoprocessorFwVersion methods */
void   rpc__req__get_coprocessor_fw_version__init
                     (RpcReqGetCoprocessorFwVersion         *message);
size_t rpc__req__get_coprocessor_fw_version__get_packed_size
                     (const RpcReqGetCoprocessorFwVersion   *message);
size_t rpc__req__get_coprocessor_fw_version__pack
                     (const RpcReqGetCoprocessorFwVersion   *message,
                      uint8_t             *out);
size_t rpc__req__get_coprocessor_fw_version__pack_to_buffer
                     (const RpcReqGetCoprocessorFwVersion   *message,
                      ProtobufCBuffer     *buffer);
RpcReqGetCoprocessorFwVersion *
       rpc__req__get_coprocessor_fw_version__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   rpc__req__get_coprocessor_fw_version__free_unpacked
                     (RpcReqGetCoprocessorFwVersion *message,
                      ProtobufCAllocator *allocator);
/* RpcRespGetCoprocessorFwVersion methods */
void   rpc__resp__get_coprocessor_fw_version__init
                     (RpcRespGetCoprocessorFwVersion         *message);
size_t rpc__resp__get_coprocessor_fw_version__get_packed_size
                     (const RpcRespGetCoprocessorFwVersion   *message);
size_t rpc__resp__get_coprocessor_fw_version__pack
                     (const RpcRespGetCoprocessorFwVersion   *message,
                      uint8_t             *out);
size_t rpc__resp__get_coprocessor_fw_version__pack_to_buffer
                     (const RpcRespGetCoprocessorFwVersion   *message,
                      ProtobufCBuffer     *buffer);
RpcRespGetCoprocessorFwVersion *
       rpc__resp__get_coprocessor_fw_version__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   rpc__resp__get_coprocessor_fw_version__free_unpacked
                     (RpcRespGetCoprocessorFwVersion *message,
                      ProtobufCAllocator *allocator);
/* RpcReqSetDhcpDnsStatus methods */
void   rpc__req__set_dhcp_dns_status__init
                     (RpcReqSetDhcpDnsStatus         *message);
size_t rpc__req__set_dhcp_dns_status__get_packed_size
                     (const RpcReqSetDhcpDnsStatus   *message);
size_t rpc__req__set_dhcp_dns_status__pack
                     (const RpcReqSetDhcpDnsStatus   *message,
                      uint8_t             *out);
size_t rpc__req__set_dhcp_dns_status__pack_to_buffer
                     (const RpcReqSetDhcpDnsStatus   *message,
                      ProtobufCBuffer     *buffer);
RpcReqSetDhcpDnsStatus *
       rpc__req__set_dhcp_dns_status__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   rpc__req__set_dhcp_dns_status__free_unpacked
                     (RpcReqSetDhcpDnsStatus *message,
                      ProtobufCAllocator *allocator);
/* RpcRespSetDhcpDnsStatus methods */
void   rpc__resp__set_dhcp_dns_status__init
                     (RpcRespSetDhcpDnsStatus         *message);
size_t rpc__resp__set_dhcp_dns_status__get_packed_size
                     (const RpcRespSetDhcpDnsStatus   *message);
size_t rpc__resp__set_dhcp_dns_status__pack
                     (const RpcRespSetDhcpDnsStatus   *message,
                      uint8_t             *out);
size_t rpc__resp__set_dhcp_dns_status__pack_to_buffer
                     (const RpcRespSetDhcpDnsStatus   *message,
                      ProtobufCBuffer     *buffer);
RpcRespSetDhcpDnsStatus *
       rpc__resp__set_dhcp_dns_status__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   rpc__resp__set_dhcp_dns_status__free_unpacked
                     (RpcRespSetDhcpDnsStatus *message,
                      ProtobufCAllocator *allocator);
/* RpcReqGetDhcpDnsStatus methods */
void   rpc__req__get_dhcp_dns_status__init
                     (RpcReqGetDhcpDnsStatus         *message);
size_t rpc__req__get_dhcp_dns_status__get_packed_size
                     (const RpcReqGetDhcpDnsStatus   *message);
size_t rpc__req__get_dhcp_dns_status__pack
                     (const RpcReqGetDhcpDnsStatus   *message,
                      uint8_t             *out);
size_t rpc__req__get_dhcp_dns_status__pack_to_buffer
                     (const RpcReqGetDhcpDnsStatus   *message,
                      ProtobufCBuffer     *buffer);
RpcReqGetDhcpDnsStatus *
       rpc__req__get_dhcp_dns_status__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   rpc__req__get_dhcp_dns_status__free_unpacked
                     (RpcReqGetDhcpDnsStatus *message,
                      ProtobufCAllocator *allocator);
/* RpcRespGetDhcpDnsStatus methods */
void   rpc__resp__get_dhcp_dns_status__init
                     (RpcRespGetDhcpDnsStatus         *message);
size_t rpc__resp__get_dhcp_dns_status__get_packed_size
                     (const RpcRespGetDhcpDnsStatus   *message);
size_t rpc__resp__get_dhcp_dns_status__pack
                     (const RpcRespGetDhcpDnsStatus   *message,
                      uint8_t             *out);
size_t rpc__resp__get_dhcp_dns_status__pack_to_buffer
                     (const RpcRespGetDhcpDnsStatus   *message,
                      ProtobufCBuffer     *buffer);
RpcRespGetDhcpDnsStatus *
       rpc__resp__get_dhcp_dns_status__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   rpc__resp__get_dhcp_dns_status__free_unpacked
                     (RpcRespGetDhcpDnsStatus *message,
                      ProtobufCAllocator *allocator);
/* RpcReqSuppDppInit methods */
void   rpc__req__supp_dpp_init__init
                     (RpcReqSuppDppInit         *message);
size_t rpc__req__supp_dpp_init__get_packed_size
                     (const RpcReqSuppDppInit   *message);
size_t rpc__req__supp_dpp_init__pack
                     (const RpcReqSuppDppInit   *message,
                      uint8_t             *out);
size_t rpc__req__supp_dpp_init__pack_to_buffer
                     (const RpcReqSuppDppInit   *message,
                      ProtobufCBuffer     *buffer);
RpcReqSuppDppInit *
       rpc__req__supp_dpp_init__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   rpc__req__supp_dpp_init__free_unpacked
                     (RpcReqSuppDppInit *message,
                      ProtobufCAllocator *allocator);
/* RpcRespSuppDppInit methods */
void   rpc__resp__supp_dpp_init__init
                     (RpcRespSuppDppInit         *message);
size_t rpc__resp__supp_dpp_init__get_packed_size
                     (const RpcRespSuppDppInit   *message);
size_t rpc__resp__supp_dpp_init__pack
                     (const RpcRespSuppDppInit   *message,
                      uint8_t             *out);
size_t rpc__resp__supp_dpp_init__pack_to_buffer
                     (const RpcRespSuppDppInit   *message,
                      ProtobufCBuffer     *buffer);
RpcRespSuppDppInit *
       rpc__resp__supp_dpp_init__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   rpc__resp__supp_dpp_init__free_unpacked
                     (RpcRespSuppDppInit *message,
                      ProtobufCAllocator *allocator);
/* RpcReqSuppDppDeinit methods */
void   rpc__req__supp_dpp_deinit__init
                     (RpcReqSuppDppDeinit         *message);
size_t rpc__req__supp_dpp_deinit__get_packed_size
                     (const RpcReqSuppDppDeinit   *message);
size_t rpc__req__supp_dpp_deinit__pack
                     (const RpcReqSuppDppDeinit   *message,
                      uint8_t             *out);
size_t rpc__req__supp_dpp_deinit__pack_to_buffer
                     (const RpcReqSuppDppDeinit   *message,
                      ProtobufCBuffer     *buffer);
RpcReqSuppDppDeinit *
       rpc__req__supp_dpp_deinit__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   rpc__req__supp_dpp_deinit__free_unpacked
                     (RpcReqSuppDppDeinit *message,
                      ProtobufCAllocator *allocator);
/* RpcRespSuppDppDeinit methods */
void   rpc__resp__supp_dpp_deinit__init
                     (RpcRespSuppDppDeinit         *message);
size_t rpc__resp__supp_dpp_deinit__get_packed_size
                     (const RpcRespSuppDppDeinit   *message);
size_t rpc__resp__supp_dpp_deinit__pack
                     (const RpcRespSuppDppDeinit   *message,
                      uint8_t             *out);
size_t rpc__resp__supp_dpp_deinit__pack_to_buffer
                     (const RpcRespSuppDppDeinit   *message,
                      ProtobufCBuffer     *buffer);
RpcRespSuppDppDeinit *
       rpc__resp__supp_dpp_deinit__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   rpc__resp__supp_dpp_deinit__free_unpacked
                     (RpcRespSuppDppDeinit *message,
                      ProtobufCAllocator *allocator);
/* RpcReqSuppDppBootstrapGen methods */
void   rpc__req__supp_dpp_bootstrap_gen__init
                     (RpcReqSuppDppBootstrapGen         *message);
size_t rpc__req__supp_dpp_bootstrap_gen__get_packed_size
                     (const RpcReqSuppDppBootstrapGen   *message);
size_t rpc__req__supp_dpp_bootstrap_gen__pack
                     (const RpcReqSuppDppBootstrapGen   *message,
                      uint8_t             *out);
size_t rpc__req__supp_dpp_bootstrap_gen__pack_to_buffer
                     (const RpcReqSuppDppBootstrapGen   *message,
                      ProtobufCBuffer     *buffer);
RpcReqSuppDppBootstrapGen *
       rpc__req__supp_dpp_bootstrap_gen__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   rpc__req__supp_dpp_bootstrap_gen__free_unpacked
                     (RpcReqSuppDppBootstrapGen *message,
                      ProtobufCAllocator *allocator);
/* RpcRespSuppDppBootstrapGen methods */
void   rpc__resp__supp_dpp_bootstrap_gen__init
                     (RpcRespSuppDppBootstrapGen         *message);
size_t rpc__resp__supp_dpp_bootstrap_gen__get_packed_size
                     (const RpcRespSuppDppBootstrapGen   *message);
size_t rpc__resp__supp_dpp_bootstrap_gen__pack
                     (const RpcRespSuppDppBootstrapGen   *message,
                      uint8_t             *out);
size_t rpc__resp__supp_dpp_bootstrap_gen__pack_to_buffer
                     (const RpcRespSuppDppBootstrapGen   *message,
                      ProtobufCBuffer     *buffer);
RpcRespSuppDppBootstrapGen *
       rpc__resp__supp_dpp_bootstrap_gen__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   rpc__resp__supp_dpp_bootstrap_gen__free_unpacked
                     (RpcRespSuppDppBootstrapGen *message,
                      ProtobufCAllocator *allocator);
/* RpcReqSuppDppStartListen methods */
void   rpc__req__supp_dpp_start_listen__init
                     (RpcReqSuppDppStartListen         *message);
size_t rpc__req__supp_dpp_start_listen__get_packed_size
                     (const RpcReqSuppDppStartListen   *message);
size_t rpc__req__supp_dpp_start_listen__pack
                     (const RpcReqSuppDppStartListen   *message,
                      uint8_t             *out);
size_t rpc__req__supp_dpp_start_listen__pack_to_buffer
                     (const RpcReqSuppDppStartListen   *message,
                      ProtobufCBuffer     *buffer);
RpcReqSuppDppStartListen *
       rpc__req__supp_dpp_start_listen__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   rpc__req__supp_dpp_start_listen__free_unpacked
                     (RpcReqSuppDppStartListen *message,
                      ProtobufCAllocator *allocator);
/* RpcRespSuppDppStartListen methods */
void   rpc__resp__supp_dpp_start_listen__init
                     (RpcRespSuppDppStartListen         *message);
size_t rpc__resp__supp_dpp_start_listen__get_packed_size
                     (const RpcRespSuppDppStartListen   *message);
size_t rpc__resp__supp_dpp_start_listen__pack
                     (const RpcRespSuppDppStartListen   *message,
                      uint8_t             *out);
size_t rpc__resp__supp_dpp_start_listen__pack_to_buffer
                     (const RpcRespSuppDppStartListen   *message,
                      ProtobufCBuffer     *buffer);
RpcRespSuppDppStartListen *
       rpc__resp__supp_dpp_start_listen__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   rpc__resp__supp_dpp_start_listen__free_unpacked
                     (RpcRespSuppDppStartListen *message,
                      ProtobufCAllocator *allocator);
/* RpcReqSuppDppStopListen methods */
void   rpc__req__supp_dpp_stop_listen__init
                     (RpcReqSuppDppStopListen         *message);
size_t rpc__req__supp_dpp_stop_listen__get_packed_size
                     (const RpcReqSuppDppStopListen   *message);
size_t rpc__req__supp_dpp_stop_listen__pack
                     (const RpcReqSuppDppStopListen   *message,
                      uint8_t             *out);
size_t rpc__req__supp_dpp_stop_listen__pack_to_buffer
                     (const RpcReqSuppDppStopListen   *message,
                      ProtobufCBuffer     *buffer);
RpcReqSuppDppStopListen *
       rpc__req__supp_dpp_stop_listen__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   rpc__req__supp_dpp_stop_listen__free_unpacked
                     (RpcReqSuppDppStopListen *message,
                      ProtobufCAllocator *allocator);
/* RpcRespSuppDppStopListen methods */
void   rpc__resp__supp_dpp_stop_listen__init
                     (RpcRespSuppDppStopListen         *message);
size_t rpc__resp__supp_dpp_stop_listen__get_packed_size
                     (const RpcRespSuppDppStopListen   *message);
size_t rpc__resp__supp_dpp_stop_listen__pack
                     (const RpcRespSuppDppStopListen   *message,
                      uint8_t             *out);
size_t rpc__resp__supp_dpp_stop_listen__pack_to_buffer
                     (const RpcRespSuppDppStopListen   *message,
                      ProtobufCBuffer     *buffer);
RpcRespSuppDppStopListen *
       rpc__resp__supp_dpp_stop_listen__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   rpc__resp__supp_dpp_stop_listen__free_unpacked
                     (RpcRespSuppDppStopListen *message,
                      ProtobufCAllocator *allocator);
/* RpcReqIfaceMacAddrSetGet methods */
void   rpc__req__iface_mac_addr_set_get__init
                     (RpcReqIfaceMacAddrSetGet         *message);
size_t rpc__req__iface_mac_addr_set_get__get_packed_size
                     (const RpcReqIfaceMacAddrSetGet   *message);
size_t rpc__req__iface_mac_addr_set_get__pack
                     (const RpcReqIfaceMacAddrSetGet   *message,
                      uint8_t             *out);
size_t rpc__req__iface_mac_addr_set_get__pack_to_buffer
                     (const RpcReqIfaceMacAddrSetGet   *message,
                      ProtobufCBuffer     *buffer);
RpcReqIfaceMacAddrSetGet *
       rpc__req__iface_mac_addr_set_get__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   rpc__req__iface_mac_addr_set_get__free_unpacked
                     (RpcReqIfaceMacAddrSetGet *message,
                      ProtobufCAllocator *allocator);
/* RpcRespIfaceMacAddrSetGet methods */
void   rpc__resp__iface_mac_addr_set_get__init
                     (RpcRespIfaceMacAddrSetGet         *message);
size_t rpc__resp__iface_mac_addr_set_get__get_packed_size
                     (const RpcRespIfaceMacAddrSetGet   *message);
size_t rpc__resp__iface_mac_addr_set_get__pack
                     (const RpcRespIfaceMacAddrSetGet   *message,
                      uint8_t             *out);
size_t rpc__resp__iface_mac_addr_set_get__pack_to_buffer
                     (const RpcRespIfaceMacAddrSetGet   *message,
                      ProtobufCBuffer     *buffer);
RpcRespIfaceMacAddrSetGet *
       rpc__resp__iface_mac_addr_set_get__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   rpc__resp__iface_mac_addr_set_get__free_unpacked
                     (RpcRespIfaceMacAddrSetGet *message,
                      ProtobufCAllocator *allocator);
/* RpcReqIfaceMacAddrLenGet methods */
void   rpc__req__iface_mac_addr_len_get__init
                     (RpcReqIfaceMacAddrLenGet         *message);
size_t rpc__req__iface_mac_addr_len_get__get_packed_size
                     (const RpcReqIfaceMacAddrLenGet   *message);
size_t rpc__req__iface_mac_addr_len_get__pack
                     (const RpcReqIfaceMacAddrLenGet   *message,
                      uint8_t             *out);
size_t rpc__req__iface_mac_addr_len_get__pack_to_buffer
                     (const RpcReqIfaceMacAddrLenGet   *message,
                      ProtobufCBuffer     *buffer);
RpcReqIfaceMacAddrLenGet *
       rpc__req__iface_mac_addr_len_get__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   rpc__req__iface_mac_addr_len_get__free_unpacked
                     (RpcReqIfaceMacAddrLenGet *message,
                      ProtobufCAllocator *allocator);
/* RpcRespIfaceMacAddrLenGet methods */
void   rpc__resp__iface_mac_addr_len_get__init
                     (RpcRespIfaceMacAddrLenGet         *message);
size_t rpc__resp__iface_mac_addr_len_get__get_packed_size
                     (const RpcRespIfaceMacAddrLenGet   *message);
size_t rpc__resp__iface_mac_addr_len_get__pack
                     (const RpcRespIfaceMacAddrLenGet   *message,
                      uint8_t             *out);
size_t rpc__resp__iface_mac_addr_len_get__pack_to_buffer
                     (const RpcRespIfaceMacAddrLenGet   *message,
                      ProtobufCBuffer     *buffer);
RpcRespIfaceMacAddrLenGet *
       rpc__resp__iface_mac_addr_len_get__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   rpc__resp__iface_mac_addr_len_get__free_unpacked
                     (RpcRespIfaceMacAddrLenGet *message,
                      ProtobufCAllocator *allocator);
/* RpcReqFeatureControl methods */
void   rpc__req__feature_control__init
                     (RpcReqFeatureControl         *message);
size_t rpc__req__feature_control__get_packed_size
                     (const RpcReqFeatureControl   *message);
size_t rpc__req__feature_control__pack
                     (const RpcReqFeatureControl   *message,
                      uint8_t             *out);
size_t rpc__req__feature_control__pack_to_buffer
                     (const RpcReqFeatureControl   *message,
                      ProtobufCBuffer     *buffer);
RpcReqFeatureControl *
       rpc__req__feature_control__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   rpc__req__feature_control__free_unpacked
                     (RpcReqFeatureControl *message,
                      ProtobufCAllocator *allocator);
/* RpcRespFeatureControl methods */
void   rpc__resp__feature_control__init
                     (RpcRespFeatureControl         *message);
size_t rpc__resp__feature_control__get_packed_size
                     (const RpcRespFeatureControl   *message);
size_t rpc__resp__feature_control__pack
                     (const RpcRespFeatureControl   *message,
                      uint8_t             *out);
size_t rpc__resp__feature_control__pack_to_buffer
                     (const RpcRespFeatureControl   *message,
                      ProtobufCBuffer     *buffer);
RpcRespFeatureControl *
       rpc__resp__feature_control__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   rpc__resp__feature_control__free_unpacked
                     (RpcRespFeatureControl *message,
                      ProtobufCAllocator *allocator);
/* RpcReqMemMonitor methods */
void   rpc__req__mem_monitor__init
                     (RpcReqMemMonitor         *message);
size_t rpc__req__mem_monitor__get_packed_size
                     (const RpcReqMemMonitor   *message);
size_t rpc__req__mem_monitor__pack
                     (const RpcReqMemMonitor   *message,
                      uint8_t             *out);
size_t rpc__req__mem_monitor__pack_to_buffer
                     (const RpcReqMemMonitor   *message,
                      ProtobufCBuffer     *buffer);
RpcReqMemMonitor *
       rpc__req__mem_monitor__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   rpc__req__mem_monitor__free_unpacked
                     (RpcReqMemMonitor *message,
                      ProtobufCAllocator *allocator);
/* RpcRespMemMonitor methods */
void   rpc__resp__mem_monitor__init
                     (RpcRespMemMonitor         *message);
size_t rpc__resp__mem_monitor__get_packed_size
                     (const RpcRespMemMonitor   *message);
size_t rpc__resp__mem_monitor__pack
                     (const RpcRespMemMonitor   *message,
                      uint8_t             *out);
size_t rpc__resp__mem_monitor__pack_to_buffer
                     (const RpcRespMemMonitor   *message,
                      ProtobufCBuffer     *buffer);
RpcRespMemMonitor *
       rpc__resp__mem_monitor__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   rpc__resp__mem_monitor__free_unpacked
                     (RpcRespMemMonitor *message,
                      ProtobufCAllocator *allocator);
/* RpcEventWifiEventNoArgs methods */
void   rpc__event__wifi_event_no_args__init
                     (RpcEventWifiEventNoArgs         *message);
size_t rpc__event__wifi_event_no_args__get_packed_size
                     (const RpcEventWifiEventNoArgs   *message);
size_t rpc__event__wifi_event_no_args__pack
                     (const RpcEventWifiEventNoArgs   *message,
                      uint8_t             *out);
size_t rpc__event__wifi_event_no_args__pack_to_buffer
                     (const RpcEventWifiEventNoArgs   *message,
                      ProtobufCBuffer     *buffer);
RpcEventWifiEventNoArgs *
       rpc__event__wifi_event_no_args__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   rpc__event__wifi_event_no_args__free_unpacked
                     (RpcEventWifiEventNoArgs *message,
                      ProtobufCAllocator *allocator);
/* RpcEventESPInit methods */
void   rpc__event__espinit__init
                     (RpcEventESPInit         *message);
size_t rpc__event__espinit__get_packed_size
                     (const RpcEventESPInit   *message);
size_t rpc__event__espinit__pack
                     (const RpcEventESPInit   *message,
                      uint8_t             *out);
size_t rpc__event__espinit__pack_to_buffer
                     (const RpcEventESPInit   *message,
                      ProtobufCBuffer     *buffer);
RpcEventESPInit *
       rpc__event__espinit__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   rpc__event__espinit__free_unpacked
                     (RpcEventESPInit *message,
                      ProtobufCAllocator *allocator);
/* RpcEventHeartbeat methods */
void   rpc__event__heartbeat__init
                     (RpcEventHeartbeat         *message);
size_t rpc__event__heartbeat__get_packed_size
                     (const RpcEventHeartbeat   *message);
size_t rpc__event__heartbeat__pack
                     (const RpcEventHeartbeat   *message,
                      uint8_t             *out);
size_t rpc__event__heartbeat__pack_to_buffer
                     (const RpcEventHeartbeat   *message,
                      ProtobufCBuffer     *buffer);
RpcEventHeartbeat *
       rpc__event__heartbeat__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   rpc__event__heartbeat__free_unpacked
                     (RpcEventHeartbeat *message,
                      ProtobufCAllocator *allocator);
/* RpcEventAPStaDisconnected methods */
void   rpc__event__ap__sta_disconnected__init
                     (RpcEventAPStaDisconnected         *message);
size_t rpc__event__ap__sta_disconnected__get_packed_size
                     (const RpcEventAPStaDisconnected   *message);
size_t rpc__event__ap__sta_disconnected__pack
                     (const RpcEventAPStaDisconnected   *message,
                      uint8_t             *out);
size_t rpc__event__ap__sta_disconnected__pack_to_buffer
                     (const RpcEventAPStaDisconnected   *message,
                      ProtobufCBuffer     *buffer);
RpcEventAPStaDisconnected *
       rpc__event__ap__sta_disconnected__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   rpc__event__ap__sta_disconnected__free_unpacked
                     (RpcEventAPStaDisconnected *message,
                      ProtobufCAllocator *allocator);
/* RpcEventAPStaConnected methods */
void   rpc__event__ap__sta_connected__init
                     (RpcEventAPStaConnected         *message);
size_t rpc__event__ap__sta_connected__get_packed_size
                     (const RpcEventAPStaConnected   *message);
size_t rpc__event__ap__sta_connected__pack
                     (const RpcEventAPStaConnected   *message,
                      uint8_t             *out);
size_t rpc__event__ap__sta_connected__pack_to_buffer
                     (const RpcEventAPStaConnected   *message,
                      ProtobufCBuffer     *buffer);
RpcEventAPStaConnected *
       rpc__event__ap__sta_connected__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   rpc__event__ap__sta_connected__free_unpacked
                     (RpcEventAPStaConnected *message,
                      ProtobufCAllocator *allocator);
/* RpcEventStaScanDone methods */
void   rpc__event__sta_scan_done__init
                     (RpcEventStaScanDone         *message);
size_t rpc__event__sta_scan_done__get_packed_size
                     (const RpcEventStaScanDone   *message);
size_t rpc__event__sta_scan_done__pack
                     (const RpcEventStaScanDone   *message,
                      uint8_t             *out);
size_t rpc__event__sta_scan_done__pack_to_buffer
                     (const RpcEventStaScanDone   *message,
                      ProtobufCBuffer     *buffer);
RpcEventStaScanDone *
       rpc__event__sta_scan_done__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   rpc__event__sta_scan_done__free_unpacked
                     (RpcEventStaScanDone *message,
                      ProtobufCAllocator *allocator);
/* RpcEventStaConnected methods */
void   rpc__event__sta_connected__init
                     (RpcEventStaConnected         *message);
size_t rpc__event__sta_connected__get_packed_size
                     (const RpcEventStaConnected   *message);
size_t rpc__event__sta_connected__pack
                     (const RpcEventStaConnected   *message,
                      uint8_t             *out);
size_t rpc__event__sta_connected__pack_to_buffer
                     (const RpcEventStaConnected   *message,
                      ProtobufCBuffer     *buffer);
RpcEventStaConnected *
       rpc__event__sta_connected__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   rpc__event__sta_connected__free_unpacked
                     (RpcEventStaConnected *message,
                      ProtobufCAllocator *allocator);
/* RpcEventStaDisconnected methods */
void   rpc__event__sta_disconnected__init
                     (RpcEventStaDisconnected         *message);
size_t rpc__event__sta_disconnected__get_packed_size
                     (const RpcEventStaDisconnected   *message);
size_t rpc__event__sta_disconnected__pack
                     (const RpcEventStaDisconnected   *message,
                      uint8_t             *out);
size_t rpc__event__sta_disconnected__pack_to_buffer
                     (const RpcEventStaDisconnected   *message,
                      ProtobufCBuffer     *buffer);
RpcEventStaDisconnected *
       rpc__event__sta_disconnected__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   rpc__event__sta_disconnected__free_unpacked
                     (RpcEventStaDisconnected *message,
                      ProtobufCAllocator *allocator);
/* RpcGpioConfig methods */
void   rpc__gpio_config__init
                     (RpcGpioConfig         *message);
size_t rpc__gpio_config__get_packed_size
                     (const RpcGpioConfig   *message);
size_t rpc__gpio_config__pack
                     (const RpcGpioConfig   *message,
                      uint8_t             *out);
size_t rpc__gpio_config__pack_to_buffer
                     (const RpcGpioConfig   *message,
                      ProtobufCBuffer     *buffer);
RpcGpioConfig *
       rpc__gpio_config__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   rpc__gpio_config__free_unpacked
                     (RpcGpioConfig *message,
                      ProtobufCAllocator *allocator);
/* RpcReqGpioConfig methods */
void   rpc__req__gpio_config__init
                     (RpcReqGpioConfig         *message);
size_t rpc__req__gpio_config__get_packed_size
                     (const RpcReqGpioConfig   *message);
size_t rpc__req__gpio_config__pack
                     (const RpcReqGpioConfig   *message,
                      uint8_t             *out);
size_t rpc__req__gpio_config__pack_to_buffer
                     (const RpcReqGpioConfig   *message,
                      ProtobufCBuffer     *buffer);
RpcReqGpioConfig *
       rpc__req__gpio_config__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   rpc__req__gpio_config__free_unpacked
                     (RpcReqGpioConfig *message,
                      ProtobufCAllocator *allocator);
/* RpcRespGpioConfig methods */
void   rpc__resp__gpio_config__init
                     (RpcRespGpioConfig         *message);
size_t rpc__resp__gpio_config__get_packed_size
                     (const RpcRespGpioConfig   *message);
size_t rpc__resp__gpio_config__pack
                     (const RpcRespGpioConfig   *message,
                      uint8_t             *out);
size_t rpc__resp__gpio_config__pack_to_buffer
                     (const RpcRespGpioConfig   *message,
                      ProtobufCBuffer     *buffer);
RpcRespGpioConfig *
       rpc__resp__gpio_config__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   rpc__resp__gpio_config__free_unpacked
                     (RpcRespGpioConfig *message,
                      ProtobufCAllocator *allocator);
/* RpcReqGpioResetPin methods */
void   rpc__req__gpio_reset_pin__init
                     (RpcReqGpioResetPin         *message);
size_t rpc__req__gpio_reset_pin__get_packed_size
                     (const RpcReqGpioResetPin   *message);
size_t rpc__req__gpio_reset_pin__pack
                     (const RpcReqGpioResetPin   *message,
                      uint8_t             *out);
size_t rpc__req__gpio_reset_pin__pack_to_buffer
                     (const RpcReqGpioResetPin   *message,
                      ProtobufCBuffer     *buffer);
RpcReqGpioResetPin *
       rpc__req__gpio_reset_pin__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   rpc__req__gpio_reset_pin__free_unpacked
                     (RpcReqGpioResetPin *message,
                      ProtobufCAllocator *allocator);
/* RpcRespGpioResetPin methods */
void   rpc__resp__gpio_reset_pin__init
                     (RpcRespGpioResetPin         *message);
size_t rpc__resp__gpio_reset_pin__get_packed_size
                     (const RpcRespGpioResetPin   *message);
size_t rpc__resp__gpio_reset_pin__pack
                     (const RpcRespGpioResetPin   *message,
                      uint8_t             *out);
size_t rpc__resp__gpio_reset_pin__pack_to_buffer
                     (const RpcRespGpioResetPin   *message,
                      ProtobufCBuffer     *buffer);
RpcRespGpioResetPin *
       rpc__resp__gpio_reset_pin__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   rpc__resp__gpio_reset_pin__free_unpacked
                     (RpcRespGpioResetPin *message,
                      ProtobufCAllocator *allocator);
/* RpcReqGpioSetLevel methods */
void   rpc__req__gpio_set_level__init
                     (RpcReqGpioSetLevel         *message);
size_t rpc__req__gpio_set_level__get_packed_size
                     (const RpcReqGpioSetLevel   *message);
size_t rpc__req__gpio_set_level__pack
                     (const RpcReqGpioSetLevel   *message,
                      uint8_t             *out);
size_t rpc__req__gpio_set_level__pack_to_buffer
                     (const RpcReqGpioSetLevel   *message,
                      ProtobufCBuffer     *buffer);
RpcReqGpioSetLevel *
       rpc__req__gpio_set_level__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   rpc__req__gpio_set_level__free_unpacked
                     (RpcReqGpioSetLevel *message,
                      ProtobufCAllocator *allocator);
/* RpcRespGpioSetLevel methods */
void   rpc__resp__gpio_set_level__init
                     (RpcRespGpioSetLevel         *message);
size_t rpc__resp__gpio_set_level__get_packed_size
                     (const RpcRespGpioSetLevel   *message);
size_t rpc__resp__gpio_set_level__pack
                     (const RpcRespGpioSetLevel   *message,
                      uint8_t             *out);
size_t rpc__resp__gpio_set_level__pack_to_buffer
                     (const RpcRespGpioSetLevel   *message,
                      ProtobufCBuffer     *buffer);
RpcRespGpioSetLevel *
       rpc__resp__gpio_set_level__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   rpc__resp__gpio_set_level__free_unpacked
                     (RpcRespGpioSetLevel *message,
                      ProtobufCAllocator *allocator);
/* RpcReqGpioGetLevel methods */
void   rpc__req__gpio_get_level__init
                     (RpcReqGpioGetLevel         *message);
size_t rpc__req__gpio_get_level__get_packed_size
                     (const RpcReqGpioGetLevel   *message);
size_t rpc__req__gpio_get_level__pack
                     (const RpcReqGpioGetLevel   *message,
                      uint8_t             *out);
size_t rpc__req__gpio_get_level__pack_to_buffer
                     (const RpcReqGpioGetLevel   *message,
                      ProtobufCBuffer     *buffer);
RpcReqGpioGetLevel *
       rpc__req__gpio_get_level__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   rpc__req__gpio_get_level__free_unpacked
                     (RpcReqGpioGetLevel *message,
                      ProtobufCAllocator *allocator);
/* RpcRespGpioGetLevel methods */
void   rpc__resp__gpio_get_level__init
                     (RpcRespGpioGetLevel         *message);
size_t rpc__resp__gpio_get_level__get_packed_size
                     (const RpcRespGpioGetLevel   *message);
size_t rpc__resp__gpio_get_level__pack
                     (const RpcRespGpioGetLevel   *message,
                      uint8_t             *out);
size_t rpc__resp__gpio_get_level__pack_to_buffer
                     (const RpcRespGpioGetLevel   *message,
                      ProtobufCBuffer     *buffer);
RpcRespGpioGetLevel *
       rpc__resp__gpio_get_level__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   rpc__resp__gpio_get_level__free_unpacked
                     (RpcRespGpioGetLevel *message,
                      ProtobufCAllocator *allocator);
/* RpcReqGpioSetDirection methods */
void   rpc__req__gpio_set_direction__init
                     (RpcReqGpioSetDirection         *message);
size_t rpc__req__gpio_set_direction__get_packed_size
                     (const RpcReqGpioSetDirection   *message);
size_t rpc__req__gpio_set_direction__pack
                     (const RpcReqGpioSetDirection   *message,
                      uint8_t             *out);
size_t rpc__req__gpio_set_direction__pack_to_buffer
                     (const RpcReqGpioSetDirection   *message,
                      ProtobufCBuffer     *buffer);
RpcReqGpioSetDirection *
       rpc__req__gpio_set_direction__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   rpc__req__gpio_set_direction__free_unpacked
                     (RpcReqGpioSetDirection *message,
                      ProtobufCAllocator *allocator);
/* RpcRespGpioSetDirection methods */
void   rpc__resp__gpio_set_direction__init
                     (RpcRespGpioSetDirection         *message);
size_t rpc__resp__gpio_set_direction__get_packed_size
                     (const RpcRespGpioSetDirection   *message);
size_t rpc__resp__gpio_set_direction__pack
                     (const RpcRespGpioSetDirection   *message,
                      uint8_t             *out);
size_t rpc__resp__gpio_set_direction__pack_to_buffer
                     (const RpcRespGpioSetDirection   *message,
                      ProtobufCBuffer     *buffer);
RpcRespGpioSetDirection *
       rpc__resp__gpio_set_direction__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   rpc__resp__gpio_set_direction__free_unpacked
                     (RpcRespGpioSetDirection *message,
                      ProtobufCAllocator *allocator);
/* RpcReqGpioInputEnable methods */
void   rpc__req__gpio_input_enable__init
                     (RpcReqGpioInputEnable         *message);
size_t rpc__req__gpio_input_enable__get_packed_size
                     (const RpcReqGpioInputEnable   *message);
size_t rpc__req__gpio_input_enable__pack
                     (const RpcReqGpioInputEnable   *message,
                      uint8_t             *out);
size_t rpc__req__gpio_input_enable__pack_to_buffer
                     (const RpcReqGpioInputEnable   *message,
                      ProtobufCBuffer     *buffer);
RpcReqGpioInputEnable *
       rpc__req__gpio_input_enable__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   rpc__req__gpio_input_enable__free_unpacked
                     (RpcReqGpioInputEnable *message,
                      ProtobufCAllocator *allocator);
/* RpcRespGpioInputEnable methods */
void   rpc__resp__gpio_input_enable__init
                     (RpcRespGpioInputEnable         *message);
size_t rpc__resp__gpio_input_enable__get_packed_size
                     (const RpcRespGpioInputEnable   *message);
size_t rpc__resp__gpio_input_enable__pack
                     (const RpcRespGpioInputEnable   *message,
                      uint8_t             *out);
size_t rpc__resp__gpio_input_enable__pack_to_buffer
                     (const RpcRespGpioInputEnable   *message,
                      ProtobufCBuffer     *buffer);
RpcRespGpioInputEnable *
       rpc__resp__gpio_input_enable__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   rpc__resp__gpio_input_enable__free_unpacked
                     (RpcRespGpioInputEnable *message,
                      ProtobufCAllocator *allocator);
/* RpcReqGpioSetPullMode methods */
void   rpc__req__gpio_set_pull_mode__init
                     (RpcReqGpioSetPullMode         *message);
size_t rpc__req__gpio_set_pull_mode__get_packed_size
                     (const RpcReqGpioSetPullMode   *message);
size_t rpc__req__gpio_set_pull_mode__pack
                     (const RpcReqGpioSetPullMode   *message,
                      uint8_t             *out);
size_t rpc__req__gpio_set_pull_mode__pack_to_buffer
                     (const RpcReqGpioSetPullMode   *message,
                      ProtobufCBuffer     *buffer);
RpcReqGpioSetPullMode *
       rpc__req__gpio_set_pull_mode__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   rpc__req__gpio_set_pull_mode__free_unpacked
                     (RpcReqGpioSetPullMode *message,
                      ProtobufCAllocator *allocator);
/* RpcRespGpioSetPullMode methods */
void   rpc__resp__gpio_set_pull_mode__init
                     (RpcRespGpioSetPullMode         *message);
size_t rpc__resp__gpio_set_pull_mode__get_packed_size
                     (const RpcRespGpioSetPullMode   *message);
size_t rpc__resp__gpio_set_pull_mode__pack
                     (const RpcRespGpioSetPullMode   *message,
                      uint8_t             *out);
size_t rpc__resp__gpio_set_pull_mode__pack_to_buffer
                     (const RpcRespGpioSetPullMode   *message,
                      ProtobufCBuffer     *buffer);
RpcRespGpioSetPullMode *
       rpc__resp__gpio_set_pull_mode__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   rpc__resp__gpio_set_pull_mode__free_unpacked
                     (RpcRespGpioSetPullMode *message,
                      ProtobufCAllocator *allocator);
/* RpcReqExtCoex methods */
void   rpc__req__ext_coex__init
                     (RpcReqExtCoex         *message);
size_t rpc__req__ext_coex__get_packed_size
                     (const RpcReqExtCoex   *message);
size_t rpc__req__ext_coex__pack
                     (const RpcReqExtCoex   *message,
                      uint8_t             *out);
size_t rpc__req__ext_coex__pack_to_buffer
                     (const RpcReqExtCoex   *message,
                      ProtobufCBuffer     *buffer);
RpcReqExtCoex *
       rpc__req__ext_coex__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   rpc__req__ext_coex__free_unpacked
                     (RpcReqExtCoex *message,
                      ProtobufCAllocator *allocator);
/* RpcRespExtCoex methods */
void   rpc__resp__ext_coex__init
                     (RpcRespExtCoex         *message);
size_t rpc__resp__ext_coex__get_packed_size
                     (const RpcRespExtCoex   *message);
size_t rpc__resp__ext_coex__pack
                     (const RpcRespExtCoex   *message,
                      uint8_t             *out);
size_t rpc__resp__ext_coex__pack_to_buffer
                     (const RpcRespExtCoex   *message,
                      ProtobufCBuffer     *buffer);
RpcRespExtCoex *
       rpc__resp__ext_coex__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   rpc__resp__ext_coex__free_unpacked
                     (RpcRespExtCoex *message,
                      ProtobufCAllocator *allocator);
/* RpcEventDhcpDnsStatus methods */
void   rpc__event__dhcp_dns_status__init
                     (RpcEventDhcpDnsStatus         *message);
size_t rpc__event__dhcp_dns_status__get_packed_size
                     (const RpcEventDhcpDnsStatus   *message);
size_t rpc__event__dhcp_dns_status__pack
                     (const RpcEventDhcpDnsStatus   *message,
                      uint8_t             *out);
size_t rpc__event__dhcp_dns_status__pack_to_buffer
                     (const RpcEventDhcpDnsStatus   *message,
                      ProtobufCBuffer     *buffer);
RpcEventDhcpDnsStatus *
       rpc__event__dhcp_dns_status__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   rpc__event__dhcp_dns_status__free_unpacked
                     (RpcEventDhcpDnsStatus *message,
                      ProtobufCAllocator *allocator);
/* RpcEventStaItwtSetup methods */
void   rpc__event__sta_itwt_setup__init
                     (RpcEventStaItwtSetup         *message);
size_t rpc__event__sta_itwt_setup__get_packed_size
                     (const RpcEventStaItwtSetup   *message);
size_t rpc__event__sta_itwt_setup__pack
                     (const RpcEventStaItwtSetup   *message,
                      uint8_t             *out);
size_t rpc__event__sta_itwt_setup__pack_to_buffer
                     (const RpcEventStaItwtSetup   *message,
                      ProtobufCBuffer     *buffer);
RpcEventStaItwtSetup *
       rpc__event__sta_itwt_setup__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   rpc__event__sta_itwt_setup__free_unpacked
                     (RpcEventStaItwtSetup *message,
                      ProtobufCAllocator *allocator);
/* RpcEventStaItwtTeardown methods */
void   rpc__event__sta_itwt_teardown__init
                     (RpcEventStaItwtTeardown         *message);
size_t rpc__event__sta_itwt_teardown__get_packed_size
                     (const RpcEventStaItwtTeardown   *message);
size_t rpc__event__sta_itwt_teardown__pack
                     (const RpcEventStaItwtTeardown   *message,
                      uint8_t             *out);
size_t rpc__event__sta_itwt_teardown__pack_to_buffer
                     (const RpcEventStaItwtTeardown   *message,
                      ProtobufCBuffer     *buffer);
RpcEventStaItwtTeardown *
       rpc__event__sta_itwt_teardown__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   rpc__event__sta_itwt_teardown__free_unpacked
                     (RpcEventStaItwtTeardown *message,
                      ProtobufCAllocator *allocator);
/* RpcEventStaItwtSuspend methods */
void   rpc__event__sta_itwt_suspend__init
                     (RpcEventStaItwtSuspend         *message);
size_t rpc__event__sta_itwt_suspend__get_packed_size
                     (const RpcEventStaItwtSuspend   *message);
size_t rpc__event__sta_itwt_suspend__pack
                     (const RpcEventStaItwtSuspend   *message,
                      uint8_t             *out);
size_t rpc__event__sta_itwt_suspend__pack_to_buffer
                     (const RpcEventStaItwtSuspend   *message,
                      ProtobufCBuffer     *buffer);
RpcEventStaItwtSuspend *
       rpc__event__sta_itwt_suspend__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   rpc__event__sta_itwt_suspend__free_unpacked
                     (RpcEventStaItwtSuspend *message,
                      ProtobufCAllocator *allocator);
/* RpcEventStaItwtProbe methods */
void   rpc__event__sta_itwt_probe__init
                     (RpcEventStaItwtProbe         *message);
size_t rpc__event__sta_itwt_probe__get_packed_size
                     (const RpcEventStaItwtProbe   *message);
size_t rpc__event__sta_itwt_probe__pack
                     (const RpcEventStaItwtProbe   *message,
                      uint8_t             *out);
size_t rpc__event__sta_itwt_probe__pack_to_buffer
                     (const RpcEventStaItwtProbe   *message,
                      ProtobufCBuffer     *buffer);
RpcEventStaItwtProbe *
       rpc__event__sta_itwt_probe__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   rpc__event__sta_itwt_probe__free_unpacked
                     (RpcEventStaItwtProbe *message,
                      ProtobufCAllocator *allocator);
/* RpcReqWifiStaEnterpriseEnable methods */
void   rpc__req__wifi_sta_enterprise_enable__init
                     (RpcReqWifiStaEnterpriseEnable         *message);
size_t rpc__req__wifi_sta_enterprise_enable__get_packed_size
                     (const RpcReqWifiStaEnterpriseEnable   *message);
size_t rpc__req__wifi_sta_enterprise_enable__pack
                     (const RpcReqWifiStaEnterpriseEnable   *message,
                      uint8_t             *out);
size_t rpc__req__wifi_sta_enterprise_enable__pack_to_buffer
                     (const RpcReqWifiStaEnterpriseEnable   *message,
                      ProtobufCBuffer     *buffer);
RpcReqWifiStaEnterpriseEnable *
       rpc__req__wifi_sta_enterprise_enable__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   rpc__req__wifi_sta_enterprise_enable__free_unpacked
                     (RpcReqWifiStaEnterpriseEnable *message,
                      ProtobufCAllocator *allocator);
/* RpcRespWifiStaEnterpriseEnable methods */
void   rpc__resp__wifi_sta_enterprise_enable__init
                     (RpcRespWifiStaEnterpriseEnable         *message);
size_t rpc__resp__wifi_sta_enterprise_enable__get_packed_size
                     (const RpcRespWifiStaEnterpriseEnable   *message);
size_t rpc__resp__wifi_sta_enterprise_enable__pack
                     (const RpcRespWifiStaEnterpriseEnable   *message,
                      uint8_t             *out);
size_t rpc__resp__wifi_sta_enterprise_enable__pack_to_buffer
                     (const RpcRespWifiStaEnterpriseEnable   *message,
                      ProtobufCBuffer     *buffer);
RpcRespWifiStaEnterpriseEnable *
       rpc__resp__wifi_sta_enterprise_enable__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   rpc__resp__wifi_sta_enterprise_enable__free_unpacked
                     (RpcRespWifiStaEnterpriseEnable *message,
                      ProtobufCAllocator *allocator);
/* RpcReqWifiStaEnterpriseDisable methods */
void   rpc__req__wifi_sta_enterprise_disable__init
                     (RpcReqWifiStaEnterpriseDisable         *message);
size_t rpc__req__wifi_sta_enterprise_disable__get_packed_size
                     (const RpcReqWifiStaEnterpriseDisable   *message);
size_t rpc__req__wifi_sta_enterprise_disable__pack
                     (const RpcReqWifiStaEnterpriseDisable   *message,
                      uint8_t             *out);
size_t rpc__req__wifi_sta_enterprise_disable__pack_to_buffer
                     (const RpcReqWifiStaEnterpriseDisable   *message,
                      ProtobufCBuffer     *buffer);
RpcReqWifiStaEnterpriseDisable *
       rpc__req__wifi_sta_enterprise_disable__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   rpc__req__wifi_sta_enterprise_disable__free_unpacked
                     (RpcReqWifiStaEnterpriseDisable *message,
                      ProtobufCAllocator *allocator);
/* RpcRespWifiStaEnterpriseDisable methods */
void   rpc__resp__wifi_sta_enterprise_disable__init
                     (RpcRespWifiStaEnterpriseDisable         *message);
size_t rpc__resp__wifi_sta_enterprise_disable__get_packed_size
                     (const RpcRespWifiStaEnterpriseDisable   *message);
size_t rpc__resp__wifi_sta_enterprise_disable__pack
                     (const RpcRespWifiStaEnterpriseDisable   *message,
                      uint8_t             *out);
size_t rpc__resp__wifi_sta_enterprise_disable__pack_to_buffer
                     (const RpcRespWifiStaEnterpriseDisable   *message,
                      ProtobufCBuffer     *buffer);
RpcRespWifiStaEnterpriseDisable *
       rpc__resp__wifi_sta_enterprise_disable__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   rpc__resp__wifi_sta_enterprise_disable__free_unpacked
                     (RpcRespWifiStaEnterpriseDisable *message,
                      ProtobufCAllocator *allocator);
/* RpcReqEapSetIdentity methods */
void   rpc__req__eap_set_identity__init
                     (RpcReqEapSetIdentity         *message);
size_t rpc__req__eap_set_identity__get_packed_size
                     (const RpcReqEapSetIdentity   *message);
size_t rpc__req__eap_set_identity__pack
                     (const RpcReqEapSetIdentity   *message,
                      uint8_t             *out);
size_t rpc__req__eap_set_identity__pack_to_buffer
                     (const RpcReqEapSetIdentity   *message,
                      ProtobufCBuffer     *buffer);
RpcReqEapSetIdentity *
       rpc__req__eap_set_identity__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   rpc__req__eap_set_identity__free_unpacked
                     (RpcReqEapSetIdentity *message,
                      ProtobufCAllocator *allocator);
/* RpcRespEapSetIdentity methods */
void   rpc__resp__eap_set_identity__init
                     (RpcRespEapSetIdentity         *message);
size_t rpc__resp__eap_set_identity__get_packed_size
                     (const RpcRespEapSetIdentity   *message);
size_t rpc__resp__eap_set_identity__pack
                     (const RpcRespEapSetIdentity   *message,
                      uint8_t             *out);
size_t rpc__resp__eap_set_identity__pack_to_buffer
                     (const RpcRespEapSetIdentity   *message,
                      ProtobufCBuffer     *buffer);
RpcRespEapSetIdentity *
       rpc__resp__eap_set_identity__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   rpc__resp__eap_set_identity__free_unpacked
                     (RpcRespEapSetIdentity *message,
                      ProtobufCAllocator *allocator);
/* RpcReqEapClearIdentity methods */
void   rpc__req__eap_clear_identity__init
                     (RpcReqEapClearIdentity         *message);
size_t rpc__req__eap_clear_identity__get_packed_size
                     (const RpcReqEapClearIdentity   *message);
size_t rpc__req__eap_clear_identity__pack
                     (const RpcReqEapClearIdentity   *message,
                      uint8_t             *out);
size_t rpc__req__eap_clear_identity__pack_to_buffer
                     (const RpcReqEapClearIdentity   *message,
                      ProtobufCBuffer     *buffer);
RpcReqEapClearIdentity *
       rpc__req__eap_clear_identity__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   rpc__req__eap_clear_identity__free_unpacked
                     (RpcReqEapClearIdentity *message,
                      ProtobufCAllocator *allocator);
/* RpcRespEapClearIdentity methods */
void   rpc__resp__eap_clear_identity__init
                     (RpcRespEapClearIdentity         *message);
size_t rpc__resp__eap_clear_identity__get_packed_size
                     (const RpcRespEapClearIdentity   *message);
size_t rpc__resp__eap_clear_identity__pack
                     (const RpcRespEapClearIdentity   *message,
                      uint8_t             *out);
size_t rpc__resp__eap_clear_identity__pack_to_buffer
                     (const RpcRespEapClearIdentity   *message,
                      ProtobufCBuffer     *buffer);
RpcRespEapClearIdentity *
       rpc__resp__eap_clear_identity__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   rpc__resp__eap_clear_identity__free_unpacked
                     (RpcRespEapClearIdentity *message,
                      ProtobufCAllocator *allocator);
/* RpcReqEapSetUsername methods */
void   rpc__req__eap_set_username__init
                     (RpcReqEapSetUsername         *message);
size_t rpc__req__eap_set_username__get_packed_size
                     (const RpcReqEapSetUsername   *message);
size_t rpc__req__eap_set_username__pack
                     (const RpcReqEapSetUsername   *message,
                      uint8_t             *out);
size_t rpc__req__eap_set_username__pack_to_buffer
                     (const RpcReqEapSetUsername   *message,
                      ProtobufCBuffer     *buffer);
RpcReqEapSetUsername *
       rpc__req__eap_set_username__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   rpc__req__eap_set_username__free_unpacked
                     (RpcReqEapSetUsername *message,
                      ProtobufCAllocator *allocator);
/* RpcRespEapSetUsername methods */
void   rpc__resp__eap_set_username__init
                     (RpcRespEapSetUsername         *message);
size_t rpc__resp__eap_set_username__get_packed_size
                     (const RpcRespEapSetUsername   *message);
size_t rpc__resp__eap_set_username__pack
                     (const RpcRespEapSetUsername   *message,
                      uint8_t             *out);
size_t rpc__resp__eap_set_username__pack_to_buffer
                     (const RpcRespEapSetUsername   *message,
                      ProtobufCBuffer     *buffer);
RpcRespEapSetUsername *
       rpc__resp__eap_set_username__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   rpc__resp__eap_set_username__free_unpacked
                     (RpcRespEapSetUsername *message,
                      ProtobufCAllocator *allocator);
/* RpcReqEapClearUsername methods */
void   rpc__req__eap_clear_username__init
                     (RpcReqEapClearUsername         *message);
size_t rpc__req__eap_clear_username__get_packed_size
                     (const RpcReqEapClearUsername   *message);
size_t rpc__req__eap_clear_username__pack
                     (const RpcReqEapClearUsername   *message,
                      uint8_t             *out);
size_t rpc__req__eap_clear_username__pack_to_buffer
                     (const RpcReqEapClearUsername   *message,
                      ProtobufCBuffer     *buffer);
RpcReqEapClearUsername *
       rpc__req__eap_clear_username__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   rpc__req__eap_clear_username__free_unpacked
                     (RpcReqEapClearUsername *message,
                      ProtobufCAllocator *allocator);
/* RpcRespEapClearUsername methods */
void   rpc__resp__eap_clear_username__init
                     (RpcRespEapClearUsername         *message);
size_t rpc__resp__eap_clear_username__get_packed_size
                     (const RpcRespEapClearUsername   *message);
size_t rpc__resp__eap_clear_username__pack
                     (const RpcRespEapClearUsername   *message,
                      uint8_t             *out);
size_t rpc__resp__eap_clear_username__pack_to_buffer
                     (const RpcRespEapClearUsername   *message,
                      ProtobufCBuffer     *buffer);
RpcRespEapClearUsername *
       rpc__resp__eap_clear_username__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   rpc__resp__eap_clear_username__free_unpacked
                     (RpcRespEapClearUsername *message,
                      ProtobufCAllocator *allocator);
/* RpcReqEapSetPassword methods */
void   rpc__req__eap_set_password__init
                     (RpcReqEapSetPassword         *message);
size_t rpc__req__eap_set_password__get_packed_size
                     (const RpcReqEapSetPassword   *message);
size_t rpc__req__eap_set_password__pack
                     (const RpcReqEapSetPassword   *message,
                      uint8_t             *out);
size_t rpc__req__eap_set_password__pack_to_buffer
                     (const RpcReqEapSetPassword   *message,
                      ProtobufCBuffer     *buffer);
RpcReqEapSetPassword *
       rpc__req__eap_set_password__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   rpc__req__eap_set_password__free_unpacked
                     (RpcReqEapSetPassword *message,
                      ProtobufCAllocator *allocator);
/* RpcRespEapSetPassword methods */
void   rpc__resp__eap_set_password__init
                     (RpcRespEapSetPassword         *message);
size_t rpc__resp__eap_set_password__get_packed_size
                     (const RpcRespEapSetPassword   *message);
size_t rpc__resp__eap_set_password__pack
                     (const RpcRespEapSetPassword   *message,
                      uint8_t             *out);
size_t rpc__resp__eap_set_password__pack_to_buffer
                     (const RpcRespEapSetPassword   *message,
                      ProtobufCBuffer     *buffer);
RpcRespEapSetPassword *
       rpc__resp__eap_set_password__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   rpc__resp__eap_set_password__free_unpacked
                     (RpcRespEapSetPassword *message,
                      ProtobufCAllocator *allocator);
/* RpcReqEapClearPassword methods */
void   rpc__req__eap_clear_password__init
                     (RpcReqEapClearPassword         *message);
size_t rpc__req__eap_clear_password__get_packed_size
                     (const RpcReqEapClearPassword   *message);
size_t rpc__req__eap_clear_password__pack
                     (const RpcReqEapClearPassword   *message,
                      uint8_t             *out);
size_t rpc__req__eap_clear_password__pack_to_buffer
                     (const RpcReqEapClearPassword   *message,
                      ProtobufCBuffer     *buffer);
RpcReqEapClearPassword *
       rpc__req__eap_clear_password__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   rpc__req__eap_clear_password__free_unpacked
                     (RpcReqEapClearPassword *message,
                      ProtobufCAllocator *allocator);
/* RpcRespEapClearPassword methods */
void   rpc__resp__eap_clear_password__init
                     (RpcRespEapClearPassword         *message);
size_t rpc__resp__eap_clear_password__get_packed_size
                     (const RpcRespEapClearPassword   *message);
size_t rpc__resp__eap_clear_password__pack
                     (const RpcRespEapClearPassword   *message,
                      uint8_t             *out);
size_t rpc__resp__eap_clear_password__pack_to_buffer
                     (const RpcRespEapClearPassword   *message,
                      ProtobufCBuffer     *buffer);
RpcRespEapClearPassword *
       rpc__resp__eap_clear_password__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   rpc__resp__eap_clear_password__free_unpacked
                     (RpcRespEapClearPassword *message,
                      ProtobufCAllocator *allocator);
/* RpcReqEapSetNewPassword methods */
void   rpc__req__eap_set_new_password__init
                     (RpcReqEapSetNewPassword         *message);
size_t rpc__req__eap_set_new_password__get_packed_size
                     (const RpcReqEapSetNewPassword   *message);
size_t rpc__req__eap_set_new_password__pack
                     (const RpcReqEapSetNewPassword   *message,
                      uint8_t             *out);
size_t rpc__req__eap_set_new_password__pack_to_buffer
                     (const RpcReqEapSetNewPassword   *message,
                      ProtobufCBuffer     *buffer);
RpcReqEapSetNewPassword *
       rpc__req__eap_set_new_password__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   rpc__req__eap_set_new_password__free_unpacked
                     (RpcReqEapSetNewPassword *message,
                      ProtobufCAllocator *allocator);
/* RpcRespEapSetNewPassword methods */
void   rpc__resp__eap_set_new_password__init
                     (RpcRespEapSetNewPassword         *message);
size_t rpc__resp__eap_set_new_password__get_packed_size
                     (const RpcRespEapSetNewPassword   *message);
size_t rpc__resp__eap_set_new_password__pack
                     (const RpcRespEapSetNewPassword   *message,
                      uint8_t             *out);
size_t rpc__resp__eap_set_new_password__pack_to_buffer
                     (const RpcRespEapSetNewPassword   *message,
                      ProtobufCBuffer     *buffer);
RpcRespEapSetNewPassword *
       rpc__resp__eap_set_new_password__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   rpc__resp__eap_set_new_password__free_unpacked
                     (RpcRespEapSetNewPassword *message,
                      ProtobufCAllocator *allocator);
/* RpcReqEapClearNewPassword methods */
void   rpc__req__eap_clear_new_password__init
                     (RpcReqEapClearNewPassword         *message);
size_t rpc__req__eap_clear_new_password__get_packed_size
                     (const RpcReqEapClearNewPassword   *message);
size_t rpc__req__eap_clear_new_password__pack
                     (const RpcReqEapClearNewPassword   *message,
                      uint8_t             *out);
size_t rpc__req__eap_clear_new_password__pack_to_buffer
                     (const RpcReqEapClearNewPassword   *message,
                      ProtobufCBuffer     *buffer);
RpcReqEapClearNewPassword *
       rpc__req__eap_clear_new_password__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   rpc__req__eap_clear_new_password__free_unpacked
                     (RpcReqEapClearNewPassword *message,
                      ProtobufCAllocator *allocator);
/* RpcRespEapClearNewPassword methods */
void   rpc__resp__eap_clear_new_password__init
                     (RpcRespEapClearNewPassword         *message);
size_t rpc__resp__eap_clear_new_password__get_packed_size
                     (const RpcRespEapClearNewPassword   *message);
size_t rpc__resp__eap_clear_new_password__pack
                     (const RpcRespEapClearNewPassword   *message,
                      uint8_t             *out);
size_t rpc__resp__eap_clear_new_password__pack_to_buffer
                     (const RpcRespEapClearNewPassword   *message,
                      ProtobufCBuffer     *buffer);
RpcRespEapClearNewPassword *
       rpc__resp__eap_clear_new_password__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   rpc__resp__eap_clear_new_password__free_unpacked
                     (RpcRespEapClearNewPassword *message,
                      ProtobufCAllocator *allocator);
/* RpcReqEapSetCaCert methods */
void   rpc__req__eap_set_ca_cert__init
                     (RpcReqEapSetCaCert         *message);
size_t rpc__req__eap_set_ca_cert__get_packed_size
                     (const RpcReqEapSetCaCert   *message);
size_t rpc__req__eap_set_ca_cert__pack
                     (const RpcReqEapSetCaCert   *message,
                      uint8_t             *out);
size_t rpc__req__eap_set_ca_cert__pack_to_buffer
                     (const RpcReqEapSetCaCert   *message,
                      ProtobufCBuffer     *buffer);
RpcReqEapSetCaCert *
       rpc__req__eap_set_ca_cert__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   rpc__req__eap_set_ca_cert__free_unpacked
                     (RpcReqEapSetCaCert *message,
                      ProtobufCAllocator *allocator);
/* RpcRespEapSetCaCert methods */
void   rpc__resp__eap_set_ca_cert__init
                     (RpcRespEapSetCaCert         *message);
size_t rpc__resp__eap_set_ca_cert__get_packed_size
                     (const RpcRespEapSetCaCert   *message);
size_t rpc__resp__eap_set_ca_cert__pack
                     (const RpcRespEapSetCaCert   *message,
                      uint8_t             *out);
size_t rpc__resp__eap_set_ca_cert__pack_to_buffer
                     (const RpcRespEapSetCaCert   *message,
                      ProtobufCBuffer     *buffer);
RpcRespEapSetCaCert *
       rpc__resp__eap_set_ca_cert__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   rpc__resp__eap_set_ca_cert__free_unpacked
                     (RpcRespEapSetCaCert *message,
                      ProtobufCAllocator *allocator);
/* RpcReqEapClearCaCert methods */
void   rpc__req__eap_clear_ca_cert__init
                     (RpcReqEapClearCaCert         *message);
size_t rpc__req__eap_clear_ca_cert__get_packed_size
                     (const RpcReqEapClearCaCert   *message);
size_t rpc__req__eap_clear_ca_cert__pack
                     (const RpcReqEapClearCaCert   *message,
                      uint8_t             *out);
size_t rpc__req__eap_clear_ca_cert__pack_to_buffer
                     (const RpcReqEapClearCaCert   *message,
                      ProtobufCBuffer     *buffer);
RpcReqEapClearCaCert *
       rpc__req__eap_clear_ca_cert__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   rpc__req__eap_clear_ca_cert__free_unpacked
                     (RpcReqEapClearCaCert *message,
                      ProtobufCAllocator *allocator);
/* RpcRespEapClearCaCert methods */
void   rpc__resp__eap_clear_ca_cert__init
                     (RpcRespEapClearCaCert         *message);
size_t rpc__resp__eap_clear_ca_cert__get_packed_size
                     (const RpcRespEapClearCaCert   *message);
size_t rpc__resp__eap_clear_ca_cert__pack
                     (const RpcRespEapClearCaCert   *message,
                      uint8_t             *out);
size_t rpc__resp__eap_clear_ca_cert__pack_to_buffer
                     (const RpcRespEapClearCaCert   *message,
                      ProtobufCBuffer     *buffer);
RpcRespEapClearCaCert *
       rpc__resp__eap_clear_ca_cert__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   rpc__resp__eap_clear_ca_cert__free_unpacked
                     (RpcRespEapClearCaCert *message,
                      ProtobufCAllocator *allocator);
/* RpcReqEapSetCertificateAndKey methods */
void   rpc__req__eap_set_certificate_and_key__init
                     (RpcReqEapSetCertificateAndKey         *message);
size_t rpc__req__eap_set_certificate_and_key__get_packed_size
                     (const RpcReqEapSetCertificateAndKey   *message);
size_t rpc__req__eap_set_certificate_and_key__pack
                     (const RpcReqEapSetCertificateAndKey   *message,
                      uint8_t             *out);
size_t rpc__req__eap_set_certificate_and_key__pack_to_buffer
                     (const RpcReqEapSetCertificateAndKey   *message,
                      ProtobufCBuffer     *buffer);
RpcReqEapSetCertificateAndKey *
       rpc__req__eap_set_certificate_and_key__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   rpc__req__eap_set_certificate_and_key__free_unpacked
                     (RpcReqEapSetCertificateAndKey *message,
                      ProtobufCAllocator *allocator);
/* RpcRespEapSetCertificateAndKey methods */
void   rpc__resp__eap_set_certificate_and_key__init
                     (RpcRespEapSetCertificateAndKey         *message);
size_t rpc__resp__eap_set_certificate_and_key__get_packed_size
                     (const RpcRespEapSetCertificateAndKey   *message);
size_t rpc__resp__eap_set_certificate_and_key__pack
                     (const RpcRespEapSetCertificateAndKey   *message,
                      uint8_t             *out);
size_t rpc__resp__eap_set_certificate_and_key__pack_to_buffer
                     (const RpcRespEapSetCertificateAndKey   *message,
                      ProtobufCBuffer     *buffer);
RpcRespEapSetCertificateAndKey *
       rpc__resp__eap_set_certificate_and_key__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   rpc__resp__eap_set_certificate_and_key__free_unpacked
                     (RpcRespEapSetCertificateAndKey *message,
                      ProtobufCAllocator *allocator);
/* RpcReqEapClearCertificateAndKey methods */
void   rpc__req__eap_clear_certificate_and_key__init
                     (RpcReqEapClearCertificateAndKey         *message);
size_t rpc__req__eap_clear_certificate_and_key__get_packed_size
                     (const RpcReqEapClearCertificateAndKey   *message);
size_t rpc__req__eap_clear_certificate_and_key__pack
                     (const RpcReqEapClearCertificateAndKey   *message,
                      uint8_t             *out);
size_t rpc__req__eap_clear_certificate_and_key__pack_to_buffer
                     (const RpcReqEapClearCertificateAndKey   *message,
                      ProtobufCBuffer     *buffer);
RpcReqEapClearCertificateAndKey *
       rpc__req__eap_clear_certificate_and_key__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   rpc__req__eap_clear_certificate_and_key__free_unpacked
                     (RpcReqEapClearCertificateAndKey *message,
                      ProtobufCAllocator *allocator);
/* RpcRespEapClearCertificateAndKey methods */
void   rpc__resp__eap_clear_certificate_and_key__init
                     (RpcRespEapClearCertificateAndKey         *message);
size_t rpc__resp__eap_clear_certificate_and_key__get_packed_size
                     (const RpcRespEapClearCertificateAndKey   *message);
size_t rpc__resp__eap_clear_certificate_and_key__pack
                     (const RpcRespEapClearCertificateAndKey   *message,
                      uint8_t             *out);
size_t rpc__resp__eap_clear_certificate_and_key__pack_to_buffer
                     (const RpcRespEapClearCertificateAndKey   *message,
                      ProtobufCBuffer     *buffer);
RpcRespEapClearCertificateAndKey *
       rpc__resp__eap_clear_certificate_and_key__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   rpc__resp__eap_clear_certificate_and_key__free_unpacked
                     (RpcRespEapClearCertificateAndKey *message,
                      ProtobufCAllocator *allocator);
/* RpcReqEapSetDisableTimeCheck methods */
void   rpc__req__eap_set_disable_time_check__init
                     (RpcReqEapSetDisableTimeCheck         *message);
size_t rpc__req__eap_set_disable_time_check__get_packed_size
                     (const RpcReqEapSetDisableTimeCheck   *message);
size_t rpc__req__eap_set_disable_time_check__pack
                     (const RpcReqEapSetDisableTimeCheck   *message,
                      uint8_t             *out);
size_t rpc__req__eap_set_disable_time_check__pack_to_buffer
                     (const RpcReqEapSetDisableTimeCheck   *message,
                      ProtobufCBuffer     *buffer);
RpcReqEapSetDisableTimeCheck *
       rpc__req__eap_set_disable_time_check__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   rpc__req__eap_set_disable_time_check__free_unpacked
                     (RpcReqEapSetDisableTimeCheck *message,
                      ProtobufCAllocator *allocator);
/* RpcRespEapSetDisableTimeCheck methods */
void   rpc__resp__eap_set_disable_time_check__init
                     (RpcRespEapSetDisableTimeCheck         *message);
size_t rpc__resp__eap_set_disable_time_check__get_packed_size
                     (const RpcRespEapSetDisableTimeCheck   *message);
size_t rpc__resp__eap_set_disable_time_check__pack
                     (const RpcRespEapSetDisableTimeCheck   *message,
                      uint8_t             *out);
size_t rpc__resp__eap_set_disable_time_check__pack_to_buffer
                     (const RpcRespEapSetDisableTimeCheck   *message,
                      ProtobufCBuffer     *buffer);
RpcRespEapSetDisableTimeCheck *
       rpc__resp__eap_set_disable_time_check__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   rpc__resp__eap_set_disable_time_check__free_unpacked
                     (RpcRespEapSetDisableTimeCheck *message,
                      ProtobufCAllocator *allocator);
/* RpcReqEapGetDisableTimeCheck methods */
void   rpc__req__eap_get_disable_time_check__init
                     (RpcReqEapGetDisableTimeCheck         *message);
size_t rpc__req__eap_get_disable_time_check__get_packed_size
                     (const RpcReqEapGetDisableTimeCheck   *message);
size_t rpc__req__eap_get_disable_time_check__pack
                     (const RpcReqEapGetDisableTimeCheck   *message,
                      uint8_t             *out);
size_t rpc__req__eap_get_disable_time_check__pack_to_buffer
                     (const RpcReqEapGetDisableTimeCheck   *message,
                      ProtobufCBuffer     *buffer);
RpcReqEapGetDisableTimeCheck *
       rpc__req__eap_get_disable_time_check__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   rpc__req__eap_get_disable_time_check__free_unpacked
                     (RpcReqEapGetDisableTimeCheck *message,
                      ProtobufCAllocator *allocator);
/* RpcRespEapGetDisableTimeCheck methods */
void   rpc__resp__eap_get_disable_time_check__init
                     (RpcRespEapGetDisableTimeCheck         *message);
size_t rpc__resp__eap_get_disable_time_check__get_packed_size
                     (const RpcRespEapGetDisableTimeCheck   *message);
size_t rpc__resp__eap_get_disable_time_check__pack
                     (const RpcRespEapGetDisableTimeCheck   *message,
                      uint8_t             *out);
size_t rpc__resp__eap_get_disable_time_check__pack_to_buffer
                     (const RpcRespEapGetDisableTimeCheck   *message,
                      ProtobufCBuffer     *buffer);
RpcRespEapGetDisableTimeCheck *
       rpc__resp__eap_get_disable_time_check__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   rpc__resp__eap_get_disable_time_check__free_unpacked
                     (RpcRespEapGetDisableTimeCheck *message,
                      ProtobufCAllocator *allocator);
/* RpcReqEapSetTtlsPhase2Method methods */
void   rpc__req__eap_set_ttls_phase2_method__init
                     (RpcReqEapSetTtlsPhase2Method         *message);
size_t rpc__req__eap_set_ttls_phase2_method__get_packed_size
                     (const RpcReqEapSetTtlsPhase2Method   *message);
size_t rpc__req__eap_set_ttls_phase2_method__pack
                     (const RpcReqEapSetTtlsPhase2Method   *message,
                      uint8_t             *out);
size_t rpc__req__eap_set_ttls_phase2_method__pack_to_buffer
                     (const RpcReqEapSetTtlsPhase2Method   *message,
                      ProtobufCBuffer     *buffer);
RpcReqEapSetTtlsPhase2Method *
       rpc__req__eap_set_ttls_phase2_method__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   rpc__req__eap_set_ttls_phase2_method__free_unpacked
                     (RpcReqEapSetTtlsPhase2Method *message,
                      ProtobufCAllocator *allocator);
/* RpcRespEapSetTtlsPhase2Method methods */
void   rpc__resp__eap_set_ttls_phase2_method__init
                     (RpcRespEapSetTtlsPhase2Method         *message);
size_t rpc__resp__eap_set_ttls_phase2_method__get_packed_size
                     (const RpcRespEapSetTtlsPhase2Method   *message);
size_t rpc__resp__eap_set_ttls_phase2_method__pack
                     (const RpcRespEapSetTtlsPhase2Method   *message,
                      uint8_t             *out);
size_t rpc__resp__eap_set_ttls_phase2_method__pack_to_buffer
                     (const RpcRespEapSetTtlsPhase2Method   *message,
                      ProtobufCBuffer     *buffer);
RpcRespEapSetTtlsPhase2Method *
       rpc__resp__eap_set_ttls_phase2_method__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   rpc__resp__eap_set_ttls_phase2_method__free_unpacked
                     (RpcRespEapSetTtlsPhase2Method *message,
                      ProtobufCAllocator *allocator);
/* RpcReqEapSetSuiteb192bitCertification methods */
void   rpc__req__eap_set_suiteb192bit_certification__init
                     (RpcReqEapSetSuiteb192bitCertification         *message);
size_t rpc__req__eap_set_suiteb192bit_certification__get_packed_size
                     (const RpcReqEapSetSuiteb192bitCertification   *message);
size_t rpc__req__eap_set_suiteb192bit_certification__pack
                     (const RpcReqEapSetSuiteb192bitCertification   *message,
                      uint8_t             *out);
size_t rpc__req__eap_set_suiteb192bit_certification__pack_to_buffer
                     (const RpcReqEapSetSuiteb192bitCertification   *message,
                      ProtobufCBuffer     *buffer);
RpcReqEapSetSuiteb192bitCertification *
       rpc__req__eap_set_suiteb192bit_certification__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   rpc__req__eap_set_suiteb192bit_certification__free_unpacked
                     (RpcReqEapSetSuiteb192bitCertification *message,
                      ProtobufCAllocator *allocator);
/* RpcRespEapSetSuiteb192bitCertification methods */
void   rpc__resp__eap_set_suiteb192bit_certification__init
                     (RpcRespEapSetSuiteb192bitCertification         *message);
size_t rpc__resp__eap_set_suiteb192bit_certification__get_packed_size
                     (const RpcRespEapSetSuiteb192bitCertification   *message);
size_t rpc__resp__eap_set_suiteb192bit_certification__pack
                     (const RpcRespEapSetSuiteb192bitCertification   *message,
                      uint8_t             *out);
size_t rpc__resp__eap_set_suiteb192bit_certification__pack_to_buffer
                     (const RpcRespEapSetSuiteb192bitCertification   *message,
                      ProtobufCBuffer     *buffer);
RpcRespEapSetSuiteb192bitCertification *
       rpc__resp__eap_set_suiteb192bit_certification__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   rpc__resp__eap_set_suiteb192bit_certification__free_unpacked
                     (RpcRespEapSetSuiteb192bitCertification *message,
                      ProtobufCAllocator *allocator);
/* RpcReqEapSetPacFile methods */
void   rpc__req__eap_set_pac_file__init
                     (RpcReqEapSetPacFile         *message);
size_t rpc__req__eap_set_pac_file__get_packed_size
                     (const RpcReqEapSetPacFile   *message);
size_t rpc__req__eap_set_pac_file__pack
                     (const RpcReqEapSetPacFile   *message,
                      uint8_t             *out);
size_t rpc__req__eap_set_pac_file__pack_to_buffer
                     (const RpcReqEapSetPacFile   *message,
                      ProtobufCBuffer     *buffer);
RpcReqEapSetPacFile *
       rpc__req__eap_set_pac_file__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   rpc__req__eap_set_pac_file__free_unpacked
                     (RpcReqEapSetPacFile *message,
                      ProtobufCAllocator *allocator);
/* RpcRespEapSetPacFile methods */
void   rpc__resp__eap_set_pac_file__init
                     (RpcRespEapSetPacFile         *message);
size_t rpc__resp__eap_set_pac_file__get_packed_size
                     (const RpcRespEapSetPacFile   *message);
size_t rpc__resp__eap_set_pac_file__pack
                     (const RpcRespEapSetPacFile   *message,
                      uint8_t             *out);
size_t rpc__resp__eap_set_pac_file__pack_to_buffer
                     (const RpcRespEapSetPacFile   *message,
                      ProtobufCBuffer     *buffer);
RpcRespEapSetPacFile *
       rpc__resp__eap_set_pac_file__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   rpc__resp__eap_set_pac_file__free_unpacked
                     (RpcRespEapSetPacFile *message,
                      ProtobufCAllocator *allocator);
/* RpcReqEapSetFastParams methods */
void   rpc__req__eap_set_fast_params__init
                     (RpcReqEapSetFastParams         *message);
size_t rpc__req__eap_set_fast_params__get_packed_size
                     (const RpcReqEapSetFastParams   *message);
size_t rpc__req__eap_set_fast_params__pack
                     (const RpcReqEapSetFastParams   *message,
                      uint8_t             *out);
size_t rpc__req__eap_set_fast_params__pack_to_buffer
                     (const RpcReqEapSetFastParams   *message,
                      ProtobufCBuffer     *buffer);
RpcReqEapSetFastParams *
       rpc__req__eap_set_fast_params__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   rpc__req__eap_set_fast_params__free_unpacked
                     (RpcReqEapSetFastParams *message,
                      ProtobufCAllocator *allocator);
/* RpcRespEapSetFastParams methods */
void   rpc__resp__eap_set_fast_params__init
                     (RpcRespEapSetFastParams         *message);
size_t rpc__resp__eap_set_fast_params__get_packed_size
                     (const RpcRespEapSetFastParams   *message);
size_t rpc__resp__eap_set_fast_params__pack
                     (const RpcRespEapSetFastParams   *message,
                      uint8_t             *out);
size_t rpc__resp__eap_set_fast_params__pack_to_buffer
                     (const RpcRespEapSetFastParams   *message,
                      ProtobufCBuffer     *buffer);
RpcRespEapSetFastParams *
       rpc__resp__eap_set_fast_params__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   rpc__resp__eap_set_fast_params__free_unpacked
                     (RpcRespEapSetFastParams *message,
                      ProtobufCAllocator *allocator);
/* RpcReqEapUseDefaultCertBundle methods */
void   rpc__req__eap_use_default_cert_bundle__init
                     (RpcReqEapUseDefaultCertBundle         *message);
size_t rpc__req__eap_use_default_cert_bundle__get_packed_size
                     (const RpcReqEapUseDefaultCertBundle   *message);
size_t rpc__req__eap_use_default_cert_bundle__pack
                     (const RpcReqEapUseDefaultCertBundle   *message,
                      uint8_t             *out);
size_t rpc__req__eap_use_default_cert_bundle__pack_to_buffer
                     (const RpcReqEapUseDefaultCertBundle   *message,
                      ProtobufCBuffer     *buffer);
RpcReqEapUseDefaultCertBundle *
       rpc__req__eap_use_default_cert_bundle__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   rpc__req__eap_use_default_cert_bundle__free_unpacked
                     (RpcReqEapUseDefaultCertBundle *message,
                      ProtobufCAllocator *allocator);
/* RpcRespEapUseDefaultCertBundle methods */
void   rpc__resp__eap_use_default_cert_bundle__init
                     (RpcRespEapUseDefaultCertBundle         *message);
size_t rpc__resp__eap_use_default_cert_bundle__get_packed_size
                     (const RpcRespEapUseDefaultCertBundle   *message);
size_t rpc__resp__eap_use_default_cert_bundle__pack
                     (const RpcRespEapUseDefaultCertBundle   *message,
                      uint8_t             *out);
size_t rpc__resp__eap_use_default_cert_bundle__pack_to_buffer
                     (const RpcRespEapUseDefaultCertBundle   *message,
                      ProtobufCBuffer     *buffer);
RpcRespEapUseDefaultCertBundle *
       rpc__resp__eap_use_default_cert_bundle__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   rpc__resp__eap_use_default_cert_bundle__free_unpacked
                     (RpcRespEapUseDefaultCertBundle *message,
                      ProtobufCAllocator *allocator);
/* RpcReqWifiSetOkcSupport methods */
void   rpc__req__wifi_set_okc_support__init
                     (RpcReqWifiSetOkcSupport         *message);
size_t rpc__req__wifi_set_okc_support__get_packed_size
                     (const RpcReqWifiSetOkcSupport   *message);
size_t rpc__req__wifi_set_okc_support__pack
                     (const RpcReqWifiSetOkcSupport   *message,
                      uint8_t             *out);
size_t rpc__req__wifi_set_okc_support__pack_to_buffer
                     (const RpcReqWifiSetOkcSupport   *message,
                      ProtobufCBuffer     *buffer);
RpcReqWifiSetOkcSupport *
       rpc__req__wifi_set_okc_support__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   rpc__req__wifi_set_okc_support__free_unpacked
                     (RpcReqWifiSetOkcSupport *message,
                      ProtobufCAllocator *allocator);
/* RpcRespWifiSetOkcSupport methods */
void   rpc__resp__wifi_set_okc_support__init
                     (RpcRespWifiSetOkcSupport         *message);
size_t rpc__resp__wifi_set_okc_support__get_packed_size
                     (const RpcRespWifiSetOkcSupport   *message);
size_t rpc__resp__wifi_set_okc_support__pack
                     (const RpcRespWifiSetOkcSupport   *message,
                      uint8_t             *out);
size_t rpc__resp__wifi_set_okc_support__pack_to_buffer
                     (const RpcRespWifiSetOkcSupport   *message,
                      ProtobufCBuffer     *buffer);
RpcRespWifiSetOkcSupport *
       rpc__resp__wifi_set_okc_support__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   rpc__resp__wifi_set_okc_support__free_unpacked
                     (RpcRespWifiSetOkcSupport *message,
                      ProtobufCAllocator *allocator);
/* RpcReqEapSetDomainName methods */
void   rpc__req__eap_set_domain_name__init
                     (RpcReqEapSetDomainName         *message);
size_t rpc__req__eap_set_domain_name__get_packed_size
                     (const RpcReqEapSetDomainName   *message);
size_t rpc__req__eap_set_domain_name__pack
                     (const RpcReqEapSetDomainName   *message,
                      uint8_t             *out);
size_t rpc__req__eap_set_domain_name__pack_to_buffer
                     (const RpcReqEapSetDomainName   *message,
                      ProtobufCBuffer     *buffer);
RpcReqEapSetDomainName *
       rpc__req__eap_set_domain_name__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   rpc__req__eap_set_domain_name__free_unpacked
                     (RpcReqEapSetDomainName *message,
                      ProtobufCAllocator *allocator);
/* RpcRespEapSetDomainName methods */
void   rpc__resp__eap_set_domain_name__init
                     (RpcRespEapSetDomainName         *message);
size_t rpc__resp__eap_set_domain_name__get_packed_size
                     (const RpcRespEapSetDomainName   *message);
size_t rpc__resp__eap_set_domain_name__pack
                     (const RpcRespEapSetDomainName   *message,
                      uint8_t             *out);
size_t rpc__resp__eap_set_domain_name__pack_to_buffer
                     (const RpcRespEapSetDomainName   *message,
                      ProtobufCBuffer     *buffer);
RpcRespEapSetDomainName *
       rpc__resp__eap_set_domain_name__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   rpc__resp__eap_set_domain_name__free_unpacked
                     (RpcRespEapSetDomainName *message,
                      ProtobufCAllocator *allocator);
/* RpcReqEapSetEapMethods methods */
void   rpc__req__eap_set_eap_methods__init
                     (RpcReqEapSetEapMethods         *message);
size_t rpc__req__eap_set_eap_methods__get_packed_size
                     (const RpcReqEapSetEapMethods   *message);
size_t rpc__req__eap_set_eap_methods__pack
                     (const RpcReqEapSetEapMethods   *message,
                      uint8_t             *out);
size_t rpc__req__eap_set_eap_methods__pack_to_buffer
                     (const RpcReqEapSetEapMethods   *message,
                      ProtobufCBuffer     *buffer);
RpcReqEapSetEapMethods *
       rpc__req__eap_set_eap_methods__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   rpc__req__eap_set_eap_methods__free_unpacked
                     (RpcReqEapSetEapMethods *message,
                      ProtobufCAllocator *allocator);
/* RpcRespEapSetEapMethods methods */
void   rpc__resp__eap_set_eap_methods__init
                     (RpcRespEapSetEapMethods         *message);
size_t rpc__resp__eap_set_eap_methods__get_packed_size
                     (const RpcRespEapSetEapMethods   *message);
size_t rpc__resp__eap_set_eap_methods__pack
                     (const RpcRespEapSetEapMethods   *message,
                      uint8_t             *out);
size_t rpc__resp__eap_set_eap_methods__pack_to_buffer
                     (const RpcRespEapSetEapMethods   *message,
                      ProtobufCBuffer     *buffer);
RpcRespEapSetEapMethods *
       rpc__resp__eap_set_eap_methods__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   rpc__resp__eap_set_eap_methods__free_unpacked
                     (RpcRespEapSetEapMethods *message,
                      ProtobufCAllocator *allocator);
/* RpcEventSuppDppUriReady methods */
void   rpc__event__supp_dpp_uri_ready__init
                     (RpcEventSuppDppUriReady         *message);
size_t rpc__event__supp_dpp_uri_ready__get_packed_size
                     (const RpcEventSuppDppUriReady   *message);
size_t rpc__event__supp_dpp_uri_ready__pack
                     (const RpcEventSuppDppUriReady   *message,
                      uint8_t             *out);
size_t rpc__event__supp_dpp_uri_ready__pack_to_buffer
                     (const RpcEventSuppDppUriReady   *message,
                      ProtobufCBuffer     *buffer);
RpcEventSuppDppUriReady *
       rpc__event__supp_dpp_uri_ready__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   rpc__event__supp_dpp_uri_ready__free_unpacked
                     (RpcEventSuppDppUriReady *message,
                      ProtobufCAllocator *allocator);
/* RpcEventSuppDppCfgRecvd methods */
void   rpc__event__supp_dpp_cfg_recvd__init
                     (RpcEventSuppDppCfgRecvd         *message);
size_t rpc__event__supp_dpp_cfg_recvd__get_packed_size
                     (const RpcEventSuppDppCfgRecvd   *message);
size_t rpc__event__supp_dpp_cfg_recvd__pack
                     (const RpcEventSuppDppCfgRecvd   *message,
                      uint8_t             *out);
size_t rpc__event__supp_dpp_cfg_recvd__pack_to_buffer
                     (const RpcEventSuppDppCfgRecvd   *message,
                      ProtobufCBuffer     *buffer);
RpcEventSuppDppCfgRecvd *
       rpc__event__supp_dpp_cfg_recvd__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   rpc__event__supp_dpp_cfg_recvd__free_unpacked
                     (RpcEventSuppDppCfgRecvd *message,
                      ProtobufCAllocator *allocator);
/* RpcEventSuppDppFail methods */
void   rpc__event__supp_dpp_fail__init
                     (RpcEventSuppDppFail         *message);
size_t rpc__event__supp_dpp_fail__get_packed_size
                     (const RpcEventSuppDppFail   *message);
size_t rpc__event__supp_dpp_fail__pack
                     (const RpcEventSuppDppFail   *message,
                      uint8_t             *out);
size_t rpc__event__supp_dpp_fail__pack_to_buffer
                     (const RpcEventSuppDppFail   *message,
                      ProtobufCBuffer     *buffer);
RpcEventSuppDppFail *
       rpc__event__supp_dpp_fail__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   rpc__event__supp_dpp_fail__free_unpacked
                     (RpcEventSuppDppFail *message,
                      ProtobufCAllocator *allocator);
/* RpcEventWifiDppUriReady methods */
void   rpc__event__wifi_dpp_uri_ready__init
                     (RpcEventWifiDppUriReady         *message);
size_t rpc__event__wifi_dpp_uri_ready__get_packed_size
                     (const RpcEventWifiDppUriReady   *message);
size_t rpc__event__wifi_dpp_uri_ready__pack
                     (const RpcEventWifiDppUriReady   *message,
                      uint8_t             *out);
size_t rpc__event__wifi_dpp_uri_ready__pack_to_buffer
                     (const RpcEventWifiDppUriReady   *message,
                      ProtobufCBuffer     *buffer);
RpcEventWifiDppUriReady *
       rpc__event__wifi_dpp_uri_ready__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   rpc__event__wifi_dpp_uri_ready__free_unpacked
                     (RpcEventWifiDppUriReady *message,
                      ProtobufCAllocator *allocator);
/* RpcEventWifiDppCfgRecvd methods */
void   rpc__event__wifi_dpp_cfg_recvd__init
                     (RpcEventWifiDppCfgRecvd         *message);
size_t rpc__event__wifi_dpp_cfg_recvd__get_packed_size
                     (const RpcEventWifiDppCfgRecvd   *message);
size_t rpc__event__wifi_dpp_cfg_recvd__pack
                     (const RpcEventWifiDppCfgRecvd   *message,
                      uint8_t             *out);
size_t rpc__event__wifi_dpp_cfg_recvd__pack_to_buffer
                     (const RpcEventWifiDppCfgRecvd   *message,
                      ProtobufCBuffer     *buffer);
RpcEventWifiDppCfgRecvd *
       rpc__event__wifi_dpp_cfg_recvd__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   rpc__event__wifi_dpp_cfg_recvd__free_unpacked
                     (RpcEventWifiDppCfgRecvd *message,
                      ProtobufCAllocator *allocator);
/* RpcEventWifiDppFail methods */
void   rpc__event__wifi_dpp_fail__init
                     (RpcEventWifiDppFail         *message);
size_t rpc__event__wifi_dpp_fail__get_packed_size
                     (const RpcEventWifiDppFail   *message);
size_t rpc__event__wifi_dpp_fail__pack
                     (const RpcEventWifiDppFail   *message,
                      uint8_t             *out);
size_t rpc__event__wifi_dpp_fail__pack_to_buffer
                     (const RpcEventWifiDppFail   *message,
                      ProtobufCBuffer     *buffer);
RpcEventWifiDppFail *
       rpc__event__wifi_dpp_fail__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   rpc__event__wifi_dpp_fail__free_unpacked
                     (RpcEventWifiDppFail *message,
                      ProtobufCAllocator *allocator);
/* RpcReqCustomRpc methods */
void   rpc__req__custom_rpc__init
                     (RpcReqCustomRpc         *message);
size_t rpc__req__custom_rpc__get_packed_size
                     (const RpcReqCustomRpc   *message);
size_t rpc__req__custom_rpc__pack
                     (const RpcReqCustomRpc   *message,
                      uint8_t             *out);
size_t rpc__req__custom_rpc__pack_to_buffer
                     (const RpcReqCustomRpc   *message,
                      ProtobufCBuffer     *buffer);
RpcReqCustomRpc *
       rpc__req__custom_rpc__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   rpc__req__custom_rpc__free_unpacked
                     (RpcReqCustomRpc *message,
                      ProtobufCAllocator *allocator);
/* RpcRespCustomRpc methods */
void   rpc__resp__custom_rpc__init
                     (RpcRespCustomRpc         *message);
size_t rpc__resp__custom_rpc__get_packed_size
                     (const RpcRespCustomRpc   *message);
size_t rpc__resp__custom_rpc__pack
                     (const RpcRespCustomRpc   *message,
                      uint8_t             *out);
size_t rpc__resp__custom_rpc__pack_to_buffer
                     (const RpcRespCustomRpc   *message,
                      ProtobufCBuffer     *buffer);
RpcRespCustomRpc *
       rpc__resp__custom_rpc__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   rpc__resp__custom_rpc__free_unpacked
                     (RpcRespCustomRpc *message,
                      ProtobufCAllocator *allocator);
/* RpcEventCustomRpc methods */
void   rpc__event__custom_rpc__init
                     (RpcEventCustomRpc         *message);
size_t rpc__event__custom_rpc__get_packed_size
                     (const RpcEventCustomRpc   *message);
size_t rpc__event__custom_rpc__pack
                     (const RpcEventCustomRpc   *message,
                      uint8_t             *out);
size_t rpc__event__custom_rpc__pack_to_buffer
                     (const RpcEventCustomRpc   *message,
                      ProtobufCBuffer     *buffer);
RpcEventCustomRpc *
       rpc__event__custom_rpc__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   rpc__event__custom_rpc__free_unpacked
                     (RpcEventCustomRpc *message,
                      ProtobufCAllocator *allocator);
/* RpcEventMemMonitor methods */
void   rpc__event__mem_monitor__init
                     (RpcEventMemMonitor         *message);
size_t rpc__event__mem_monitor__get_packed_size
                     (const RpcEventMemMonitor   *message);
size_t rpc__event__mem_monitor__pack
                     (const RpcEventMemMonitor   *message,
                      uint8_t             *out);
size_t rpc__event__mem_monitor__pack_to_buffer
                     (const RpcEventMemMonitor   *message,
                      ProtobufCBuffer     *buffer);
RpcEventMemMonitor *
       rpc__event__mem_monitor__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   rpc__event__mem_monitor__free_unpacked
                     (RpcEventMemMonitor *message,
                      ProtobufCAllocator *allocator);
/* Rpc methods */
void   rpc__init
                     (Rpc         *message);
size_t rpc__get_packed_size
                     (const Rpc   *message);
size_t rpc__pack
                     (const Rpc   *message,
                      uint8_t             *out);
size_t rpc__pack_to_buffer
                     (const Rpc   *message,
                      ProtobufCBuffer     *buffer);
Rpc *
       rpc__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   rpc__free_unpacked
                     (Rpc *message,
                      ProtobufCAllocator *allocator);
/* --- per-message closures --- */

typedef void (*WifiInitConfig_Closure)
                 (const WifiInitConfig *message,
                  void *closure_data);
typedef void (*WifiCountry_Closure)
                 (const WifiCountry *message,
                  void *closure_data);
typedef void (*WifiActiveScanTime_Closure)
                 (const WifiActiveScanTime *message,
                  void *closure_data);
typedef void (*WifiScanTime_Closure)
                 (const WifiScanTime *message,
                  void *closure_data);
typedef void (*WifiScanChannelBitmap_Closure)
                 (const WifiScanChannelBitmap *message,
                  void *closure_data);
typedef void (*WifiScanConfig_Closure)
                 (const WifiScanConfig *message,
                  void *closure_data);
typedef void (*WifiScanDefaultParams_Closure)
                 (const WifiScanDefaultParams *message,
                  void *closure_data);
typedef void (*WifiHeApInfo_Closure)
                 (const WifiHeApInfo *message,
                  void *closure_data);
typedef void (*WifiApRecord_Closure)
                 (const WifiApRecord *message,
                  void *closure_data);
typedef void (*WifiScanThreshold_Closure)
                 (const WifiScanThreshold *message,
                  void *closure_data);
typedef void (*WifiPmfConfig_Closure)
                 (const WifiPmfConfig *message,
                  void *closure_data);
typedef void (*WifiBssMaxIdleConfig_Closure)
                 (const WifiBssMaxIdleConfig *message,
                  void *closure_data);
typedef void (*WifiApConfig_Closure)
                 (const WifiApConfig *message,
                  void *closure_data);
typedef void (*WifiStaConfig_Closure)
                 (const WifiStaConfig *message,
                  void *closure_data);
typedef void (*WifiConfig_Closure)
                 (const WifiConfig *message,
                  void *closure_data);
typedef void (*WifiStaInfo_Closure)
                 (const WifiStaInfo *message,
                  void *closure_data);
typedef void (*WifiStaList_Closure)
                 (const WifiStaList *message,
                  void *closure_data);
typedef void (*WifiPktRxCtrl_Closure)
                 (const WifiPktRxCtrl *message,
                  void *closure_data);
typedef void (*WifiPromiscuousPkt_Closure)
                 (const WifiPromiscuousPkt *message,
                  void *closure_data);
typedef void (*WifiPromiscuousFilter_Closure)
                 (const WifiPromiscuousFilter *message,
                  void *closure_data);
typedef void (*WifiCsiConfig_Closure)
                 (const WifiCsiConfig *message,
                  void *closure_data);
typedef void (*WifiCsiInfo_Closure)
                 (const WifiCsiInfo *message,
                  void *closure_data);
typedef void (*WifiAntGpio_Closure)
                 (const WifiAntGpio *message,
                  void *closure_data);
typedef void (*WifiAntGpioConfig_Closure)
                 (const WifiAntGpioConfig *message,
                  void *closure_data);
typedef void (*WifiAntConfig_Closure)
                 (const WifiAntConfig *message,
                  void *closure_data);
typedef void (*WifiActionTxReq_Closure)
                 (const WifiActionTxReq *message,
                  void *closure_data);
typedef void (*WifiFtmInitiatorCfg_Closure)
                 (const WifiFtmInitiatorCfg *message,
                  void *closure_data);
typedef void (*WifiEventStaScanDone_Closure)
                 (const WifiEventStaScanDone *message,
                  void *closure_data);
typedef void (*WifiEventStaConnected_Closure)
                 (const WifiEventStaConnected *message,
                  void *closure_data);
typedef void (*WifiEventStaDisconnected_Closure)
                 (const WifiEventStaDisconnected *message,
                  void *closure_data);
typedef void (*WifiEventStaAuthmodeChange_Closure)
                 (const WifiEventStaAuthmodeChange *message,
                  void *closure_data);
typedef void (*WifiEventStaWpsErPin_Closure)
                 (const WifiEventStaWpsErPin *message,
                  void *closure_data);
typedef void (*ApCred_Closure)
                 (const ApCred *message,
                  void *closure_data);
typedef void (*WifiEventStaWpsErSuccess_Closure)
                 (const WifiEventStaWpsErSuccess *message,
                  void *closure_data);
typedef void (*WifiEventApProbeReqRx_Closure)
                 (const WifiEventApProbeReqRx *message,
                  void *closure_data);
typedef void (*WifiEventBssRssiLow_Closure)
                 (const WifiEventBssRssiLow *message,
                  void *closure_data);
typedef void (*WifiFtmReportEntry_Closure)
                 (const WifiFtmReportEntry *message,
                  void *closure_data);
typedef void (*WifiEventFtmReport_Closure)
                 (const WifiEventFtmReport *message,
                  void *closure_data);
typedef void (*WifiEventActionTxStatus_Closure)
                 (const WifiEventActionTxStatus *message,
                  void *closure_data);
typedef void (*WifiEventRocDone_Closure)
                 (const WifiEventRocDone *message,
                  void *closure_data);
typedef void (*WifiEventApWpsRgPin_Closure)
                 (const WifiEventApWpsRgPin *message,
                  void *closure_data);
typedef void (*WifiEventApWpsRgFailReason_Closure)
                 (const WifiEventApWpsRgFailReason *message,
                  void *closure_data);
typedef void (*WifiEventApWpsRgSuccess_Closure)
                 (const WifiEventApWpsRgSuccess *message,
                  void *closure_data);
typedef void (*WifiProtocols_Closure)
                 (const WifiProtocols *message,
                  void *closure_data);
typedef void (*WifiBandwidths_Closure)
                 (const WifiBandwidths *message,
                  void *closure_data);
typedef void (*WifiItwtSetupConfig_Closure)
                 (const WifiItwtSetupConfig *message,
                  void *closure_data);
typedef void (*WifiTwtConfig_Closure)
                 (const WifiTwtConfig *message,
                  void *closure_data);
typedef void (*EspAppDesc_Closure)
                 (const EspAppDesc *message,
                  void *closure_data);
typedef void (*HeapSizeThreshold_Closure)
                 (const HeapSizeThreshold *message,
                  void *closure_data);
typedef void (*MemInfo_Closure)
                 (const MemInfo *message,
                  void *closure_data);
typedef void (*HeapInfo_Closure)
                 (const HeapInfo *message,
                  void *closure_data);
typedef void (*ConnectedSTAList_Closure)
                 (const ConnectedSTAList *message,
                  void *closure_data);
typedef void (*EapFastConfig_Closure)
                 (const EapFastConfig *message,
                  void *closure_data);
typedef void (*RpcReqGetMacAddress_Closure)
                 (const RpcReqGetMacAddress *message,
                  void *closure_data);
typedef void (*RpcRespGetMacAddress_Closure)
                 (const RpcRespGetMacAddress *message,
                  void *closure_data);
typedef void (*RpcReqGetMode_Closure)
                 (const RpcReqGetMode *message,
                  void *closure_data);
typedef void (*RpcRespGetMode_Closure)
                 (const RpcRespGetMode *message,
                  void *closure_data);
typedef void (*RpcReqSetMode_Closure)
                 (const RpcReqSetMode *message,
                  void *closure_data);
typedef void (*RpcRespSetMode_Closure)
                 (const RpcRespSetMode *message,
                  void *closure_data);
typedef void (*RpcReqGetPs_Closure)
                 (const RpcReqGetPs *message,
                  void *closure_data);
typedef void (*RpcRespGetPs_Closure)
                 (const RpcRespGetPs *message,
                  void *closure_data);
typedef void (*RpcReqSetPs_Closure)
                 (const RpcReqSetPs *message,
                  void *closure_data);
typedef void (*RpcRespSetPs_Closure)
                 (const RpcRespSetPs *message,
                  void *closure_data);
typedef void (*RpcReqSetMacAddress_Closure)
                 (const RpcReqSetMacAddress *message,
                  void *closure_data);
typedef void (*RpcRespSetMacAddress_Closure)
                 (const RpcRespSetMacAddress *message,
                  void *closure_data);
typedef void (*RpcReqOTABegin_Closure)
                 (const RpcReqOTABegin *message,
                  void *closure_data);
typedef void (*RpcRespOTABegin_Closure)
                 (const RpcRespOTABegin *message,
                  void *closure_data);
typedef void (*RpcReqOTAWrite_Closure)
                 (const RpcReqOTAWrite *message,
                  void *closure_data);
typedef void (*RpcRespOTAWrite_Closure)
                 (const RpcRespOTAWrite *message,
                  void *closure_data);
typedef void (*RpcReqOTAEnd_Closure)
                 (const RpcReqOTAEnd *message,
                  void *closure_data);
typedef void (*RpcRespOTAEnd_Closure)
                 (const RpcRespOTAEnd *message,
                  void *closure_data);
typedef void (*RpcReqOTAActivate_Closure)
                 (const RpcReqOTAActivate *message,
                  void *closure_data);
typedef void (*RpcRespOTAActivate_Closure)
                 (const RpcRespOTAActivate *message,
                  void *closure_data);
typedef void (*RpcReqAppGetDesc_Closure)
                 (const RpcReqAppGetDesc *message,
                  void *closure_data);
typedef void (*RpcRespAppGetDesc_Closure)
                 (const RpcRespAppGetDesc *message,
                  void *closure_data);
typedef void (*RpcReqWifiSetMaxTxPower_Closure)
                 (const RpcReqWifiSetMaxTxPower *message,
                  void *closure_data);
typedef void (*RpcRespWifiSetMaxTxPower_Closure)
                 (const RpcRespWifiSetMaxTxPower *message,
                  void *closure_data);
typedef void (*RpcReqWifiGetMaxTxPower_Closure)
                 (const RpcReqWifiGetMaxTxPower *message,
                  void *closure_data);
typedef void (*RpcRespWifiGetMaxTxPower_Closure)
                 (const RpcRespWifiGetMaxTxPower *message,
                  void *closure_data);
typedef void (*RpcReqConfigHeartbeat_Closure)
                 (const RpcReqConfigHeartbeat *message,
                  void *closure_data);
typedef void (*RpcRespConfigHeartbeat_Closure)
                 (const RpcRespConfigHeartbeat *message,
                  void *closure_data);
typedef void (*RpcReqWifiInit_Closure)
                 (const RpcReqWifiInit *message,
                  void *closure_data);
typedef void (*RpcRespWifiInit_Closure)
                 (const RpcRespWifiInit *message,
                  void *closure_data);
typedef void (*RpcReqWifiDeinit_Closure)
                 (const RpcReqWifiDeinit *message,
                  void *closure_data);
typedef void (*RpcRespWifiDeinit_Closure)
                 (const RpcRespWifiDeinit *message,
                  void *closure_data);
typedef void (*RpcReqWifiSetConfig_Closure)
                 (const RpcReqWifiSetConfig *message,
                  void *closure_data);
typedef void (*RpcRespWifiSetConfig_Closure)
                 (const RpcRespWifiSetConfig *message,
                  void *closure_data);
typedef void (*RpcReqWifiGetConfig_Closure)
                 (const RpcReqWifiGetConfig *message,
                  void *closure_data);
typedef void (*RpcRespWifiGetConfig_Closure)
                 (const RpcRespWifiGetConfig *message,
                  void *closure_data);
typedef void (*RpcReqWifiConnect_Closure)
                 (const RpcReqWifiConnect *message,
                  void *closure_data);
typedef void (*RpcRespWifiConnect_Closure)
                 (const RpcRespWifiConnect *message,
                  void *closure_data);
typedef void (*RpcReqWifiDisconnect_Closure)
                 (const RpcReqWifiDisconnect *message,
                  void *closure_data);
typedef void (*RpcRespWifiDisconnect_Closure)
                 (const RpcRespWifiDisconnect *message,
                  void *closure_data);
typedef void (*RpcReqWifiStart_Closure)
                 (const RpcReqWifiStart *message,
                  void *closure_data);
typedef void (*RpcRespWifiStart_Closure)
                 (const RpcRespWifiStart *message,
                  void *closure_data);
typedef void (*RpcReqWifiStop_Closure)
                 (const RpcReqWifiStop *message,
                  void *closure_data);
typedef void (*RpcRespWifiStop_Closure)
                 (const RpcRespWifiStop *message,
                  void *closure_data);
typedef void (*RpcReqWifiScanStart_Closure)
                 (const RpcReqWifiScanStart *message,
                  void *closure_data);
typedef void (*RpcRespWifiScanStart_Closure)
                 (const RpcRespWifiScanStart *message,
                  void *closure_data);
typedef void (*RpcReqWifiScanStop_Closure)
                 (const RpcReqWifiScanStop *message,
                  void *closure_data);
typedef void (*RpcRespWifiScanStop_Closure)
                 (const RpcRespWifiScanStop *message,
                  void *closure_data);
typedef void (*RpcReqWifiScanGetApNum_Closure)
                 (const RpcReqWifiScanGetApNum *message,
                  void *closure_data);
typedef void (*RpcRespWifiScanGetApNum_Closure)
                 (const RpcRespWifiScanGetApNum *message,
                  void *closure_data);
typedef void (*RpcReqWifiScanGetApRecords_Closure)
                 (const RpcReqWifiScanGetApRecords *message,
                  void *closure_data);
typedef void (*RpcRespWifiScanGetApRecords_Closure)
                 (const RpcRespWifiScanGetApRecords *message,
                  void *closure_data);
typedef void (*RpcReqWifiScanGetApRecord_Closure)
                 (const RpcReqWifiScanGetApRecord *message,
                  void *closure_data);
typedef void (*RpcRespWifiScanGetApRecord_Closure)
                 (const RpcRespWifiScanGetApRecord *message,
                  void *closure_data);
typedef void (*RpcReqWifiClearApList_Closure)
                 (const RpcReqWifiClearApList *message,
                  void *closure_data);
typedef void (*RpcRespWifiClearApList_Closure)
                 (const RpcRespWifiClearApList *message,
                  void *closure_data);
typedef void (*RpcReqWifiRestore_Closure)
                 (const RpcReqWifiRestore *message,
                  void *closure_data);
typedef void (*RpcRespWifiRestore_Closure)
                 (const RpcRespWifiRestore *message,
                  void *closure_data);
typedef void (*RpcReqWifiClearFastConnect_Closure)
                 (const RpcReqWifiClearFastConnect *message,
                  void *closure_data);
typedef void (*RpcRespWifiClearFastConnect_Closure)
                 (const RpcRespWifiClearFastConnect *message,
                  void *closure_data);
typedef void (*RpcReqWifiDeauthSta_Closure)
                 (const RpcReqWifiDeauthSta *message,
                  void *closure_data);
typedef void (*RpcRespWifiDeauthSta_Closure)
                 (const RpcRespWifiDeauthSta *message,
                  void *closure_data);
typedef void (*RpcReqWifiStaGetApInfo_Closure)
                 (const RpcReqWifiStaGetApInfo *message,
                  void *closure_data);
typedef void (*RpcRespWifiStaGetApInfo_Closure)
                 (const RpcRespWifiStaGetApInfo *message,
                  void *closure_data);
typedef void (*RpcReqWifiSetProtocol_Closure)
                 (const RpcReqWifiSetProtocol *message,
                  void *closure_data);
typedef void (*RpcRespWifiSetProtocol_Closure)
                 (const RpcRespWifiSetProtocol *message,
                  void *closure_data);
typedef void (*RpcReqWifiGetProtocol_Closure)
                 (const RpcReqWifiGetProtocol *message,
                  void *closure_data);
typedef void (*RpcRespWifiGetProtocol_Closure)
                 (const RpcRespWifiGetProtocol *message,
                  void *closure_data);
typedef void (*RpcReqWifiSetBandwidth_Closure)
                 (const RpcReqWifiSetBandwidth *message,
                  void *closure_data);
typedef void (*RpcRespWifiSetBandwidth_Closure)
                 (const RpcRespWifiSetBandwidth *message,
                  void *closure_data);
typedef void (*RpcReqWifiGetBandwidth_Closure)
                 (const RpcReqWifiGetBandwidth *message,
                  void *closure_data);
typedef void (*RpcRespWifiGetBandwidth_Closure)
                 (const RpcRespWifiGetBandwidth *message,
                  void *closure_data);
typedef void (*RpcReqWifiSetChannel_Closure)
                 (const RpcReqWifiSetChannel *message,
                  void *closure_data);
typedef void (*RpcRespWifiSetChannel_Closure)
                 (const RpcRespWifiSetChannel *message,
                  void *closure_data);
typedef void (*RpcReqWifiGetChannel_Closure)
                 (const RpcReqWifiGetChannel *message,
                  void *closure_data);
typedef void (*RpcRespWifiGetChannel_Closure)
                 (const RpcRespWifiGetChannel *message,
                  void *closure_data);
typedef void (*RpcReqWifiSetStorage_Closure)
                 (const RpcReqWifiSetStorage *message,
                  void *closure_data);
typedef void (*RpcRespWifiSetStorage_Closure)
                 (const RpcRespWifiSetStorage *message,
                  void *closure_data);
typedef void (*RpcReqWifiSetCountryCode_Closure)
                 (const RpcReqWifiSetCountryCode *message,
                  void *closure_data);
typedef void (*RpcRespWifiSetCountryCode_Closure)
                 (const RpcRespWifiSetCountryCode *message,
                  void *closure_data);
typedef void (*RpcReqWifiGetCountryCode_Closure)
                 (const RpcReqWifiGetCountryCode *message,
                  void *closure_data);
typedef void (*RpcRespWifiGetCountryCode_Closure)
                 (const RpcRespWifiGetCountryCode *message,
                  void *closure_data);
typedef void (*RpcReqWifiSetCountry_Closure)
                 (const RpcReqWifiSetCountry *message,
                  void *closure_data);
typedef void (*RpcRespWifiSetCountry_Closure)
                 (const RpcRespWifiSetCountry *message,
                  void *closure_data);
typedef void (*RpcReqWifiGetCountry_Closure)
                 (const RpcReqWifiGetCountry *message,
                  void *closure_data);
typedef void (*RpcRespWifiGetCountry_Closure)
                 (const RpcRespWifiGetCountry *message,
                  void *closure_data);
typedef void (*RpcReqWifiApGetStaList_Closure)
                 (const RpcReqWifiApGetStaList *message,
                  void *closure_data);
typedef void (*RpcRespWifiApGetStaList_Closure)
                 (const RpcRespWifiApGetStaList *message,
                  void *closure_data);
typedef void (*RpcReqWifiApGetStaAid_Closure)
                 (const RpcReqWifiApGetStaAid *message,
                  void *closure_data);
typedef void (*RpcReqWifiStaGetNegotiatedPhymode_Closure)
                 (const RpcReqWifiStaGetNegotiatedPhymode *message,
                  void *closure_data);
typedef void (*RpcRespWifiStaGetNegotiatedPhymode_Closure)
                 (const RpcRespWifiStaGetNegotiatedPhymode *message,
                  void *closure_data);
typedef void (*RpcRespWifiApGetStaAid_Closure)
                 (const RpcRespWifiApGetStaAid *message,
                  void *closure_data);
typedef void (*RpcReqWifiStaGetRssi_Closure)
                 (const RpcReqWifiStaGetRssi *message,
                  void *closure_data);
typedef void (*RpcRespWifiStaGetRssi_Closure)
                 (const RpcRespWifiStaGetRssi *message,
                  void *closure_data);
typedef void (*RpcReqWifiScanParams_Closure)
                 (const RpcReqWifiScanParams *message,
                  void *closure_data);
typedef void (*RpcRespWifiScanParams_Closure)
                 (const RpcRespWifiScanParams *message,
                  void *closure_data);
typedef void (*RpcReqWifiStaGetAid_Closure)
                 (const RpcReqWifiStaGetAid *message,
                  void *closure_data);
typedef void (*RpcRespWifiStaGetAid_Closure)
                 (const RpcRespWifiStaGetAid *message,
                  void *closure_data);
typedef void (*RpcReqWifiSetProtocols_Closure)
                 (const RpcReqWifiSetProtocols *message,
                  void *closure_data);
typedef void (*RpcRespWifiSetProtocols_Closure)
                 (const RpcRespWifiSetProtocols *message,
                  void *closure_data);
typedef void (*RpcReqWifiGetProtocols_Closure)
                 (const RpcReqWifiGetProtocols *message,
                  void *closure_data);
typedef void (*RpcRespWifiGetProtocols_Closure)
                 (const RpcRespWifiGetProtocols *message,
                  void *closure_data);
typedef void (*RpcReqWifiSetBandwidths_Closure)
                 (const RpcReqWifiSetBandwidths *message,
                  void *closure_data);
typedef void (*RpcRespWifiSetBandwidths_Closure)
                 (const RpcRespWifiSetBandwidths *message,
                  void *closure_data);
typedef void (*RpcReqWifiGetBandwidths_Closure)
                 (const RpcReqWifiGetBandwidths *message,
                  void *closure_data);
typedef void (*RpcRespWifiGetBandwidths_Closure)
                 (const RpcRespWifiGetBandwidths *message,
                  void *closure_data);
typedef void (*RpcReqWifiSetBand_Closure)
                 (const RpcReqWifiSetBand *message,
                  void *closure_data);
typedef void (*RpcRespWifiSetBand_Closure)
                 (const RpcRespWifiSetBand *message,
                  void *closure_data);
typedef void (*RpcReqWifiGetBand_Closure)
                 (const RpcReqWifiGetBand *message,
                  void *closure_data);
typedef void (*RpcRespWifiGetBand_Closure)
                 (const RpcRespWifiGetBand *message,
                  void *closure_data);
typedef void (*RpcReqWifiSetBandMode_Closure)
                 (const RpcReqWifiSetBandMode *message,
                  void *closure_data);
typedef void (*RpcRespWifiSetBandMode_Closure)
                 (const RpcRespWifiSetBandMode *message,
                  void *closure_data);
typedef void (*RpcReqWifiGetBandMode_Closure)
                 (const RpcReqWifiGetBandMode *message,
                  void *closure_data);
typedef void (*RpcRespWifiGetBandMode_Closure)
                 (const RpcRespWifiGetBandMode *message,
                  void *closure_data);
typedef void (*RpcReqWifiSetInactiveTime_Closure)
                 (const RpcReqWifiSetInactiveTime *message,
                  void *closure_data);
typedef void (*RpcRespWifiSetInactiveTime_Closure)
                 (const RpcRespWifiSetInactiveTime *message,
                  void *closure_data);
typedef void (*RpcReqWifiGetInactiveTime_Closure)
                 (const RpcReqWifiGetInactiveTime *message,
                  void *closure_data);
typedef void (*RpcRespWifiGetInactiveTime_Closure)
                 (const RpcRespWifiGetInactiveTime *message,
                  void *closure_data);
typedef void (*RpcReqWifiDisablePmfConfig_Closure)
                 (const RpcReqWifiDisablePmfConfig *message,
                  void *closure_data);
typedef void (*RpcRespWifiDisablePmfConfig_Closure)
                 (const RpcRespWifiDisablePmfConfig *message,
                  void *closure_data);
typedef void (*RpcReqWifiStaItwtSetup_Closure)
                 (const RpcReqWifiStaItwtSetup *message,
                  void *closure_data);
typedef void (*RpcRespWifiStaItwtSetup_Closure)
                 (const RpcRespWifiStaItwtSetup *message,
                  void *closure_data);
typedef void (*RpcReqWifiStaItwtTeardown_Closure)
                 (const RpcReqWifiStaItwtTeardown *message,
                  void *closure_data);
typedef void (*RpcRespWifiStaItwtTeardown_Closure)
                 (const RpcRespWifiStaItwtTeardown *message,
                  void *closure_data);
typedef void (*RpcReqWifiStaItwtSuspend_Closure)
                 (const RpcReqWifiStaItwtSuspend *message,
                  void *closure_data);
typedef void (*RpcRespWifiStaItwtSuspend_Closure)
                 (const RpcRespWifiStaItwtSuspend *message,
                  void *closure_data);
typedef void (*RpcReqWifiStaItwtGetFlowIdStatus_Closure)
                 (const RpcReqWifiStaItwtGetFlowIdStatus *message,
                  void *closure_data);
typedef void (*RpcRespWifiStaItwtGetFlowIdStatus_Closure)
                 (const RpcRespWifiStaItwtGetFlowIdStatus *message,
                  void *closure_data);
typedef void (*RpcReqWifiStaItwtSendProbeReq_Closure)
                 (const RpcReqWifiStaItwtSendProbeReq *message,
                  void *closure_data);
typedef void (*RpcRespWifiStaItwtSendProbeReq_Closure)
                 (const RpcRespWifiStaItwtSendProbeReq *message,
                  void *closure_data);
typedef void (*RpcReqWifiStaItwtSetTargetWakeTimeOffset_Closure)
                 (const RpcReqWifiStaItwtSetTargetWakeTimeOffset *message,
                  void *closure_data);
typedef void (*RpcRespWifiStaItwtSetTargetWakeTimeOffset_Closure)
                 (const RpcRespWifiStaItwtSetTargetWakeTimeOffset *message,
                  void *closure_data);
typedef void (*RpcReqWifiStaTwtConfig_Closure)
                 (const RpcReqWifiStaTwtConfig *message,
                  void *closure_data);
typedef void (*RpcRespWifiStaTwtConfig_Closure)
                 (const RpcRespWifiStaTwtConfig *message,
                  void *closure_data);
typedef void (*RpcReqGetCoprocessorFwVersion_Closure)
                 (const RpcReqGetCoprocessorFwVersion *message,
                  void *closure_data);
typedef void (*RpcRespGetCoprocessorFwVersion_Closure)
                 (const RpcRespGetCoprocessorFwVersion *message,
                  void *closure_data);
typedef void (*RpcReqSetDhcpDnsStatus_Closure)
                 (const RpcReqSetDhcpDnsStatus *message,
                  void *closure_data);
typedef void (*RpcRespSetDhcpDnsStatus_Closure)
                 (const RpcRespSetDhcpDnsStatus *message,
                  void *closure_data);
typedef void (*RpcReqGetDhcpDnsStatus_Closure)
                 (const RpcReqGetDhcpDnsStatus *message,
                  void *closure_data);
typedef void (*RpcRespGetDhcpDnsStatus_Closure)
                 (const RpcRespGetDhcpDnsStatus *message,
                  void *closure_data);
typedef void (*RpcReqSuppDppInit_Closure)
                 (const RpcReqSuppDppInit *message,
                  void *closure_data);
typedef void (*RpcRespSuppDppInit_Closure)
                 (const RpcRespSuppDppInit *message,
                  void *closure_data);
typedef void (*RpcReqSuppDppDeinit_Closure)
                 (const RpcReqSuppDppDeinit *message,
                  void *closure_data);
typedef void (*RpcRespSuppDppDeinit_Closure)
                 (const RpcRespSuppDppDeinit *message,
                  void *closure_data);
typedef void (*RpcReqSuppDppBootstrapGen_Closure)
                 (const RpcReqSuppDppBootstrapGen *message,
                  void *closure_data);
typedef void (*RpcRespSuppDppBootstrapGen_Closure)
                 (const RpcRespSuppDppBootstrapGen *message,
                  void *closure_data);
typedef void (*RpcReqSuppDppStartListen_Closure)
                 (const RpcReqSuppDppStartListen *message,
                  void *closure_data);
typedef void (*RpcRespSuppDppStartListen_Closure)
                 (const RpcRespSuppDppStartListen *message,
                  void *closure_data);
typedef void (*RpcReqSuppDppStopListen_Closure)
                 (const RpcReqSuppDppStopListen *message,
                  void *closure_data);
typedef void (*RpcRespSuppDppStopListen_Closure)
                 (const RpcRespSuppDppStopListen *message,
                  void *closure_data);
typedef void (*RpcReqIfaceMacAddrSetGet_Closure)
                 (const RpcReqIfaceMacAddrSetGet *message,
                  void *closure_data);
typedef void (*RpcRespIfaceMacAddrSetGet_Closure)
                 (const RpcRespIfaceMacAddrSetGet *message,
                  void *closure_data);
typedef void (*RpcReqIfaceMacAddrLenGet_Closure)
                 (const RpcReqIfaceMacAddrLenGet *message,
                  void *closure_data);
typedef void (*RpcRespIfaceMacAddrLenGet_Closure)
                 (const RpcRespIfaceMacAddrLenGet *message,
                  void *closure_data);
typedef void (*RpcReqFeatureControl_Closure)
                 (const RpcReqFeatureControl *message,
                  void *closure_data);
typedef void (*RpcRespFeatureControl_Closure)
                 (const RpcRespFeatureControl *message,
                  void *closure_data);
typedef void (*RpcReqMemMonitor_Closure)
                 (const RpcReqMemMonitor *message,
                  void *closure_data);
typedef void (*RpcRespMemMonitor_Closure)
                 (const RpcRespMemMonitor *message,
                  void *closure_data);
typedef void (*RpcEventWifiEventNoArgs_Closure)
                 (const RpcEventWifiEventNoArgs *message,
                  void *closure_data);
typedef void (*RpcEventESPInit_Closure)
                 (const RpcEventESPInit *message,
                  void *closure_data);
typedef void (*RpcEventHeartbeat_Closure)
                 (const RpcEventHeartbeat *message,
                  void *closure_data);
typedef void (*RpcEventAPStaDisconnected_Closure)
                 (const RpcEventAPStaDisconnected *message,
                  void *closure_data);
typedef void (*RpcEventAPStaConnected_Closure)
                 (const RpcEventAPStaConnected *message,
                  void *closure_data);
typedef void (*RpcEventStaScanDone_Closure)
                 (const RpcEventStaScanDone *message,
                  void *closure_data);
typedef void (*RpcEventStaConnected_Closure)
                 (const RpcEventStaConnected *message,
                  void *closure_data);
typedef void (*RpcEventStaDisconnected_Closure)
                 (const RpcEventStaDisconnected *message,
                  void *closure_data);
typedef void (*RpcGpioConfig_Closure)
                 (const RpcGpioConfig *message,
                  void *closure_data);
typedef void (*RpcReqGpioConfig_Closure)
                 (const RpcReqGpioConfig *message,
                  void *closure_data);
typedef void (*RpcRespGpioConfig_Closure)
                 (const RpcRespGpioConfig *message,
                  void *closure_data);
typedef void (*RpcReqGpioResetPin_Closure)
                 (const RpcReqGpioResetPin *message,
                  void *closure_data);
typedef void (*RpcRespGpioResetPin_Closure)
                 (const RpcRespGpioResetPin *message,
                  void *closure_data);
typedef void (*RpcReqGpioSetLevel_Closure)
                 (const RpcReqGpioSetLevel *message,
                  void *closure_data);
typedef void (*RpcRespGpioSetLevel_Closure)
                 (const RpcRespGpioSetLevel *message,
                  void *closure_data);
typedef void (*RpcReqGpioGetLevel_Closure)
                 (const RpcReqGpioGetLevel *message,
                  void *closure_data);
typedef void (*RpcRespGpioGetLevel_Closure)
                 (const RpcRespGpioGetLevel *message,
                  void *closure_data);
typedef void (*RpcReqGpioSetDirection_Closure)
                 (const RpcReqGpioSetDirection *message,
                  void *closure_data);
typedef void (*RpcRespGpioSetDirection_Closure)
                 (const RpcRespGpioSetDirection *message,
                  void *closure_data);
typedef void (*RpcReqGpioInputEnable_Closure)
                 (const RpcReqGpioInputEnable *message,
                  void *closure_data);
typedef void (*RpcRespGpioInputEnable_Closure)
                 (const RpcRespGpioInputEnable *message,
                  void *closure_data);
typedef void (*RpcReqGpioSetPullMode_Closure)
                 (const RpcReqGpioSetPullMode *message,
                  void *closure_data);
typedef void (*RpcRespGpioSetPullMode_Closure)
                 (const RpcRespGpioSetPullMode *message,
                  void *closure_data);
typedef void (*RpcReqExtCoex_Closure)
                 (const RpcReqExtCoex *message,
                  void *closure_data);
typedef void (*RpcRespExtCoex_Closure)
                 (const RpcRespExtCoex *message,
                  void *closure_data);
typedef void (*RpcEventDhcpDnsStatus_Closure)
                 (const RpcEventDhcpDnsStatus *message,
                  void *closure_data);
typedef void (*RpcEventStaItwtSetup_Closure)
                 (const RpcEventStaItwtSetup *message,
                  void *closure_data);
typedef void (*RpcEventStaItwtTeardown_Closure)
                 (const RpcEventStaItwtTeardown *message,
                  void *closure_data);
typedef void (*RpcEventStaItwtSuspend_Closure)
                 (const RpcEventStaItwtSuspend *message,
                  void *closure_data);
typedef void (*RpcEventStaItwtProbe_Closure)
                 (const RpcEventStaItwtProbe *message,
                  void *closure_data);
typedef void (*RpcReqWifiStaEnterpriseEnable_Closure)
                 (const RpcReqWifiStaEnterpriseEnable *message,
                  void *closure_data);
typedef void (*RpcRespWifiStaEnterpriseEnable_Closure)
                 (const RpcRespWifiStaEnterpriseEnable *message,
                  void *closure_data);
typedef void (*RpcReqWifiStaEnterpriseDisable_Closure)
                 (const RpcReqWifiStaEnterpriseDisable *message,
                  void *closure_data);
typedef void (*RpcRespWifiStaEnterpriseDisable_Closure)
                 (const RpcRespWifiStaEnterpriseDisable *message,
                  void *closure_data);
typedef void (*RpcReqEapSetIdentity_Closure)
                 (const RpcReqEapSetIdentity *message,
                  void *closure_data);
typedef void (*RpcRespEapSetIdentity_Closure)
                 (const RpcRespEapSetIdentity *message,
                  void *closure_data);
typedef void (*RpcReqEapClearIdentity_Closure)
                 (const RpcReqEapClearIdentity *message,
                  void *closure_data);
typedef void (*RpcRespEapClearIdentity_Closure)
                 (const RpcRespEapClearIdentity *message,
                  void *closure_data);
typedef void (*RpcReqEapSetUsername_Closure)
                 (const RpcReqEapSetUsername *message,
                  void *closure_data);
typedef void (*RpcRespEapSetUsername_Closure)
                 (const RpcRespEapSetUsername *message,
                  void *closure_data);
typedef void (*RpcReqEapClearUsername_Closure)
                 (const RpcReqEapClearUsername *message,
                  void *closure_data);
typedef void (*RpcRespEapClearUsername_Closure)
                 (const RpcRespEapClearUsername *message,
                  void *closure_data);
typedef void (*RpcReqEapSetPassword_Closure)
                 (const RpcReqEapSetPassword *message,
                  void *closure_data);
typedef void (*RpcRespEapSetPassword_Closure)
                 (const RpcRespEapSetPassword *message,
                  void *closure_data);
typedef void (*RpcReqEapClearPassword_Closure)
                 (const RpcReqEapClearPassword *message,
                  void *closure_data);
typedef void (*RpcRespEapClearPassword_Closure)
                 (const RpcRespEapClearPassword *message,
                  void *closure_data);
typedef void (*RpcReqEapSetNewPassword_Closure)
                 (const RpcReqEapSetNewPassword *message,
                  void *closure_data);
typedef void (*RpcRespEapSetNewPassword_Closure)
                 (const RpcRespEapSetNewPassword *message,
                  void *closure_data);
typedef void (*RpcReqEapClearNewPassword_Closure)
                 (const RpcReqEapClearNewPassword *message,
                  void *closure_data);
typedef void (*RpcRespEapClearNewPassword_Closure)
                 (const RpcRespEapClearNewPassword *message,
                  void *closure_data);
typedef void (*RpcReqEapSetCaCert_Closure)
                 (const RpcReqEapSetCaCert *message,
                  void *closure_data);
typedef void (*RpcRespEapSetCaCert_Closure)
                 (const RpcRespEapSetCaCert *message,
                  void *closure_data);
typedef void (*RpcReqEapClearCaCert_Closure)
                 (const RpcReqEapClearCaCert *message,
                  void *closure_data);
typedef void (*RpcRespEapClearCaCert_Closure)
                 (const RpcRespEapClearCaCert *message,
                  void *closure_data);
typedef void (*RpcReqEapSetCertificateAndKey_Closure)
                 (const RpcReqEapSetCertificateAndKey *message,
                  void *closure_data);
typedef void (*RpcRespEapSetCertificateAndKey_Closure)
                 (const RpcRespEapSetCertificateAndKey *message,
                  void *closure_data);
typedef void (*RpcReqEapClearCertificateAndKey_Closure)
                 (const RpcReqEapClearCertificateAndKey *message,
                  void *closure_data);
typedef void (*RpcRespEapClearCertificateAndKey_Closure)
                 (const RpcRespEapClearCertificateAndKey *message,
                  void *closure_data);
typedef void (*RpcReqEapSetDisableTimeCheck_Closure)
                 (const RpcReqEapSetDisableTimeCheck *message,
                  void *closure_data);
typedef void (*RpcRespEapSetDisableTimeCheck_Closure)
                 (const RpcRespEapSetDisableTimeCheck *message,
                  void *closure_data);
typedef void (*RpcReqEapGetDisableTimeCheck_Closure)
                 (const RpcReqEapGetDisableTimeCheck *message,
                  void *closure_data);
typedef void (*RpcRespEapGetDisableTimeCheck_Closure)
                 (const RpcRespEapGetDisableTimeCheck *message,
                  void *closure_data);
typedef void (*RpcReqEapSetTtlsPhase2Method_Closure)
                 (const RpcReqEapSetTtlsPhase2Method *message,
                  void *closure_data);
typedef void (*RpcRespEapSetTtlsPhase2Method_Closure)
                 (const RpcRespEapSetTtlsPhase2Method *message,
                  void *closure_data);
typedef void (*RpcReqEapSetSuiteb192bitCertification_Closure)
                 (const RpcReqEapSetSuiteb192bitCertification *message,
                  void *closure_data);
typedef void (*RpcRespEapSetSuiteb192bitCertification_Closure)
                 (const RpcRespEapSetSuiteb192bitCertification *message,
                  void *closure_data);
typedef void (*RpcReqEapSetPacFile_Closure)
                 (const RpcReqEapSetPacFile *message,
                  void *closure_data);
typedef void (*RpcRespEapSetPacFile_Closure)
                 (const RpcRespEapSetPacFile *message,
                  void *closure_data);
typedef void (*RpcReqEapSetFastParams_Closure)
                 (const RpcReqEapSetFastParams *message,
                  void *closure_data);
typedef void (*RpcRespEapSetFastParams_Closure)
                 (const RpcRespEapSetFastParams *message,
                  void *closure_data);
typedef void (*RpcReqEapUseDefaultCertBundle_Closure)
                 (const RpcReqEapUseDefaultCertBundle *message,
                  void *closure_data);
typedef void (*RpcRespEapUseDefaultCertBundle_Closure)
                 (const RpcRespEapUseDefaultCertBundle *message,
                  void *closure_data);
typedef void (*RpcReqWifiSetOkcSupport_Closure)
                 (const RpcReqWifiSetOkcSupport *message,
                  void *closure_data);
typedef void (*RpcRespWifiSetOkcSupport_Closure)
                 (const RpcRespWifiSetOkcSupport *message,
                  void *closure_data);
typedef void (*RpcReqEapSetDomainName_Closure)
                 (const RpcReqEapSetDomainName *message,
                  void *closure_data);
typedef void (*RpcRespEapSetDomainName_Closure)
                 (const RpcRespEapSetDomainName *message,
                  void *closure_data);
typedef void (*RpcReqEapSetEapMethods_Closure)
                 (const RpcReqEapSetEapMethods *message,
                  void *closure_data);
typedef void (*RpcRespEapSetEapMethods_Closure)
                 (const RpcRespEapSetEapMethods *message,
                  void *closure_data);
typedef void (*RpcEventSuppDppUriReady_Closure)
                 (const RpcEventSuppDppUriReady *message,
                  void *closure_data);
typedef void (*RpcEventSuppDppCfgRecvd_Closure)
                 (const RpcEventSuppDppCfgRecvd *message,
                  void *closure_data);
typedef void (*RpcEventSuppDppFail_Closure)
                 (const RpcEventSuppDppFail *message,
                  void *closure_data);
typedef void (*RpcEventWifiDppUriReady_Closure)
                 (const RpcEventWifiDppUriReady *message,
                  void *closure_data);
typedef void (*RpcEventWifiDppCfgRecvd_Closure)
                 (const RpcEventWifiDppCfgRecvd *message,
                  void *closure_data);
typedef void (*RpcEventWifiDppFail_Closure)
                 (const RpcEventWifiDppFail *message,
                  void *closure_data);
typedef void (*RpcReqCustomRpc_Closure)
                 (const RpcReqCustomRpc *message,
                  void *closure_data);
typedef void (*RpcRespCustomRpc_Closure)
                 (const RpcRespCustomRpc *message,
                  void *closure_data);
typedef void (*RpcEventCustomRpc_Closure)
                 (const RpcEventCustomRpc *message,
                  void *closure_data);
typedef void (*RpcEventMemMonitor_Closure)
                 (const RpcEventMemMonitor *message,
                  void *closure_data);
typedef void (*Rpc_Closure)
                 (const Rpc *message,
                  void *closure_data);

/* --- services --- */


/* --- descriptors --- */

extern const ProtobufCEnumDescriptor    rpc__wifi_bw__descriptor;
extern const ProtobufCEnumDescriptor    rpc__wifi_power_save__descriptor;
extern const ProtobufCEnumDescriptor    rpc__wifi_sec_prot__descriptor;
extern const ProtobufCEnumDescriptor    rpc__status__descriptor;
extern const ProtobufCEnumDescriptor    rpc_cmd__descriptor;
extern const ProtobufCEnumDescriptor    rpc_type__descriptor;
extern const ProtobufCEnumDescriptor    rpc_feature__descriptor;
extern const ProtobufCEnumDescriptor    rpc_feature_command__descriptor;
extern const ProtobufCEnumDescriptor    rpc_feature_option__descriptor;
extern const ProtobufCEnumDescriptor    rpc_id__descriptor;
extern const ProtobufCEnumDescriptor    rpc__gpio_mode__descriptor;
extern const ProtobufCEnumDescriptor    rpc__gpio_pull_mode__descriptor;
extern const ProtobufCEnumDescriptor    rpc__mem_monitor_config__descriptor;
extern const ProtobufCEnumDescriptor    rpc__ext_coex_cmd__descriptor;
extern const ProtobufCMessageDescriptor wifi_init_config__descriptor;
extern const ProtobufCMessageDescriptor wifi_country__descriptor;
extern const ProtobufCMessageDescriptor wifi_active_scan_time__descriptor;
extern const ProtobufCMessageDescriptor wifi_scan_time__descriptor;
extern const ProtobufCMessageDescriptor wifi_scan_channel_bitmap__descriptor;
extern const ProtobufCMessageDescriptor wifi_scan_config__descriptor;
extern const ProtobufCMessageDescriptor wifi_scan_default_params__descriptor;
extern const ProtobufCMessageDescriptor wifi_he_ap_info__descriptor;
extern const ProtobufCMessageDescriptor wifi_ap_record__descriptor;
extern const ProtobufCMessageDescriptor wifi_scan_threshold__descriptor;
extern const ProtobufCMessageDescriptor wifi_pmf_config__descriptor;
extern const ProtobufCMessageDescriptor wifi_bss_max_idle_config__descriptor;
extern const ProtobufCMessageDescriptor wifi_ap_config__descriptor;
extern const ProtobufCMessageDescriptor wifi_sta_config__descriptor;
extern const ProtobufCMessageDescriptor wifi_config__descriptor;
extern const ProtobufCMessageDescriptor wifi_sta_info__descriptor;
extern const ProtobufCMessageDescriptor wifi_sta_list__descriptor;
extern const ProtobufCMessageDescriptor wifi_pkt_rx_ctrl__descriptor;
extern const ProtobufCMessageDescriptor wifi_promiscuous_pkt__descriptor;
extern const ProtobufCMessageDescriptor wifi_promiscuous_filter__descriptor;
extern const ProtobufCMessageDescriptor wifi_csi_config__descriptor;
extern const ProtobufCMessageDescriptor wifi_csi_info__descriptor;
extern const ProtobufCMessageDescriptor wifi_ant_gpio__descriptor;
extern const ProtobufCMessageDescriptor wifi_ant_gpio_config__descriptor;
extern const ProtobufCMessageDescriptor wifi_ant_config__descriptor;
extern const ProtobufCMessageDescriptor wifi_action_tx_req__descriptor;
extern const ProtobufCMessageDescriptor wifi_ftm_initiator_cfg__descriptor;
extern const ProtobufCMessageDescriptor wifi_event_sta_scan_done__descriptor;
extern const ProtobufCMessageDescriptor wifi_event_sta_connected__descriptor;
extern const ProtobufCMessageDescriptor wifi_event_sta_disconnected__descriptor;
extern const ProtobufCMessageDescriptor wifi_event_sta_authmode_change__descriptor;
extern const ProtobufCMessageDescriptor wifi_event_sta_wps_er_pin__descriptor;
extern const ProtobufCMessageDescriptor ap_cred__descriptor;
extern const ProtobufCMessageDescriptor wifi_event_sta_wps_er_success__descriptor;
extern const ProtobufCMessageDescriptor wifi_event_ap_probe_req_rx__descriptor;
extern const ProtobufCMessageDescriptor wifi_event_bss_rssi_low__descriptor;
extern const ProtobufCMessageDescriptor wifi_ftm_report_entry__descriptor;
extern const ProtobufCMessageDescriptor wifi_event_ftm_report__descriptor;
extern const ProtobufCMessageDescriptor wifi_event_action_tx_status__descriptor;
extern const ProtobufCMessageDescriptor wifi_event_roc_done__descriptor;
extern const ProtobufCMessageDescriptor wifi_event_ap_wps_rg_pin__descriptor;
extern const ProtobufCMessageDescriptor wifi_event_ap_wps_rg_fail_reason__descriptor;
extern const ProtobufCMessageDescriptor wifi_event_ap_wps_rg_success__descriptor;
extern const ProtobufCMessageDescriptor wifi_protocols__descriptor;
extern const ProtobufCMessageDescriptor wifi_bandwidths__descriptor;
extern const ProtobufCMessageDescriptor wifi_itwt_setup_config__descriptor;
extern const ProtobufCMessageDescriptor wifi_twt_config__descriptor;
extern const ProtobufCMessageDescriptor esp_app_desc__descriptor;
extern const ProtobufCMessageDescriptor heap_size_threshold__descriptor;
extern const ProtobufCMessageDescriptor mem_info__descriptor;
extern const ProtobufCMessageDescriptor heap_info__descriptor;
extern const ProtobufCMessageDescriptor connected_stalist__descriptor;
extern const ProtobufCMessageDescriptor eap_fast_config__descriptor;
extern const ProtobufCMessageDescriptor rpc__req__get_mac_address__descriptor;
extern const ProtobufCMessageDescriptor rpc__resp__get_mac_address__descriptor;
extern const ProtobufCMessageDescriptor rpc__req__get_mode__descriptor;
extern const ProtobufCMessageDescriptor rpc__resp__get_mode__descriptor;
extern const ProtobufCMessageDescriptor rpc__req__set_mode__descriptor;
extern const ProtobufCMessageDescriptor rpc__resp__set_mode__descriptor;
extern const ProtobufCMessageDescriptor rpc__req__get_ps__descriptor;
extern const ProtobufCMessageDescriptor rpc__resp__get_ps__descriptor;
extern const ProtobufCMessageDescriptor rpc__req__set_ps__descriptor;
extern const ProtobufCMessageDescriptor rpc__resp__set_ps__descriptor;
extern const ProtobufCMessageDescriptor rpc__req__set_mac_address__descriptor;
extern const ProtobufCMessageDescriptor rpc__resp__set_mac_address__descriptor;
extern const ProtobufCMessageDescriptor rpc__req__otabegin__descriptor;
extern const ProtobufCMessageDescriptor rpc__resp__otabegin__descriptor;
extern const ProtobufCMessageDescriptor rpc__req__otawrite__descriptor;
extern const ProtobufCMessageDescriptor rpc__resp__otawrite__descriptor;
extern const ProtobufCMessageDescriptor rpc__req__otaend__descriptor;
extern const ProtobufCMessageDescriptor rpc__resp__otaend__descriptor;
extern const ProtobufCMessageDescriptor rpc__req__otaactivate__descriptor;
extern const ProtobufCMessageDescriptor rpc__resp__otaactivate__descriptor;
extern const ProtobufCMessageDescriptor rpc__req__app_get_desc__descriptor;
extern const ProtobufCMessageDescriptor rpc__resp__app_get_desc__descriptor;
extern const ProtobufCMessageDescriptor rpc__req__wifi_set_max_tx_power__descriptor;
extern const ProtobufCMessageDescriptor rpc__resp__wifi_set_max_tx_power__descriptor;
extern const ProtobufCMessageDescriptor rpc__req__wifi_get_max_tx_power__descriptor;
extern const ProtobufCMessageDescriptor rpc__resp__wifi_get_max_tx_power__descriptor;
extern const ProtobufCMessageDescriptor rpc__req__config_heartbeat__descriptor;
extern const ProtobufCMessageDescriptor rpc__resp__config_heartbeat__descriptor;
extern const ProtobufCMessageDescriptor rpc__req__wifi_init__descriptor;
extern const ProtobufCMessageDescriptor rpc__resp__wifi_init__descriptor;
extern const ProtobufCMessageDescriptor rpc__req__wifi_deinit__descriptor;
extern const ProtobufCMessageDescriptor rpc__resp__wifi_deinit__descriptor;
extern const ProtobufCMessageDescriptor rpc__req__wifi_set_config__descriptor;
extern const ProtobufCMessageDescriptor rpc__resp__wifi_set_config__descriptor;
extern const ProtobufCMessageDescriptor rpc__req__wifi_get_config__descriptor;
extern const ProtobufCMessageDescriptor rpc__resp__wifi_get_config__descriptor;
extern const ProtobufCMessageDescriptor rpc__req__wifi_connect__descriptor;
extern const ProtobufCMessageDescriptor rpc__resp__wifi_connect__descriptor;
extern const ProtobufCMessageDescriptor rpc__req__wifi_disconnect__descriptor;
extern const ProtobufCMessageDescriptor rpc__resp__wifi_disconnect__descriptor;
extern const ProtobufCMessageDescriptor rpc__req__wifi_start__descriptor;
extern const ProtobufCMessageDescriptor rpc__resp__wifi_start__descriptor;
extern const ProtobufCMessageDescriptor rpc__req__wifi_stop__descriptor;
extern const ProtobufCMessageDescriptor rpc__resp__wifi_stop__descriptor;
extern const ProtobufCMessageDescriptor rpc__req__wifi_scan_start__descriptor;
extern const ProtobufCMessageDescriptor rpc__resp__wifi_scan_start__descriptor;
extern const ProtobufCMessageDescriptor rpc__req__wifi_scan_stop__descriptor;
extern const ProtobufCMessageDescriptor rpc__resp__wifi_scan_stop__descriptor;
extern const ProtobufCMessageDescriptor rpc__req__wifi_scan_get_ap_num__descriptor;
extern const ProtobufCMessageDescriptor rpc__resp__wifi_scan_get_ap_num__descriptor;
extern const ProtobufCMessageDescriptor rpc__req__wifi_scan_get_ap_records__descriptor;
extern const ProtobufCMessageDescriptor rpc__resp__wifi_scan_get_ap_records__descriptor;
extern const ProtobufCMessageDescriptor rpc__req__wifi_scan_get_ap_record__descriptor;
extern const ProtobufCMessageDescriptor rpc__resp__wifi_scan_get_ap_record__descriptor;
extern const ProtobufCMessageDescriptor rpc__req__wifi_clear_ap_list__descriptor;
extern const ProtobufCMessageDescriptor rpc__resp__wifi_clear_ap_list__descriptor;
extern const ProtobufCMessageDescriptor rpc__req__wifi_restore__descriptor;
extern const ProtobufCMessageDescriptor rpc__resp__wifi_restore__descriptor;
extern const ProtobufCMessageDescriptor rpc__req__wifi_clear_fast_connect__descriptor;
extern const ProtobufCMessageDescriptor rpc__resp__wifi_clear_fast_connect__descriptor;
extern const ProtobufCMessageDescriptor rpc__req__wifi_deauth_sta__descriptor;
extern const ProtobufCMessageDescriptor rpc__resp__wifi_deauth_sta__descriptor;
extern const ProtobufCMessageDescriptor rpc__req__wifi_sta_get_ap_info__descriptor;
extern const ProtobufCMessageDescriptor rpc__resp__wifi_sta_get_ap_info__descriptor;
extern const ProtobufCMessageDescriptor rpc__req__wifi_set_protocol__descriptor;
extern const ProtobufCMessageDescriptor rpc__resp__wifi_set_protocol__descriptor;
extern const ProtobufCMessageDescriptor rpc__req__wifi_get_protocol__descriptor;
extern const ProtobufCMessageDescriptor rpc__resp__wifi_get_protocol__descriptor;
extern const ProtobufCMessageDescriptor rpc__req__wifi_set_bandwidth__descriptor;
extern const ProtobufCMessageDescriptor rpc__resp__wifi_set_bandwidth__descriptor;
extern const ProtobufCMessageDescriptor rpc__req__wifi_get_bandwidth__descriptor;
extern const ProtobufCMessageDescriptor rpc__resp__wifi_get_bandwidth__descriptor;
extern const ProtobufCMessageDescriptor rpc__req__wifi_set_channel__descriptor;
extern const ProtobufCMessageDescriptor rpc__resp__wifi_set_channel__descriptor;
extern const ProtobufCMessageDescriptor rpc__req__wifi_get_channel__descriptor;
extern const ProtobufCMessageDescriptor rpc__resp__wifi_get_channel__descriptor;
extern const ProtobufCMessageDescriptor rpc__req__wifi_set_storage__descriptor;
extern const ProtobufCMessageDescriptor rpc__resp__wifi_set_storage__descriptor;
extern const ProtobufCMessageDescriptor rpc__req__wifi_set_country_code__descriptor;
extern const ProtobufCMessageDescriptor rpc__resp__wifi_set_country_code__descriptor;
extern const ProtobufCMessageDescriptor rpc__req__wifi_get_country_code__descriptor;
extern const ProtobufCMessageDescriptor rpc__resp__wifi_get_country_code__descriptor;
extern const ProtobufCMessageDescriptor rpc__req__wifi_set_country__descriptor;
extern const ProtobufCMessageDescriptor rpc__resp__wifi_set_country__descriptor;
extern const ProtobufCMessageDescriptor rpc__req__wifi_get_country__descriptor;
extern const ProtobufCMessageDescriptor rpc__resp__wifi_get_country__descriptor;
extern const ProtobufCMessageDescriptor rpc__req__wifi_ap_get_sta_list__descriptor;
extern const ProtobufCMessageDescriptor rpc__resp__wifi_ap_get_sta_list__descriptor;
extern const ProtobufCMessageDescriptor rpc__req__wifi_ap_get_sta_aid__descriptor;
extern const ProtobufCMessageDescriptor rpc__req__wifi_sta_get_negotiated_phymode__descriptor;
extern const ProtobufCMessageDescriptor rpc__resp__wifi_sta_get_negotiated_phymode__descriptor;
extern const ProtobufCMessageDescriptor rpc__resp__wifi_ap_get_sta_aid__descriptor;
extern const ProtobufCMessageDescriptor rpc__req__wifi_sta_get_rssi__descriptor;
extern const ProtobufCMessageDescriptor rpc__resp__wifi_sta_get_rssi__descriptor;
extern const ProtobufCMessageDescriptor rpc__req__wifi_scan_params__descriptor;
extern const ProtobufCMessageDescriptor rpc__resp__wifi_scan_params__descriptor;
extern const ProtobufCMessageDescriptor rpc__req__wifi_sta_get_aid__descriptor;
extern const ProtobufCMessageDescriptor rpc__resp__wifi_sta_get_aid__descriptor;
extern const ProtobufCMessageDescriptor rpc__req__wifi_set_protocols__descriptor;
extern const ProtobufCMessageDescriptor rpc__resp__wifi_set_protocols__descriptor;
extern const ProtobufCMessageDescriptor rpc__req__wifi_get_protocols__descriptor;
extern const ProtobufCMessageDescriptor rpc__resp__wifi_get_protocols__descriptor;
extern const ProtobufCMessageDescriptor rpc__req__wifi_set_bandwidths__descriptor;
extern const ProtobufCMessageDescriptor rpc__resp__wifi_set_bandwidths__descriptor;
extern const ProtobufCMessageDescriptor rpc__req__wifi_get_bandwidths__descriptor;
extern const ProtobufCMessageDescriptor rpc__resp__wifi_get_bandwidths__descriptor;
extern const ProtobufCMessageDescriptor rpc__req__wifi_set_band__descriptor;
extern const ProtobufCMessageDescriptor rpc__resp__wifi_set_band__descriptor;
extern const ProtobufCMessageDescriptor rpc__req__wifi_get_band__descriptor;
extern const ProtobufCMessageDescriptor rpc__resp__wifi_get_band__descriptor;
extern const ProtobufCMessageDescriptor rpc__req__wifi_set_band_mode__descriptor;
extern const ProtobufCMessageDescriptor rpc__resp__wifi_set_band_mode__descriptor;
extern const ProtobufCMessageDescriptor rpc__req__wifi_get_band_mode__descriptor;
extern const ProtobufCMessageDescriptor rpc__resp__wifi_get_band_mode__descriptor;
extern const ProtobufCMessageDescriptor rpc__req__wifi_set_inactive_time__descriptor;
extern const ProtobufCMessageDescriptor rpc__resp__wifi_set_inactive_time__descriptor;
extern const ProtobufCMessageDescriptor rpc__req__wifi_get_inactive_time__descriptor;
extern const ProtobufCMessageDescriptor rpc__resp__wifi_get_inactive_time__descriptor;
extern const ProtobufCMessageDescriptor rpc__req__wifi_disable_pmf_config__descriptor;
extern const ProtobufCMessageDescriptor rpc__resp__wifi_disable_pmf_config__descriptor;
extern const ProtobufCMessageDescriptor rpc__req__wifi_sta_itwt_setup__descriptor;
extern const ProtobufCMessageDescriptor rpc__resp__wifi_sta_itwt_setup__descriptor;
extern const ProtobufCMessageDescriptor rpc__req__wifi_sta_itwt_teardown__descriptor;
extern const ProtobufCMessageDescriptor rpc__resp__wifi_sta_itwt_teardown__descriptor;
extern const ProtobufCMessageDescriptor rpc__req__wifi_sta_itwt_suspend__descriptor;
extern const ProtobufCMessageDescriptor rpc__resp__wifi_sta_itwt_suspend__descriptor;
extern const ProtobufCMessageDescriptor rpc__req__wifi_sta_itwt_get_flow_id_status__descriptor;
extern const ProtobufCMessageDescriptor rpc__resp__wifi_sta_itwt_get_flow_id_status__descriptor;
extern const ProtobufCMessageDescriptor rpc__req__wifi_sta_itwt_send_probe_req__descriptor;
extern const ProtobufCMessageDescriptor rpc__resp__wifi_sta_itwt_send_probe_req__descriptor;
extern const ProtobufCMessageDescriptor rpc__req__wifi_sta_itwt_set_target_wake_time_offset__descriptor;
extern const ProtobufCMessageDescriptor rpc__resp__wifi_sta_itwt_set_target_wake_time_offset__descriptor;
extern const ProtobufCMessageDescriptor rpc__req__wifi_sta_twt_config__descriptor;
extern const ProtobufCMessageDescriptor rpc__resp__wifi_sta_twt_config__descriptor;
extern const ProtobufCMessageDescriptor rpc__req__get_coprocessor_fw_version__descriptor;
extern const ProtobufCMessageDescriptor rpc__resp__get_coprocessor_fw_version__descriptor;
extern const ProtobufCMessageDescriptor rpc__req__set_dhcp_dns_status__descriptor;
extern const ProtobufCMessageDescriptor rpc__resp__set_dhcp_dns_status__descriptor;
extern const ProtobufCMessageDescriptor rpc__req__get_dhcp_dns_status__descriptor;
extern const ProtobufCMessageDescriptor rpc__resp__get_dhcp_dns_status__descriptor;
extern const ProtobufCMessageDescriptor rpc__req__supp_dpp_init__descriptor;
extern const ProtobufCMessageDescriptor rpc__resp__supp_dpp_init__descriptor;
extern const ProtobufCMessageDescriptor rpc__req__supp_dpp_deinit__descriptor;
extern const ProtobufCMessageDescriptor rpc__resp__supp_dpp_deinit__descriptor;
extern const ProtobufCMessageDescriptor rpc__req__supp_dpp_bootstrap_gen__descriptor;
extern const ProtobufCMessageDescriptor rpc__resp__supp_dpp_bootstrap_gen__descriptor;
extern const ProtobufCMessageDescriptor rpc__req__supp_dpp_start_listen__descriptor;
extern const ProtobufCMessageDescriptor rpc__resp__supp_dpp_start_listen__descriptor;
extern const ProtobufCMessageDescriptor rpc__req__supp_dpp_stop_listen__descriptor;
extern const ProtobufCMessageDescriptor rpc__resp__supp_dpp_stop_listen__descriptor;
extern const ProtobufCMessageDescriptor rpc__req__iface_mac_addr_set_get__descriptor;
extern const ProtobufCMessageDescriptor rpc__resp__iface_mac_addr_set_get__descriptor;
extern const ProtobufCMessageDescriptor rpc__req__iface_mac_addr_len_get__descriptor;
extern const ProtobufCMessageDescriptor rpc__resp__iface_mac_addr_len_get__descriptor;
extern const ProtobufCMessageDescriptor rpc__req__feature_control__descriptor;
extern const ProtobufCMessageDescriptor rpc__resp__feature_control__descriptor;
extern const ProtobufCMessageDescriptor rpc__req__mem_monitor__descriptor;
extern const ProtobufCMessageDescriptor rpc__resp__mem_monitor__descriptor;
extern const ProtobufCMessageDescriptor rpc__event__wifi_event_no_args__descriptor;
extern const ProtobufCMessageDescriptor rpc__event__espinit__descriptor;
extern const ProtobufCMessageDescriptor rpc__event__heartbeat__descriptor;
extern const ProtobufCMessageDescriptor rpc__event__ap__sta_disconnected__descriptor;
extern const ProtobufCMessageDescriptor rpc__event__ap__sta_connected__descriptor;
extern const ProtobufCMessageDescriptor rpc__event__sta_scan_done__descriptor;
extern const ProtobufCMessageDescriptor rpc__event__sta_connected__descriptor;
extern const ProtobufCMessageDescriptor rpc__event__sta_disconnected__descriptor;
extern const ProtobufCMessageDescriptor rpc__gpio_config__descriptor;
extern const ProtobufCMessageDescriptor rpc__req__gpio_config__descriptor;
extern const ProtobufCMessageDescriptor rpc__resp__gpio_config__descriptor;
extern const ProtobufCMessageDescriptor rpc__req__gpio_reset_pin__descriptor;
extern const ProtobufCMessageDescriptor rpc__resp__gpio_reset_pin__descriptor;
extern const ProtobufCMessageDescriptor rpc__req__gpio_set_level__descriptor;
extern const ProtobufCMessageDescriptor rpc__resp__gpio_set_level__descriptor;
extern const ProtobufCMessageDescriptor rpc__req__gpio_get_level__descriptor;
extern const ProtobufCMessageDescriptor rpc__resp__gpio_get_level__descriptor;
extern const ProtobufCMessageDescriptor rpc__req__gpio_set_direction__descriptor;
extern const ProtobufCMessageDescriptor rpc__resp__gpio_set_direction__descriptor;
extern const ProtobufCMessageDescriptor rpc__req__gpio_input_enable__descriptor;
extern const ProtobufCMessageDescriptor rpc__resp__gpio_input_enable__descriptor;
extern const ProtobufCMessageDescriptor rpc__req__gpio_set_pull_mode__descriptor;
extern const ProtobufCMessageDescriptor rpc__resp__gpio_set_pull_mode__descriptor;
extern const ProtobufCMessageDescriptor rpc__req__ext_coex__descriptor;
extern const ProtobufCMessageDescriptor rpc__resp__ext_coex__descriptor;
extern const ProtobufCMessageDescriptor rpc__event__dhcp_dns_status__descriptor;
extern const ProtobufCMessageDescriptor rpc__event__sta_itwt_setup__descriptor;
extern const ProtobufCMessageDescriptor rpc__event__sta_itwt_teardown__descriptor;
extern const ProtobufCMessageDescriptor rpc__event__sta_itwt_suspend__descriptor;
extern const ProtobufCMessageDescriptor rpc__event__sta_itwt_probe__descriptor;
extern const ProtobufCMessageDescriptor rpc__req__wifi_sta_enterprise_enable__descriptor;
extern const ProtobufCMessageDescriptor rpc__resp__wifi_sta_enterprise_enable__descriptor;
extern const ProtobufCMessageDescriptor rpc__req__wifi_sta_enterprise_disable__descriptor;
extern const ProtobufCMessageDescriptor rpc__resp__wifi_sta_enterprise_disable__descriptor;
extern const ProtobufCMessageDescriptor rpc__req__eap_set_identity__descriptor;
extern const ProtobufCMessageDescriptor rpc__resp__eap_set_identity__descriptor;
extern const ProtobufCMessageDescriptor rpc__req__eap_clear_identity__descriptor;
extern const ProtobufCMessageDescriptor rpc__resp__eap_clear_identity__descriptor;
extern const ProtobufCMessageDescriptor rpc__req__eap_set_username__descriptor;
extern const ProtobufCMessageDescriptor rpc__resp__eap_set_username__descriptor;
extern const ProtobufCMessageDescriptor rpc__req__eap_clear_username__descriptor;
extern const ProtobufCMessageDescriptor rpc__resp__eap_clear_username__descriptor;
extern const ProtobufCMessageDescriptor rpc__req__eap_set_password__descriptor;
extern const ProtobufCMessageDescriptor rpc__resp__eap_set_password__descriptor;
extern const ProtobufCMessageDescriptor rpc__req__eap_clear_password__descriptor;
extern const ProtobufCMessageDescriptor rpc__resp__eap_clear_password__descriptor;
extern const ProtobufCMessageDescriptor rpc__req__eap_set_new_password__descriptor;
extern const ProtobufCMessageDescriptor rpc__resp__eap_set_new_password__descriptor;
extern const ProtobufCMessageDescriptor rpc__req__eap_clear_new_password__descriptor;
extern const ProtobufCMessageDescriptor rpc__resp__eap_clear_new_password__descriptor;
extern const ProtobufCMessageDescriptor rpc__req__eap_set_ca_cert__descriptor;
extern const ProtobufCMessageDescriptor rpc__resp__eap_set_ca_cert__descriptor;
extern const ProtobufCMessageDescriptor rpc__req__eap_clear_ca_cert__descriptor;
extern const ProtobufCMessageDescriptor rpc__resp__eap_clear_ca_cert__descriptor;
extern const ProtobufCMessageDescriptor rpc__req__eap_set_certificate_and_key__descriptor;
extern const ProtobufCMessageDescriptor rpc__resp__eap_set_certificate_and_key__descriptor;
extern const ProtobufCMessageDescriptor rpc__req__eap_clear_certificate_and_key__descriptor;
extern const ProtobufCMessageDescriptor rpc__resp__eap_clear_certificate_and_key__descriptor;
extern const ProtobufCMessageDescriptor rpc__req__eap_set_disable_time_check__descriptor;
extern const ProtobufCMessageDescriptor rpc__resp__eap_set_disable_time_check__descriptor;
extern const ProtobufCMessageDescriptor rpc__req__eap_get_disable_time_check__descriptor;
extern const ProtobufCMessageDescriptor rpc__resp__eap_get_disable_time_check__descriptor;
extern const ProtobufCMessageDescriptor rpc__req__eap_set_ttls_phase2_method__descriptor;
extern const ProtobufCMessageDescriptor rpc__resp__eap_set_ttls_phase2_method__descriptor;
extern const ProtobufCMessageDescriptor rpc__req__eap_set_suiteb192bit_certification__descriptor;
extern const ProtobufCMessageDescriptor rpc__resp__eap_set_suiteb192bit_certification__descriptor;
extern const ProtobufCMessageDescriptor rpc__req__eap_set_pac_file__descriptor;
extern const ProtobufCMessageDescriptor rpc__resp__eap_set_pac_file__descriptor;
extern const ProtobufCMessageDescriptor rpc__req__eap_set_fast_params__descriptor;
extern const ProtobufCMessageDescriptor rpc__resp__eap_set_fast_params__descriptor;
extern const ProtobufCMessageDescriptor rpc__req__eap_use_default_cert_bundle__descriptor;
extern const ProtobufCMessageDescriptor rpc__resp__eap_use_default_cert_bundle__descriptor;
extern const ProtobufCMessageDescriptor rpc__req__wifi_set_okc_support__descriptor;
extern const ProtobufCMessageDescriptor rpc__resp__wifi_set_okc_support__descriptor;
extern const ProtobufCMessageDescriptor rpc__req__eap_set_domain_name__descriptor;
extern const ProtobufCMessageDescriptor rpc__resp__eap_set_domain_name__descriptor;
extern const ProtobufCMessageDescriptor rpc__req__eap_set_eap_methods__descriptor;
extern const ProtobufCMessageDescriptor rpc__resp__eap_set_eap_methods__descriptor;
extern const ProtobufCMessageDescriptor rpc__event__supp_dpp_uri_ready__descriptor;
extern const ProtobufCMessageDescriptor rpc__event__supp_dpp_cfg_recvd__descriptor;
extern const ProtobufCMessageDescriptor rpc__event__supp_dpp_fail__descriptor;
extern const ProtobufCMessageDescriptor rpc__event__wifi_dpp_uri_ready__descriptor;
extern const ProtobufCMessageDescriptor rpc__event__wifi_dpp_cfg_recvd__descriptor;
extern const ProtobufCMessageDescriptor rpc__event__wifi_dpp_fail__descriptor;
extern const ProtobufCMessageDescriptor rpc__req__custom_rpc__descriptor;
extern const ProtobufCMessageDescriptor rpc__resp__custom_rpc__descriptor;
extern const ProtobufCMessageDescriptor rpc__event__custom_rpc__descriptor;
extern const ProtobufCMessageDescriptor rpc__event__mem_monitor__descriptor;
extern const ProtobufCMessageDescriptor rpc__descriptor;

PROTOBUF_C__END_DECLS


#endif  /* PROTOBUF_C_esp_5fhosted_5frpc_2eproto__INCLUDED */