The include file for all the types for Ember ApplicationFramework.

License#

Copyright 2018 Silicon Laboratories Inc. www.silabs.com

The licensor of this software is Silicon Laboratories Inc. Your use of this software is governed by the terms of Silicon Labs Master Software License Agreement (MSLA) available at www.silabs.com/about-us/legal/master-software-license-agreement. This software is distributed to you in Source Code format and is governed by the sections of the MSLA applicable to Source Code.

/***************************************************************************/
#ifndef SILABS_AF_API_TYPES
#define SILABS_AF_API_TYPES

#ifdef SL_COMPONENT_CATALOG_PRESENT
#include "sl_component_catalog.h"
#endif
#include "zap-type.h"
#include "app/framework/common/sl_zigbee_system_common.h"
#ifdef SL_CATALOG_ZIGBEE_MESSAGING_CLIENT_PRESENT
#include "messaging-client-config.h"
#endif  // SL_CATALOG_ZIGBEE_MESSAGING_CLIENT_PRESENT

#ifdef EZSP_HOST
#include "app/util/ezsp/ezsp-enum.h"
#endif

typedef uint16_t sl_zigbee_af_profile_id_t;

typedef uint16_t sl_zigbee_af_attribute_id_t;

typedef uint16_t sl_zigbee_af_cluster_id_t;

typedef uint8_t sl_zigbee_af_attribute_type_t;

typedef uint8_t sl_zigbee_af_cluster_mask_t;

typedef uint8_t sl_zigbee_af_attribute_mask_t;

typedef void (*sl_zigbee_af_generic_cluster_function_t)(void);

typedef struct {
  sl_zigbee_af_cluster_id_t                    clusterId;
  sl_zigbee_af_cluster_mask_t                  functionMask;
  const sl_zigbee_af_generic_cluster_function_t functionPtr;
} sli_cluster_function_structure_t;

#define SL_ZIGBEE_AF_NULL_MANUFACTURER_CODE 0x0000u

 #define SL_ZIGBEE_AF_INVALID_PROFILE_ID 0xFFFFu

typedef union {
  uint8_t *ptrToDefaultValue;
  uint16_t defaultValue;
} sl_zigbee_af_default_attribute_value_t;

typedef struct {
  sl_zigbee_af_default_attribute_value_t defaultValue;
  sl_zigbee_af_default_attribute_value_t minValue;
  sl_zigbee_af_default_attribute_value_t maxValue;
} sl_zigbee_af_attribute_min_max_value_t;

typedef union {
  uint8_t *ptrToDefaultValue;
  uint16_t defaultValue;
  sl_zigbee_af_attribute_min_max_value_t *ptrToMinMaxValue;
} sl_zigbee_af_default_or_min_max_attribute_value_t;

typedef struct {
  sl_zigbee_af_attribute_id_t attributeId;
  sl_zigbee_af_attribute_type_t attributeType;
  uint8_t size;
  sl_zigbee_af_attribute_mask_t mask;
  sl_zigbee_af_default_or_min_max_attribute_value_t  defaultValue;
} sl_zigbee_af_attribute_metadata_t;

typedef struct {
  sl_zigbee_af_cluster_id_t clusterId;
  sl_zigbee_af_attribute_metadata_t *attributes;
  uint16_t attributeCount;
  uint16_t clusterSize;
  sl_zigbee_af_cluster_mask_t mask;

  const sl_zigbee_af_generic_cluster_function_t *functions;
} sl_zigbee_af_cluster_t;

typedef struct {
  uint8_t endpoint;

  sl_zigbee_af_cluster_id_t clusterId;

  sl_zigbee_af_cluster_mask_t clusterMask;

  sl_zigbee_af_attribute_id_t attributeId;

  uint16_t manufacturerCode;
} sl_zigbee_af_attribute_search_record_t;

typedef struct {
  uint16_t index;
  uint16_t manufacturerCode;
} sl_zigbee_af_manufacturer_code_entry_t;

typedef uint64_t sl_zigbee_af_difference_type_t;

typedef struct {
  sl_zigbee_incoming_message_type_t type;
  sl_zigbee_aps_frame_t* apsFrame;
  uint8_t* message;
  uint16_t msgLen;
  uint16_t source;
  uint8_t lastHopLqi;
  int8_t lastHopRssi;
  uint8_t bindingTableIndex;
  uint8_t addressTableIndex;
  uint8_t networkIndex;
} sl_zigbee_af_incoming_message_t;

typedef uint8_t sl_zigbee_af_interpan_message_type_t;
#define SL_ZIGBEE_AF_INTER_PAN_UNICAST   0x00u
#define SL_ZIGBEE_AF_INTER_PAN_BROADCAST 0x08u
#define SL_ZIGBEE_AF_INTER_PAN_MULTICAST 0x0Cu

// Legacy names
#define INTER_PAN_UNICAST   SL_ZIGBEE_AF_INTER_PAN_UNICAST
#define INTER_PAN_BROADCAST SL_ZIGBEE_AF_INTER_PAN_BROADCAST
#define INTER_PAN_MULTICAST SL_ZIGBEE_AF_INTER_PAN_MULTICAST

#define SL_ZIGBEE_AF_INTERPAN_OPTION_NONE                 0x0000u
#define SL_ZIGBEE_AF_INTERPAN_OPTION_APS_ENCRYPT          0x0001u
#define SL_ZIGBEE_AF_INTERPAN_OPTION_MAC_HAS_LONG_ADDRESS 0x0002u

typedef uint16_t sl_zigbee_af_interpan_options_t;

typedef struct {
  sl_zigbee_af_interpan_message_type_t messageType;

  sl_802154_long_addr_t longAddress;
  sl_802154_short_addr_t shortAddress;
  sl_802154_pan_id_t panId;

  sl_zigbee_af_profile_id_t profileId;
  sl_zigbee_af_cluster_id_t clusterId;
  sl_zigbee_multicast_id_t groupId;
  sl_zigbee_af_interpan_options_t options;
} sl_zigbee_af_interpan_header_t;

// Legacy Name
#define sli_zigbee_interpan_header_t sl_zigbee_af_interpan_header_t

typedef uint8_t sl_zigbee_af_allowed_interpan_options_t;

#define SL_ZIGBEE_AF_INTERPAN_DIRECTION_CLIENT_TO_SERVER 0x01u
#define SL_ZIGBEE_AF_INTERPAN_DIRECTION_SERVER_TO_CLIENT 0x02u
#define SL_ZIGBEE_AF_INTERPAN_DIRECTION_BOTH             0x03u
#define SL_ZIGBEE_AF_INTERPAN_GLOBAL_COMMAND             0x04u
#define SL_ZIGBEE_AF_INTERPAN_MANUFACTURER_SPECIFIC      0x08u

typedef struct {
  sl_zigbee_af_profile_id_t profileId;
  sl_zigbee_af_cluster_id_t clusterId;
  uint8_t commandId;
  sl_zigbee_af_allowed_interpan_options_t options;
} sl_zigbee_af_allowed_inter_pan_message_t;

typedef struct {
  sl_zigbee_aps_frame_t            *apsFrame;
  sl_zigbee_incoming_message_type_t  type;
  sl_802154_short_addr_t               source;
  uint8_t                    *buffer;
  uint16_t                    bufLen;
  bool                   clusterSpecific;
  bool                   mfgSpecific;
  uint16_t                    mfgCode;
  uint8_t                     seqNum;
  uint8_t                     commandId;
  uint8_t                     payloadStartIndex;
  uint8_t                     direction;
  sl_zigbee_af_interpan_header_t    *interPanHeader;
  uint8_t                     networkIndex;
} sl_zigbee_af_cluster_command_t;

typedef struct {
  sl_zigbee_af_cluster_t *cluster;
  uint8_t  clusterCount;
  uint16_t endpointSize;
} sl_zigbee_af_endpoint_type_t;

#ifdef EZSP_HOST
typedef sl_zigbee_ezsp_decision_id_t sl_zigbee_af_tc_link_key_request_policy_t;
typedef sl_zigbee_ezsp_decision_id_t sl_zigbee_af_app_link_key_request_policy_t;
  #define SL_ZIGBEE_AF_ALLOW_TC_KEY_REQUESTS                       SL_ZIGBEE_EZSP_ALLOW_TC_KEY_REQUESTS_AND_SEND_CURRENT_KEY
  #define SL_ZIGBEE_AF_DENY_TC_KEY_REQUESTS                        SL_ZIGBEE_EZSP_DENY_TC_KEY_REQUESTS
  #define SL_ZIGBEE_AF_ALLOW_APP_KEY_REQUESTS                      SL_ZIGBEE_EZSP_ALLOW_APP_KEY_REQUESTS
  #define SL_ZIGBEE_AF_DENY_APP_KEY_REQUESTS                       SL_ZIGBEE_EZSP_DENY_APP_KEY_REQUESTS
#else
typedef sl_zigbee_tc_link_key_request_policy_t sl_zigbee_af_tc_link_key_request_policy_t;
typedef sl_zigbee_app_link_key_request_policy_t sl_zigbee_af_app_link_key_request_policy_t;
  #define SL_ZIGBEE_AF_ALLOW_TC_KEY_REQUESTS                       SL_ZIGBEE_ALLOW_TC_LINK_KEY_REQUEST_AND_SEND_CURRENT_KEY
  #define SL_ZIGBEE_AF_DENY_TC_KEY_REQUESTS                        SL_ZIGBEE_DENY_TC_LINK_KEY_REQUESTS
  #define SL_ZIGBEE_AF_ALLOW_APP_KEY_REQUESTS                      SL_ZIGBEE_ALLOW_APP_LINK_KEY_REQUEST
  #define SL_ZIGBEE_AF_DENY_APP_KEY_REQUESTS                       SL_ZIGBEE_DENY_APP_LINK_KEY_REQUESTS
#endif

#ifdef DOXYGEN_SHOULD_SKIP_THIS
enum sl_zigbee_af_security_profile_t
#else
typedef uint8_t sl_zigbee_af_security_profile_t;
enum
#endif
{
  SL_ZIGBEE_AF_SECURITY_PROFILE_NONE    = 0x00,
  SL_ZIGBEE_AF_SECURITY_PROFILE_HA      = 0x01,
  SL_ZIGBEE_AF_SECURITY_PROFILE_HA12    = 0x02,
  SL_ZIGBEE_AF_SECURITY_PROFILE_SE_TEST = 0x03,
  SL_ZIGBEE_AF_SECURITY_PROFILE_SE_FULL = 0x04,
  SL_ZIGBEE_AF_SECURITY_PROFILE_Z3      = 0x05,
  SL_ZIGBEE_AF_SECURITY_PROFILE_CUSTOM  = 0xFF,
};

typedef struct {
  sl_zigbee_af_security_profile_t       securityProfile;
  uint16_t                       tcBitmask;
  sl_zigbee_extended_security_bitmask_t tcExtendedBitmask;
  uint16_t                       nodeBitmask;
  sl_zigbee_extended_security_bitmask_t nodeExtendedBitmask;
  sl_zigbee_af_tc_link_key_request_policy_t  tcLinkKeyRequestPolicy;
  sl_zigbee_af_app_link_key_request_policy_t  appLinkKeyRequestPolicy;
  sl_zigbee_key_data_t                 preconfiguredKey;
} sl_zigbee_af_security_profile_data_t;

#ifndef DOXYGEN_SHOULD_SKIP_THIS
typedef struct {
  sl_zigbee_node_type_t nodeType;
  sl_zigbee_af_security_profile_t securityProfile;
} sli_zigbee_af_zigbee_pro_network;

#endif

#ifdef DOXYGEN_SHOULD_SKIP_THIS
enum sl_zigbee_af_endpoint_bitmask_t;
#else
typedef uint8_t sl_zigbee_af_endpoint_bitmask_t;
enum
#endif
{
  SL_ZIGBEE_AF_ENDPOINT_DISABLED = 0x00,
  SL_ZIGBEE_AF_ENDPOINT_ENABLED  = 0x01,
};

typedef struct {
  uint8_t endpoint;
  sl_zigbee_af_profile_id_t profileId;
  uint16_t deviceId;
  uint8_t deviceVersion;
  sl_zigbee_af_endpoint_type_t *endpointType;
  uint8_t networkIndex;
  sl_zigbee_af_endpoint_bitmask_t bitmask;
} sl_zigbee_af_defined_endpoint_t;

// Cluster-specific types

#if (SL_ZIGBEE_AF_PLUGIN_ESI_MANAGEMENT_ESI_TABLE_SIZE <= 8)
typedef uint8_t sl_zigbee_af_plugin_esi_management_bitmask_t;
#elif (SL_ZIGBEE_AF_PLUGIN_ESI_MANAGEMENT_ESI_TABLE_SIZE <= 16)
typedef uint16_t sl_zigbee_af_plugin_esi_management_bitmask_t;
#elif (SL_ZIGBEE_AF_PLUGIN_ESI_MANAGEMENT_ESI_TABLE_SIZE <= 32)
typedef uint32_t sl_zigbee_af_plugin_esi_management_bitmask_t;
#else
  #error "SL_ZIGBEE_AF_PLUGIN_ESI_MANAGEMENT_ESI_TABLE_SIZE cannot exceed 32"
#endif

typedef struct {
  uint32_t     eventId;
#if defined(EMBER_AF_PLUGIN_DRLC_SERVER) || defined(SL_CATALOG_ZIGBEE_DRLC_SERVER_PRESENT)
  sl_802154_long_addr_t source;
  uint8_t      sourceEndpoint;
#endif //EMBER_AF_PLUGIN_DRLC_SERVER || SL_CATALOG_ZIGBEE_DRLC_SERVER_PRESENT

#if defined(EMBER_AF_PLUGIN_DRLC) || defined(SL_CATALOG_ZIGBEE_DRLC_PRESENT)
  sl_zigbee_af_plugin_esi_management_bitmask_t esiBitmask;
#endif //EMBER_AF_PLUGIN_DRLC || SL_CATALOG_ZIGBEE_DRLC_PRESENT

  uint8_t      destinationEndpoint;
  uint16_t     deviceClass;
  uint8_t      utilityEnrollmentGroup;
  uint32_t     startTime;
  uint16_t     duration;
  uint8_t      criticalityLevel;
  uint8_t      coolingTempOffset;
  uint8_t      heatingTempOffset;
  int16_t     coolingTempSetPoint;
  int16_t     heatingTempSetPoint;
  int8_t      avgLoadPercentage;
  uint8_t      dutyCycle;
  uint8_t      eventControl;
  uint32_t     startRand;
  uint32_t     durationRand;
  uint8_t      optionControl;
} sl_zigbee_af_load_control_event_t;

typedef enum {
  SL_ZIGBEE_AF_BROADCAST_SERVICE_DISCOVERY_COMPLETE               = 0x00,
  SL_ZIGBEE_AF_BROADCAST_SERVICE_DISCOVERY_RESPONSE_RECEIVED      = 0x01,
  SL_ZIGBEE_AF_UNICAST_SERVICE_DISCOVERY_TIMEOUT                  = 0x02,
  SL_ZIGBEE_AF_UNICAST_SERVICE_DISCOVERY_COMPLETE_WITH_RESPONSE   = 0x03,
  SL_ZIGBEE_AF_BROADCAST_SERVICE_DISCOVERY_COMPLETE_WITH_RESPONSE = 0x04,
  SL_ZIGBEE_AF_UNICAST_SERVICE_DISCOVERY_COMPLETE_WITH_EMPTY_RESPONSE   = 0x05,
  SL_ZIGBEE_AF_BROADCAST_SERVICE_DISCOVERY_COMPLETE_WITH_EMPTY_RESPONSE = 0x06,
} sl_zigbee_af_service_discovery_status_t;

#define EM_AF_DISCOVERY_RESPONSE_MASK (0x05u)

#define sl_zigbee_af_have_discovery_response_status(status)  ((status) & EM_AF_DISCOVERY_RESPONSE_MASK)

typedef struct {
  sl_zigbee_af_service_discovery_status_t status;

  uint16_t zdoRequestClusterId;

  sl_802154_short_addr_t matchAddress;

  const void* responseData;
} sl_zigbee_af_service_discovery_result_t;

typedef struct {
  uint8_t count;
  const uint8_t* list;
} sl_zigbee_af_endpoint_list_t;

typedef struct {
  uint8_t inClusterCount;
  const uint16_t* inClusterList;
  uint8_t outClusterCount;
  const uint16_t* outClusterList;
  sl_zigbee_af_profile_id_t profileId;
  uint16_t deviceId;
  uint8_t endpoint;
} sl_zigbee_af_cluster_list_t;

typedef void (sl_zigbee_af_service_discovery_callback_t)(const sl_zigbee_af_service_discovery_result_t* result);

typedef void (sl_zigbee_af_partner_link_key_exchange_callback_t)(bool success);

typedef enum {
  SL_ZIGBEE_AF_LONG_POLL,
  SL_ZIGBEE_AF_SHORT_POLL,
} sl_zigbee_af_event_poll_control_t;

typedef enum {
  SL_ZIGBEE_AF_OK_TO_SLEEP,
  SL_ZIGBEE_AF_OK_TO_HIBERNATE = SL_ZIGBEE_AF_OK_TO_SLEEP,
  SL_ZIGBEE_AF_OK_TO_NAP,
  SL_ZIGBEE_AF_STAY_AWAKE,
} sl_zigbee_af_event_sleep_control_t;

#ifdef DOXYGEN_SHOULD_SKIP_THIS
enum sl_zigbee_af_application_task_t
#else
typedef uint32_t sl_zigbee_af_application_task_t;
enum
#endif
{
  // we may be able to remove these top two since they are
  // handled by the stack on the SOC.
  SL_ZIGBEE_AF_WAITING_FOR_DATA_ACK                     = 0x00000001, //not needed?
  SL_ZIGBEE_AF_LAST_POLL_GOT_DATA                       = 0x00000002, //not needed?
  SL_ZIGBEE_AF_WAITING_FOR_SERVICE_DISCOVERY            = 0x00000004,
  SL_ZIGBEE_AF_WAITING_FOR_ZDO_RESPONSE                 = 0x00000008,
  SL_ZIGBEE_AF_WAITING_FOR_ZCL_RESPONSE                 = 0x00000010,
  SL_ZIGBEE_AF_WAITING_FOR_REGISTRATION                 = 0x00000020,
  SL_ZIGBEE_AF_WAITING_FOR_PARTNER_LINK_KEY_EXCHANGE    = 0x00000040,
  SL_ZIGBEE_AF_FORCE_SHORT_POLL                         = 0x00000080,
  SL_ZIGBEE_AF_FRAGMENTATION_IN_PROGRESS                = 0x00000100,
  SL_ZIGBEE_AF_FORCE_SHORT_POLL_FOR_PARENT_CONNECTIVITY = 0x00000200,
  SL_ZIGBEE_AF_WAITING_FOR_TC_KEY_UPDATE                = 0x00000400,
};

typedef struct {
  uint8_t endpoint;
  sl_zigbee_af_cluster_id_t clusterId;
  bool isClient;
  sl_zigbee_af_event_poll_control_t pollControl;
  sl_zigbee_af_event_sleep_control_t sleepControl;
  sl_zigbee_event_control_t *eventControl;
} sl_zigbee_af_event_context;

// TODO: update doxygen
typedef struct {
  uint8_t endpoint;
  sl_zigbee_af_cluster_id_t clusterId;
  bool isClient;
  sl_zigbee_af_event_poll_control_t pollControl;
  sl_zigbee_af_event_sleep_control_t sleepControl;
  sli_zigbee_event_t *event;
} sl_zigbee_event_context_t;

typedef void (*sl_zigbee_af_network_event_handler_t)(void);

typedef void (*sl_zigbee_af_endpoint_event_handler_t)(uint8_t endpoint);

#define SL_ZIGBEE_AF_GROUP_TABLE_NULL_INDEX 0xFFu
#define SL_ZIGBEE_AF_GROUP_TABLE_UNUSED_ENDPOINT_ID 0x00u
#define ZCL_GROUPS_CLUSTER_MAXIMUM_NAME_LENGTH 16u
typedef struct {
  uint8_t  endpoint; // 0x00 when not in use
  uint16_t groupId;
  uint8_t  bindingIndex;
#ifdef SL_ZIGBEE_AF_PLUGIN_GROUPS_SERVER_NAME_SUPPORT
  uint8_t  name[ZCL_GROUPS_CLUSTER_MAXIMUM_NAME_LENGTH + 1];
#endif
} sl_zigbee_af_group_table_entry_t;

#define SL_ZIGBEE_AF_SCENE_TABLE_NULL_INDEX 0xFFu
#define SL_ZIGBEE_AF_SCENE_TABLE_UNUSED_ENDPOINT_ID 0x00u
#define ZCL_SCENES_CLUSTER_MAXIMUM_NAME_LENGTH 16u
#define ZCL_SCENES_GLOBAL_SCENE_GROUP_ID 0x0000u
#define ZCL_SCENES_GLOBAL_SCENE_SCENE_ID 0x00u

// EMZIGBEE-6833: sl_zigbee_af_scene_table_entry_t declaration should be moved to the scenes component.
#ifdef SL_CATALOG_ZIGBEE_SCENES_PRESENT
#include "scenes-config.h"
#if (SL_ZIGBEE_AF_PLUGIN_SCENES_NAME_SUPPORT == 1)
#define SCENES_NAME_SUPPORT
#endif
#endif // SL_CATALOG_ZIGBEE_SCENES_PRESENT

typedef struct {
  uint8_t   endpoint;                // 0x00 when this record is not in use
  uint16_t  groupId;                 // 0x0000 if not associated with a group
  uint8_t   sceneId;
#ifdef SCENES_NAME_SUPPORT
  uint8_t   name[ZCL_SCENES_CLUSTER_MAXIMUM_NAME_LENGTH + 1];
#endif
  uint16_t  transitionTime;          // in seconds
  uint8_t   transitionTime100ms;     // in tenths of a seconds
#ifdef ZCL_USING_ON_OFF_CLUSTER_SERVER
  bool hasOnOffValue;
  bool onOffValue;
#endif
#ifdef ZCL_USING_LEVEL_CONTROL_CLUSTER_SERVER
  bool hasCurrentLevelValue;
  uint8_t   currentLevelValue;
#endif
#ifdef ZCL_USING_THERMOSTAT_CLUSTER_SERVER
  bool hasOccupiedCoolingSetpointValue;
  int16_t  occupiedCoolingSetpointValue;
  bool hasOccupiedHeatingSetpointValue;
  int16_t  occupiedHeatingSetpointValue;
  bool hasSystemModeValue;
  uint8_t   systemModeValue;
#endif
#ifdef ZCL_USING_COLOR_CONTROL_CLUSTER_SERVER
  bool hasCurrentXValue;
  uint16_t  currentXValue;
  bool hasCurrentYValue;
  uint16_t  currentYValue;
  bool hasEnhancedCurrentHueValue;
  uint16_t  enhancedCurrentHueValue;
  bool hasCurrentSaturationValue;
  uint8_t   currentSaturationValue;
  bool hasColorLoopActiveValue;
  uint8_t   colorLoopActiveValue;
  bool hasColorLoopDirectionValue;
  uint8_t   colorLoopDirectionValue;
  bool hasColorLoopTimeValue;
  uint16_t  colorLoopTimeValue;
  bool hasColorTemperatureMiredsValue;
  uint16_t  colorTemperatureMiredsValue;
#endif //ZCL_USING_COLOR_CONTROL_CLUSTER_SERVER
#ifdef ZCL_USING_DOOR_LOCK_CLUSTER_SERVER
  bool hasLockStateValue;
  uint8_t   lockStateValue;
#endif
#ifdef ZCL_USING_WINDOW_COVERING_CLUSTER_SERVER
  bool hasCurrentPositionLiftPercentageValue;
  uint8_t   currentPositionLiftPercentageValue;
  bool hasCurrentPositionTiltPercentageValue;
  uint8_t   currentPositionTiltPercentageValue;
#endif
} sl_zigbee_af_scene_table_entry_t;

#if !defined(EMBER_AF_PLUGIN_MESSAGING_CLIENT) && !defined(SL_CATALOG_ZIGBEE_MESSAGING_CLIENT_PRESENT)
// To forward declare callbacks regardless of whether the plugin
// is enabled,  define all data structures. To define
// the messaging client data struct, declare this variable.
  #define SL_ZIGBEE_AF_PLUGIN_MESSAGING_CLIENT_MESSAGE_SIZE 0
#endif

typedef struct {
  bool    valid;
  bool    active;
  sl_zigbee_af_plugin_esi_management_bitmask_t esiBitmask;
  uint8_t      clientEndpoint;
  uint32_t     messageId;
  uint8_t      messageControl;
  uint32_t     startTime;
  uint32_t     endTime;
  uint16_t     durationInMinutes;
  uint8_t      message[SL_ZIGBEE_AF_PLUGIN_MESSAGING_CLIENT_MESSAGE_SIZE + 1];
} sl_zigbee_af_plugin_messaging_client_message_t;

#define ZCL_PRICE_CLUSTER_MAXIMUM_RATE_LABEL_LENGTH 11u
typedef struct {
  bool valid;
  bool active;
  uint8_t   clientEndpoint;
  uint32_t  providerId;
  uint8_t   rateLabel[ZCL_PRICE_CLUSTER_MAXIMUM_RATE_LABEL_LENGTH + 1];
  uint32_t  issuerEventId;
  uint32_t  currentTime;
  uint8_t   unitOfMeasure;
  uint16_t  currency;
  uint8_t   priceTrailingDigitAndPriceTier;
  uint8_t   numberOfPriceTiersAndRegisterTier;
  uint32_t  startTime;
  uint32_t  endTime;
  uint16_t  durationInMinutes;
  uint32_t  price;
  uint8_t   priceRatio;
  uint32_t  generationPrice;
  uint8_t   generationPriceRatio;
  uint32_t  alternateCostDelivered;
  uint8_t   alternateCostUnit;
  uint8_t   alternateCostTrailingDigit;
  uint8_t   numberOfBlockThresholds;
  uint8_t   priceControl;
} sl_zigbee_af_plugin_price_client_price_t;

#ifdef DOXYGEN_SHOULD_SKIP_THIS
enum sl_zigbee_af_plugin_price_cpp_auth_t
#else
typedef uint8_t sl_zigbee_af_plugin_price_cpp_auth_t;
enum
#endif
{
  SL_ZIGBEE_AF_PLUGIN_PRICE_CPP_AUTH_PENDING  = 0,
  SL_ZIGBEE_AF_PLUGIN_PRICE_CPP_AUTH_ACCEPTED = 1,
  SL_ZIGBEE_AF_PLUGIN_PRICE_CPP_AUTH_REJECTED = 2,
  SL_ZIGBEE_AF_PLUGIN_PRICE_CPP_AUTH_FORCED   = 3,
  SL_ZIGBEE_AF_PLUGIN_PRICE_CPP_AUTH_RESERVED = 4
};

#define SL_ZIGBEE_AF_PLUGIN_REPORTING_UNUSED_ENDPOINT_ID 0x00u
typedef struct {
  sl_zigbee_af_reporting_direction_t direction;
  uint8_t endpoint;
  sl_zigbee_af_cluster_id_t clusterId;
  sl_zigbee_af_attribute_id_t attributeId;
  uint8_t mask;
  uint16_t manufacturerCode;
  union {
    struct {
      uint16_t minInterval;
      uint16_t maxInterval;
      uint32_t reportableChange;
    } reported;
    struct {
      sl_802154_short_addr_t source;
      uint8_t endpoint;
      uint16_t timeout;
    } received;
  } data;
} sl_zigbee_af_plugin_reporting_entry_t;

typedef enum {
  SL_ZIGBEE_AF_PLUGIN_TUNNELING_CLIENT_SUCCESS                          = 0x00,
  SL_ZIGBEE_AF_PLUGIN_TUNNELING_CLIENT_BUSY                             = 0x01,
  SL_ZIGBEE_AF_PLUGIN_TUNNELING_CLIENT_NO_MORE_TUNNEL_IDS               = 0x02,
  SL_ZIGBEE_AF_PLUGIN_TUNNELING_CLIENT_PROTOCOL_NOT_SUPPORTED           = 0x03,
  SL_ZIGBEE_AF_PLUGIN_TUNNELING_CLIENT_FLOW_CONTROL_NOT_SUPPORTED       = 0x04,
  SL_ZIGBEE_AF_PLUGIN_TUNNELING_CLIENT_IEEE_ADDRESS_REQUEST_FAILED      = 0xF9,
  SL_ZIGBEE_AF_PLUGIN_TUNNELING_CLIENT_IEEE_ADDRESS_NOT_FOUND           = 0xFA,
  SL_ZIGBEE_AF_PLUGIN_TUNNELING_CLIENT_ADDRESS_TABLE_FULL               = 0xFB,
  SL_ZIGBEE_AF_PLUGIN_TUNNELING_CLIENT_LINK_KEY_EXCHANGE_REQUEST_FAILED = 0xFC,
  SL_ZIGBEE_AF_PLUGIN_TUNNELING_CLIENT_LINK_KEY_EXCHANGE_FAILED         = 0xFD,
  SL_ZIGBEE_AF_PLUGIN_TUNNELING_CLIENT_REQUEST_TUNNEL_FAILED            = 0xFE,
  SL_ZIGBEE_AF_PLUGIN_TUNNELING_CLIENT_REQUEST_TUNNEL_TIMEOUT           = 0xFF,
} sl_zigbee_af_plugin_tunneling_client_status_t;

#ifdef DOXYGEN_SHOULD_SKIP_THIS
enum sl_zigbee_af_zll_commissioning_status_t
#else
typedef uint8_t sl_zigbee_af_zll_commissioning_status_t;
enum
#endif
{
  SL_ZIGBEE_AF_ZLL_ABORTED_BY_APPLICATION                      = 0x00,
  SL_ZIGBEE_AF_ZLL_CHANNEL_CHANGE_FAILED                       = 0x01,
  SL_ZIGBEE_AF_ZLL_JOINING_FAILED                              = 0x02,
  SL_ZIGBEE_AF_ZLL_NO_NETWORKS_FOUND                           = 0x03,
  SL_ZIGBEE_AF_ZLL_PREEMPTED_BY_STACK                          = 0x04,
  SL_ZIGBEE_AF_ZLL_SENDING_START_JOIN_FAILED                   = 0x05,
  SL_ZIGBEE_AF_ZLL_SENDING_DEVICE_INFORMATION_REQUEST_FAILED   = 0x06,
  SL_ZIGBEE_AF_ZLL_SENDING_IDENTIFY_REQUEST_FAILED             = 0x07,
  SL_ZIGBEE_AF_ZLL_SENDING_RESET_TO_FACTORY_NEW_REQUEST_FAILED = 0x08,
  SL_ZIGBEE_AF_ZLL_NETWORK_FORMATION_FAILED                    = 0x09,
  SL_ZIGBEE_AF_ZLL_NETWORK_UPDATE_OPERATION                    = 0x0A,
};

typedef struct {
  sl_zigbee_multicast_id_t groupId;
  uint8_t            groupType;
} sl_zigbee_af_plugin_zll_commissioning_group_information_record_t;

typedef struct {
  sl_802154_short_addr_t networkAddress;
  uint8_t       endpointId;
  uint16_t      profileId;
  uint16_t      deviceId;
  uint8_t       version;
} sl_zigbee_af_plugin_zll_commissioning_endpoint_information_record_t;

typedef struct {
  uint16_t manufacturerId;
  uint16_t imageTypeId;
  uint32_t firmwareVersion;

  uint8_t deviceSpecificFileEui64[EUI64_SIZE];
} sl_zigbee_af_ota_image_id_t;

#ifdef DOXYGEN_SHOULD_SKIP_THIS
enum sl_zigbee_af_image_block_request_options_t
#else
typedef uint8_t sl_zigbee_af_image_block_request_options_t;
enum
#endif
{
  SL_ZIGBEE_AF_IMAGE_BLOCK_REQUEST_OPTIONS_NONE                          = 0x00,
  // Client supports Min Block Request field
  SL_ZIGBEE_AF_IMAGE_BLOCK_REQUEST_MIN_BLOCK_REQUEST_SUPPORTED_BY_CLIENT = 0x01,
  // Server supports Min Block Request field
  SL_ZIGBEE_AF_IMAGE_BLOCK_REQUEST_MIN_BLOCK_REQUEST_SUPPORTED_BY_SERVER = 0x02,
  // The Image Block Request is actually simulated in place of an actually
  // received Image Page Request
  SL_ZIGBEE_AF_IMAGE_BLOCK_REQUEST_SIMULATED_FROM_PAGE_REQUEST           = 0x04
};

typedef struct {
  const sl_zigbee_af_ota_image_id_t* id;
  uint32_t offset;
  uint32_t waitTimeSecondsResponse;
  sl_802154_short_addr_t source;
  sl_802154_long_addr_t sourceEui;           // optionally present in messages
  // The minBlockRequestPeriod can be treated as milliseconds or seconds on the
  // client. The OTA server plugin has optional support to probe clients and
  // treat this field with appropriate units (ms or sec)
  uint16_t minBlockRequestPeriod; // optionally present in messages
  uint8_t maxDataSize;
  uint8_t clientEndpoint;
  sl_zigbee_af_image_block_request_options_t bitmask;
} sl_zigbee_af_image_block_request_callback_struct_t;

typedef enum {
  SL_ZIGBEE_AF_OTA_STORAGE_SUCCESS               = 0,
  SL_ZIGBEE_AF_OTA_STORAGE_ERROR                 = 1,
  SL_ZIGBEE_AF_OTA_STORAGE_RETURN_DATA_TOO_LONG  = 2,
  SL_ZIGBEE_AF_OTA_STORAGE_PARTIAL_FILE_FOUND    = 3,
  SL_ZIGBEE_AF_OTA_STORAGE_OPERATION_IN_PROGRESS = 4,
} sl_zigbee_af_ota_storage_status_t;

#ifdef DOXYGEN_SHOULD_SKIP_THIS
enum sl_zigbee_af_ota_download_result_t
#else
typedef uint8_t sl_zigbee_af_ota_download_result_t;
enum
#endif
{
  SL_ZIGBEE_AF_OTA_DOWNLOAD_AND_VERIFY_SUCCESS = 0,
  SL_ZIGBEE_AF_OTA_DOWNLOAD_TIME_OUT           = 1,
  SL_ZIGBEE_AF_OTA_VERIFY_FAILED               = 2,
  SL_ZIGBEE_AF_OTA_SERVER_ABORTED              = 3,
  SL_ZIGBEE_AF_OTA_CLIENT_ABORTED              = 4,
  SL_ZIGBEE_AF_OTA_ERASE_FAILED                = 5,
};

#define SL_ZIGBEE_AF_OTA_MAX_HEADER_STRING_LENGTH 32u

#define UID_SIZE 32u
typedef struct {
  // Magic Number omitted since it is always the same.
  uint16_t headerVersion;
  uint16_t headerLength;
  uint16_t fieldControl;
  uint16_t manufacturerId;
  uint16_t imageTypeId;           // a.k.a. Device ID
  uint32_t firmwareVersion;
  uint16_t zigbeeStackVersion;

  uint8_t headerString[SL_ZIGBEE_AF_OTA_MAX_HEADER_STRING_LENGTH + 1];

  uint32_t imageSize;

  uint8_t securityCredentials;
  union {
    uint8_t EUI64[EUI64_SIZE];
    uint8_t UID[UID_SIZE];
  } upgradeFileDestination;
  uint16_t minimumHardwareVersion;
  uint16_t maximumHardwareVersion;
} sl_zigbee_af_ota_header_t;

typedef struct {
  uint16_t id;
  uint32_t length;
} sl_zigbee_af_tag_data_t;

typedef enum {
  NO_APP_MESSAGE               = 0,
  RECEIVED_PARTNER_CERTIFICATE = 1,
  GENERATING_EPHEMERAL_KEYS    = 2,
  GENERATING_SHARED_SECRET     = 3,
  KEY_GENERATION_DONE          = 4,
  GENERATE_SHARED_SECRET_DONE  = 5,
  LINK_KEY_ESTABLISHED         = 6,

  NO_LOCAL_RESOURCES          = 7,
  PARTNER_NO_RESOURCES        = 8,
  TIMEOUT_OCCURRED            = 9,
  INVALID_APP_COMMAND         = 10,
  MESSAGE_SEND_FAILURE        = 11,
  PARTNER_SENT_TERMINATE      = 12,
  INVALID_PARTNER_MESSAGE     = 13,
  PARTNER_SENT_DEFAULT_RESPONSE_ERROR = 14,

  BAD_CERTIFICATE_ISSUER      = 15,
  KEY_CONFIRM_FAILURE         = 16,
  BAD_KEY_ESTABLISHMENT_SUITE = 17,

  KEY_TABLE_FULL              = 18,

  NO_ESTABLISHMENT_ALLOWED    = 19,

  /* 283k1 certificates need to have valid key usage.
   */
  INVALID_CERTIFICATE_KEY_USAGE = 20,
} sl_zigbee_af_key_establishment_notify_message_t;

#define APP_NOTIFY_ERROR_CODE_START NO_LOCAL_RESOURCES
#define APP_NOTIFY_MESSAGE_TEXT { \
    "None",                       \
    "Received Cert",              \
    "Generate keys",              \
    "Generate secret",            \
    "Key generate done",          \
    "Generate secret done",       \
    "Link key verified",          \
                                  \
    /* Transient Error codes */   \
    "No local resources",         \
    "Partner no resources",       \
    "Timeout",                    \
    "Invalid app. command",       \
    "Message send failure",       \
    "Partner sent terminate",     \
    "Bad message",                \
    "Partner sent Default Rsp",   \
                                  \
    /* Fatal errors */            \
    "Bad cert issuer",            \
    "Key confirm failure",        \
    "Bad key est. suite",         \
    "Key table full",             \
    "Not allowed",                \
    "Invalid Key Usage",          \
}

typedef enum {
  SL_ZIGBEE_AF_IMAGE_GOOD                 = 0,
  SL_ZIGBEE_AF_IMAGE_BAD                  = 1,
  SL_ZIGBEE_AF_IMAGE_VERIFY_IN_PROGRESS   = 2,

#ifndef DOXYGEN_SHOULD_SKIP_THIS
  // Internal use only.
  SL_ZIGBEE_AF_IMAGE_VERIFY_WAIT          = 3,
  SL_ZIGBEE_AF_IMAGE_VERIFY_ERROR         = 4,
  SL_ZIGBEE_AF_IMAGE_UNKNOWN              = 5,
  SL_ZIGBEE_AF_NO_IMAGE_VERIFY_SUPPORT    = 6,
#endif
} sl_zigbee_af_image_verify_status_t;

typedef void (*sl_zigbee_af_tick_function_t)(uint8_t endpoint);

typedef void (*sl_zigbee_af_init_function_t)(uint8_t endpoint);

typedef void (*sl_zigbee_af_cluster_attribute_changed_callback_t)(uint8_t endpoint,
                                                                  sl_zigbee_af_attribute_id_t attributeId);

typedef void (*sl_zigbee_af_manufacturer_specific_cluster_attribute_changed_callback_t)(uint8_t endpoint,
                                                                                        sl_zigbee_af_attribute_id_t attributeId,
                                                                                        uint16_t manufacturerCode);

typedef sl_zigbee_af_status_t (*sl_zigbee_af_cluster_pre_attribute_changed_callback_t)(uint8_t endpoint,
                                                                                       sl_zigbee_af_attribute_id_t attributeId,
                                                                                       sl_zigbee_af_attribute_type_t attributeType,
                                                                                       uint8_t size,
                                                                                       uint8_t *value);

typedef void (*sl_zigbee_af_default_response_function_t)(uint8_t endpoint,
                                                         uint8_t commandId,
                                                         sl_zigbee_af_status_t status);

typedef void (*sl_zigbee_af_message_sent_function_t)(sl_zigbee_outgoing_message_type_t type,
                                                     uint16_t indexOrDestination,
                                                     sl_zigbee_aps_frame_t *apsFrame,
                                                     uint16_t msgLen,
                                                     uint8_t *message,
                                                     sl_status_t status);

typedef struct {
  sl_zigbee_af_message_sent_function_t callback;
  sl_zigbee_aps_frame_t* apsFrame;
  uint8_t* message;
  uint16_t indexOrDestination;
  uint16_t messageLength;
  sl_zigbee_outgoing_message_type_t type;
  bool broadcast;
} sl_zigbee_af_message_struct_t;

typedef struct {
  sl_802154_long_addr_t deviceId;
  sl_zigbee_key_data_t key;
} sl_zigbee_af_link_key_backup_data_t;

typedef struct {
  sl_802154_long_addr_t extendedPanId;
  uint8_t keyListLength;
  uint8_t maxKeyListLength;
  sl_zigbee_af_link_key_backup_data_t* keyList;
} sl_zigbee_af_trust_center_backup_data_t;

#define SL_ZIGBEE_AF_STANDALONE_BOOTLOADER_HARDWARE_TAG_LENGTH 16u

typedef struct {
  uint8_t hardwareTag[SL_ZIGBEE_AF_STANDALONE_BOOTLOADER_HARDWARE_TAG_LENGTH];
  uint8_t eui64[EUI64_SIZE];
  uint16_t mfgId;
  uint16_t bootloaderVersion;
  uint8_t capabilities;
  uint8_t platform;
  uint8_t micro;
  uint8_t phy;
  bool bootloaderActive;
} sl_zigbee_af_standalone_bootloader_query_response_data_t;

typedef struct {
  uint16_t clusterId;
  uint8_t commandId;
  uint8_t mask;
} sl_zigbee_af_command_metadata_t;

typedef struct {
  uint16_t year;
  uint8_t month;
  uint8_t day;
  uint8_t hours;
  uint8_t minutes;
  uint8_t seconds;
} sl_zigbee_af_time_struct_t;

typedef struct {
  uint8_t year;
  uint8_t month;
  uint8_t dayOfMonth;
  uint8_t dayOfWeek;
} sl_zigbee_af_date_t;

/* Simple Metering Server Test Code */
#define SL_ZIGBEE_AF_PLUGIN_SIMPLE_METERING_SERVER_ELECTRIC_METER 0
#define SL_ZIGBEE_AF_PLUGIN_SIMPLE_METERING_SERVER_GAS_METER 1

// Functional Notification Flags
// Also #defined in enums.h under slightly different names
#define SL_ZIGBEE_AF_METERING_FNF_NEW_OTA_FIRMWARE                               0x00000001
#define SL_ZIGBEE_AF_METERING_FNF_CBKE_UPDATE_REQUEST                            0x00000002
#define SL_ZIGBEE_AF_METERING_FNF_TIME_SYNC                                      0x00000004
#define SL_ZIGBEE_AF_METERING_FNF_STAY_AWAKE_REQUEST_HAN                         0x00000010
#define SL_ZIGBEE_AF_METERING_FNF_STAY_AWAKE_REQUEST_WAN                         0x00000020
#define SL_ZIGBEE_AF_METERING_FNF_PUSH_HISTORICAL_METERING_DATA_ATTRIBUTE_SET    0x000001C0
#define SL_ZIGBEE_AF_METERING_FNF_PUSH_HISTORICAL_PREPAYMENT_DATA_ATTRIBUTE_SET  0x00000E00
#define SL_ZIGBEE_AF_METERING_FNF_PUSH_ALL_STATIC_DATA_BASIC_CLUSTER             0x00001000
#define SL_ZIGBEE_AF_METERING_FNF_PUSH_ALL_STATIC_DATA_METERING_CLUSTER          0x00002000
#define SL_ZIGBEE_AF_METERING_FNF_PUSH_ALL_STATIC_DATA_PREPAYMENT_CLUSTER        0x00004000
#define SL_ZIGBEE_AF_METERING_FNF_NETWORK_KEY_ACTIVE                             0x00008000
#define SL_ZIGBEE_AF_METERING_FNF_DISPLAY_MESSAGE                                0x00010000
#define SL_ZIGBEE_AF_METERING_FNF_CANCEL_ALL_MESSAGES                            0x00020000
#define SL_ZIGBEE_AF_METERING_FNF_CHANGE_SUPPLY                                  0x00040000
#define SL_ZIGBEE_AF_METERING_FNF_LOCAL_CHANGE_SUPPLY                            0x00080000
#define SL_ZIGBEE_AF_METERING_FNF_SET_UNCONTROLLED_FLOW_THRESHOLD                0x00100000
#define SL_ZIGBEE_AF_METERING_FNF_TUNNEL_MESSAGE_PENDING                         0x00200000
#define SL_ZIGBEE_AF_METERING_FNF_GET_SNAPSHOT                                   0x00400000
#define SL_ZIGBEE_AF_METERING_FNF_GET_SAMPLED_DATA                               0x00800000
#define SL_ZIGBEE_AF_METERING_FNF_NEW_SUB_GHZ_CHANNEL_MASKS_AVAILABLE            0x01000000
#define SL_ZIGBEE_AF_METERING_FNF_ENERGY_SCAN_PENDING                            0x02000000
#define SL_ZIGBEE_AF_METERING_FNF_CHANNEL_CHANGE_PENDING                         0x04000000

// Notification Flags 2
#define SL_ZIGBEE_AF_METERING_NF2_PUBLISH_PRICE                                  0x00000001
#define SL_ZIGBEE_AF_METERING_NF2_PUBLISH_BLOCK_PERIOD                           0x00000002
#define SL_ZIGBEE_AF_METERING_NF2_PUBLISH_TARIFF_INFORMATION                     0x00000004
#define SL_ZIGBEE_AF_METERING_NF2_PUBLISH_CONVERSION_FACTOR                      0x00000008
#define SL_ZIGBEE_AF_METERING_NF2_PUBLISH_CALORIFIC_VALUE                        0x00000010
#define SL_ZIGBEE_AF_METERING_NF2_PUBLISH_CO2_VALUE                              0x00000020
#define SL_ZIGBEE_AF_METERING_NF2_PUBLISH_BILLING_PERIOD                         0x00000040
#define SL_ZIGBEE_AF_METERING_NF2_PUBLISH_CONSOLIDATED_BILL                      0x00000080
#define SL_ZIGBEE_AF_METERING_NF2_PUBLISH_PRICE_MATRIX                           0x00000100
#define SL_ZIGBEE_AF_METERING_NF2_PUBLISH_BLOCK_THRESHOLDS                       0x00000200
#define SL_ZIGBEE_AF_METERING_NF2_PUBLISH_CURRENCY_CONVERSION                    0x00000400
#define SL_ZIGBEE_AF_METERING_NF2_PUBLISH_CREDIT_PAYMENT_INFO                    0x00001000
#define SL_ZIGBEE_AF_METERING_NF2_PUBLISH_CPP_EVENT                              0x00002000
#define SL_ZIGBEE_AF_METERING_NF2_PUBLISH_TIER_LABELS                            0x00004000
#define SL_ZIGBEE_AF_METERING_NF2_CANCEL_TARIFF                                  0x00008000

// Notification Flags 3
#define SL_ZIGBEE_AF_METERING_NF3_PUBLISH_CALENDAR                               0x00000001
#define SL_ZIGBEE_AF_METERING_NF3_PUBLISH_SPECIAL_DAYS                           0x00000002
#define SL_ZIGBEE_AF_METERING_NF3_PUBLISH_SEASONS                                0x00000004
#define SL_ZIGBEE_AF_METERING_NF3_PUBLISH_WEEK                                   0x00000008
#define SL_ZIGBEE_AF_METERING_NF3_PUBLISH_DAY                                    0x00000010
#define SL_ZIGBEE_AF_METERING_NF3_CANCEL_CALENDAR                                0x00000020

// Notification Flags 4
#define SL_ZIGBEE_AF_METERING_NF4_SELECT_AVAILABLE_EMERGENCY_CREDIT              0x00000001
#define SL_ZIGBEE_AF_METERING_NF4_CHANGE_DEBT                                    0x00000002
#define SL_ZIGBEE_AF_METERING_NF4_EMERGENCY_CREDIT_SETUP                         0x00000004
#define SL_ZIGBEE_AF_METERING_NF4_CONSUMER_TOP_UP                                0x00000008
#define SL_ZIGBEE_AF_METERING_NF4_CREDIT_ADJUSTMENT                              0x00000010
#define SL_ZIGBEE_AF_METERING_NF4_CHANGE_PAYMENT_MODE                            0x00000020
#define SL_ZIGBEE_AF_METERING_NF4_GET_PREPAY_SNAPSHOT                            0x00000040
#define SL_ZIGBEE_AF_METERING_NF4_GET_TOP_UP_LOG                                 0x00000080
#define SL_ZIGBEE_AF_METERING_NF4_SET_LOW_CREDIT_WARNING_LEVEL                   0x00000100
#define SL_ZIGBEE_AF_METERING_NF4_GET_DEBT_REPAYMENT_LOG                         0x00000200
#define SL_ZIGBEE_AF_METERING_NF4_SET_MAXIMUM_CREDIT_LIMIT                       0x00000400
#define SL_ZIGBEE_AF_METERING_NF4_SET_OVERALL_DEBT_CAP                           0x00000800

// Notification Flags 5
#define SL_ZIGBEE_AF_METERING_NF5_PUBLISH_CHANGE_OF_TENANCY                      0x00000001
#define SL_ZIGBEE_AF_METERING_NF5_PUBLISH_CHANGE_OF_SUPPLIER                     0x00000002
#define SL_ZIGBEE_AF_METERING_NF5_REQUEST_NEW_PASSWORD_1_RESPONSE                0x00000004
#define SL_ZIGBEE_AF_METERING_NF5_REQUEST_NEW_PASSWORD_2_RESPONSE                0x00000008
#define SL_ZIGBEE_AF_METERING_NF5_REQUEST_NEW_PASSWORD_3_RESPONSE                0x00000010
#define SL_ZIGBEE_AF_METERING_NF5_REQUEST_NEW_PASSWORD_4_RESPONSE                0x00000020
#define SL_ZIGBEE_AF_METERING_NF5_UPDATE_SITE_ID                                 0x00000040
#define SL_ZIGBEE_AF_METERING_NF5_RESET_BATTERY_COUNTER                          0x00000080
#define SL_ZIGBEE_AF_METERING_NF5_UPDATE_CIN                                     0x00000100

#ifdef DOXYGEN_SHOULD_SKIP_THIS
enum sl_zigbee_af_cbke_key_establishment_suite_t
#else
typedef uint16_t sl_zigbee_af_cbke_key_establishment_suite_t;
enum
#endif
{
  SL_ZIGBEE_AF_INVALID_KEY_ESTABLISHMENT_SUITE      = 0x0000,
  SL_ZIGBEE_AF_CBKE_KEY_ESTABLISHMENT_SUITE_163K1   = 0x0001,
  SL_ZIGBEE_AF_CBKE_KEY_ESTABLISHMENT_SUITE_283K1   = 0x0002,
};

#define SL_ZIGBEE_AF_DEVICE_MANAGEMENT_MAXIMUM_PROPOSED_PROVIDER_NAME_LENGTH (16u)
#define SL_ZIGBEE_AF_DEVICE_MANAGEMENT_MAXIMUM_PROPOSED_PROVIDER_CONTACT_DETAILS_LENGTH (18u)
#define SL_ZIGBEE_AF_DEVICE_MANAGEMENT_MAXIMUM_SITE_ID_LENGTH (32u)
#define SL_ZIGBEE_AF_DEVICE_MANAGEMENT_MAXIMUM_CIN_LENGTH (24u)
#define SL_ZIGBEE_AF_DEVICE_MANAGEMENT_MAXIMUM_PASSWORD_LENGTH (10u)

#ifdef DOXYGEN_SHOULD_SKIP_THIS
enum sl_zigbee_af_device_management_password_type_t
#else
typedef uint16_t sl_zigbee_af_device_management_password_type_t;
enum
#endif
{
  UNUSED_PASSWORD   = 0x00,
  SERVICE_PASSWORD  = 0x01,
  CONSUMER_PASSWORD = 0x02,
};

#ifdef DOXYGEN_SHOULD_SKIP_THIS
enum sl_zigbee_af_device_management_change_pending_flags_t
#else
typedef uint8_t sl_zigbee_af_device_management_change_pending_flags_t;
enum
#endif
{
  SL_ZIGBEE_AF_DEVICE_MANAGEMENT_CHANGE_OF_TENANCY_PENDING_MASK              = 0x01,
  SL_ZIGBEE_AF_DEVICE_MANAGEMENT_CHANGE_OF_SUPPLIER_PENDING_MASK             = 0x02,
  SL_ZIGBEE_AF_DEVICE_MANAGEMENT_UPDATE_SITE_ID_PENDING_MASK                 = 0x04,
  SL_ZIGBEE_AF_DEVICE_MANAGEMENT_UPDATE_CIN_PENDING_MASK                     = 0x08,
  SL_ZIGBEE_AF_DEVICE_MANAGEMENT_UPDATE_SERVICE_PASSWORD_PENDING_MASK        = 0x10,
  SL_ZIGBEE_AF_DEVICE_MANAGEMENT_UPDATE_CONSUMER_PASSWORD_PENDING_MASK       = 0x20,
};

typedef struct {
  // Optional fields only used by Gas Proxy Function plugin.
  uint32_t providerId;
  uint32_t issuerEventId;
  uint8_t tariffType;

  // always used fields
  uint32_t implementationDateTime;
  uint32_t tenancy;
} sl_zigbee_af_device_management_tenancy_t;

typedef struct {
  uint32_t proposedProviderId;
  uint32_t implementationDateTime;
  uint32_t providerChangeControl;
  uint8_t proposedProviderName[SL_ZIGBEE_AF_DEVICE_MANAGEMENT_MAXIMUM_PROPOSED_PROVIDER_NAME_LENGTH + 1];
  uint8_t proposedProviderContactDetails[SL_ZIGBEE_AF_DEVICE_MANAGEMENT_MAXIMUM_PROPOSED_PROVIDER_CONTACT_DETAILS_LENGTH + 1];
} sl_zigbee_af_device_management_supplier_t;

typedef struct {
  uint32_t requestDateTime;
  uint32_t implementationDateTime;
  uint8_t supplyStatus;
  uint8_t originatorIdSupplyControlBits;
} sl_zigbee_af_device_management_supply_t;

typedef struct {
  uint8_t siteId[SL_ZIGBEE_AF_DEVICE_MANAGEMENT_MAXIMUM_SITE_ID_LENGTH + 1];
  uint32_t implementationDateTime;
  uint32_t issuerEventId;
} sl_zigbee_af_device_management_site_id_t;

typedef struct {
  uint8_t cin[SL_ZIGBEE_AF_DEVICE_MANAGEMENT_MAXIMUM_CIN_LENGTH + 1];
  uint32_t implementationDateTime;
  uint32_t issuerEventId;
} sl_zigbee_af_device_management_c_i_n_t;

typedef struct {
  bool supplyTamperState;
  bool supplyDepletionState;
  bool supplyUncontrolledFlowState;
  bool loadLimitSupplyState;
} sl_zigbee_af_device_management_supply_status_flags_t;

typedef struct {
  uint16_t uncontrolledFlowThreshold;
  uint16_t multiplier;
  uint16_t divisor;
  uint16_t measurementPeriod;
  uint8_t unitOfMeasure;
  uint8_t stabilisationPeriod;
} sl_zigbee_af_device_management_uncontrolled_flow_threshold_t;

typedef struct {
  uint32_t implementationDateTime;
  uint8_t supplyStatus;
} sl_zigbee_af_device_management_supply_status_t;

typedef struct {
  uint8_t password[SL_ZIGBEE_AF_DEVICE_MANAGEMENT_MAXIMUM_PASSWORD_LENGTH + 1];
  uint32_t implementationDateTime;
  uint16_t durationInMinutes;
  sl_zigbee_af_device_management_password_type_t passwordType;
} sl_zigbee_af_device_management_password_t;

typedef struct {
  sl_zigbee_af_device_management_tenancy_t tenancy;
  sl_zigbee_af_device_management_supplier_t supplier;
  sl_zigbee_af_device_management_supply_t supply;
  sl_zigbee_af_device_management_site_id_t siteId;
  sl_zigbee_af_device_management_c_i_n_t cin;
  sl_zigbee_af_device_management_supply_status_flags_t supplyStatusFlags;
  sl_zigbee_af_device_management_supply_status_t supplyStatus;
  //TODO: These passwords ought to be tokenized / hashed
  sl_zigbee_af_device_management_password_t servicePassword;
  sl_zigbee_af_device_management_password_t consumerPassword;
  sl_zigbee_af_device_management_uncontrolled_flow_threshold_t threshold;
  uint32_t providerId;
  uint32_t issuerEventId;
  uint8_t proposedLocalSupplyStatus;
  sl_zigbee_af_tariff_type_t tariffType;
  sl_zigbee_af_device_management_change_pending_flags_t pendingUpdates;
} sl_zigbee_af_device_management_info_t;

typedef struct {
  uint8_t startIndex;
  uint8_t endIndex;
} sl_zigbee_af_device_management_attribute_range_t;

// attrRange is a list of attributeId values in a cluster. It's needed to track contiguous
// segments of valid attributeId's with gaps in the middle.
// attributeSetId is the value of the upper byte in the attributeId. It ranges from 0x01(Price)
// to 0x08(OTA Event Configuration)
// Eg. {0x00,0x05} and {0x08,0x0A}
// We're betting that there isn't a list of cluster attributes that has more than 5 gaps.
typedef struct {
  uint8_t attributeSetId;
  sl_zigbee_af_device_management_attribute_range_t attributeRange[7];
} sl_zigbee_af_device_management_attribute_table_t;

typedef struct {
  bool encryption;

  uint8_t * plainPayload;
  uint16_t plainPayloadLength;

  uint8_t * encryptedPayload;
  uint16_t encryptedPayloadLength;
} sl_zigbee_af_gbz_message_data_t;

typedef struct {
  uint8_t * gbzCommands;
  uint16_t  gbzCommandsLength;
  uint8_t * gbzCommandsResponse;
  uint16_t  gbzCommandsResponseLength;
  uint16_t  messageCode;
} sl_zigbee_af_gpf_message_t;

typedef uint16_t sl_zigbee_af_remote_cluster_type_t;

#define SL_ZIGBEE_AF_REMOTE_CLUSTER_TYPE_NONE     0x0000u
#define SL_ZIGBEE_AF_REMOTE_CLUSTER_TYPE_SERVER   0x0001u
#define SL_ZIGBEE_AF_REMOTE_CLUSTER_TYPE_CLIENT   0x0002u
#define SL_ZIGBEE_AF_REMOTE_CLUSTER_TYPE_INVALID  0xFFFFu

typedef struct {
  sl_zigbee_af_cluster_id_t clusterId;
  sl_zigbee_af_profile_id_t profileId;
  uint16_t deviceId;
  uint8_t endpoint;
  sl_zigbee_af_remote_cluster_type_t type;
} sl_zigbee_af_remote_cluster_struct_t;

typedef struct {
  sl_802154_long_addr_t targetEUI64;
  uint8_t sourceEndpoint;
  uint8_t destEndpoint;
  uint16_t clusterId;
  sl_802154_long_addr_t destEUI64;
  sl_802154_long_addr_t sourceEUI64;
} sl_zigbee_af_remote_binding_struct_t;

typedef struct {
  sl_zigbee_af_cluster_id_t clusterId;
  bool server;
} sl_zigbee_af_cluster_info_t;

#ifdef SL_CATALOG_ZIGBEE_DEVICE_DATABASE_PRESENT
#include "device-database-config.h"
#else
#define SL_ZIGBEE_AF_MAX_CLUSTERS_PER_ENDPOINT 3u
#define SL_ZIGBEE_AF_MAX_ENDPOINTS_PER_DEVICE  1u
#endif
typedef struct {
  sl_zigbee_af_cluster_info_t clusters[SL_ZIGBEE_AF_MAX_CLUSTERS_PER_ENDPOINT];
  sl_zigbee_af_profile_id_t profileId;
  uint16_t deviceId;
  uint8_t endpoint;
  uint8_t clusterCount;
} sl_zigbee_af_endpoint_info_struct_t;

// Although we treat this like a bitmap, only 1 bit is set at a time.
// We use the bitmap feature to allow us to find all devices
// with any in a set of status codes using
// sl_zigbee_af_device_database_find_device_by_status().
typedef enum {
  SL_ZIGBEE_AF_DEVICE_DISCOVERY_STATUS_NONE                 = 0x00,
  SL_ZIGBEE_AF_DEVICE_DISCOVERY_STATUS_NEW                  = 0x01,
  SL_ZIGBEE_AF_DEVICE_DISCOVERY_STATUS_FIND_ENDPOINTS       = 0x02,
  SL_ZIGBEE_AF_DEVICE_DISCOVERY_STATUS_FIND_CLUSTERS        = 0x04,
  SL_ZIGBEE_AF_DEVICE_DISCOVERY_STATUS_FIND_STACK_REVISION  = 0x08,

  SL_ZIGBEE_AF_DEVICE_DISCOVERY_STATUS_DONE      = 0x40,
  SL_ZIGBEE_AF_DEVICE_DISCOVERY_STATUS_FAILED    = 0x80,
} sl_zigbee_af_device_discovery_status_t;

typedef struct {
  sl_802154_long_addr_t eui64;
  sl_zigbee_af_endpoint_info_struct_t endpoints[SL_ZIGBEE_AF_MAX_ENDPOINTS_PER_DEVICE];
  sl_zigbee_af_device_discovery_status_t status;
  uint8_t discoveryFailures;
  uint8_t capabilities;
  uint8_t endpointCount;
  uint8_t stackRevision;
} sl_zigbee_af_device_info_t;

typedef struct {
  uint16_t deviceIndex;
} sl_zigbee_af_device_database_iterator_t;

typedef struct {
  sl_802154_short_addr_t sl_zigbee_node_id;
  uint32_t timeStamp;
} sl_zigbee_af_joining_device_t;

#define SL_ZIGBEE_AF_INVALID_CLUSTER_ID 0xFFFFu

#define SL_ZIGBEE_AF_INVALID_ENDPOINT 0xFFu

#define SL_ZIGBEE_AF_INVALID_ENDPOINT_INDEX 0xFFu

#define SL_ZIGBEE_AF_INVALID_PAN_ID 0xFFFFu

#define SL_ZIGBEE_AF_PERMIT_JOIN_FOREVER     0xFFu
#define SL_ZIGBEE_AF_PERMIT_JOIN_MAX_TIMEOUT 0xFEu

#define SL_ZIGBEE_AF_ZDO_RESPONSE_OVERHEAD 2u

#endif // SILABS_AF_API_TYPES

Modules#

sli_cluster_function_structure_t

sl_zigbee_af_default_attribute_value_t

sl_zigbee_af_attribute_min_max_value_t

sl_zigbee_af_default_or_min_max_attribute_value_t

sl_zigbee_af_attribute_metadata_t

sl_zigbee_af_cluster_t

sl_zigbee_af_attribute_search_record_t

sl_zigbee_af_manufacturer_code_entry_t

sl_zigbee_af_incoming_message_t

sl_zigbee_af_interpan_header_t

sl_zigbee_af_allowed_inter_pan_message_t

sl_zigbee_af_cluster_command_t

sl_zigbee_af_endpoint_type_t

sl_zigbee_af_security_profile_data_t

sl_zigbee_af_defined_endpoint_t

sl_zigbee_af_load_control_event_t

sl_zigbee_af_service_discovery_result_t

sl_zigbee_af_endpoint_list_t

sl_zigbee_af_cluster_list_t

sl_zigbee_af_event_context

sl_zigbee_event_context_t

sl_zigbee_af_group_table_entry_t

sl_zigbee_af_scene_table_entry_t

sl_zigbee_af_plugin_messaging_client_message_t

sl_zigbee_af_plugin_price_client_price_t

sl_zigbee_af_plugin_reporting_entry_t

sl_zigbee_af_plugin_zll_commissioning_group_information_record_t

sl_zigbee_af_plugin_zll_commissioning_endpoint_information_record_t

sl_zigbee_af_ota_image_id_t

sl_zigbee_af_image_block_request_callback_struct_t

sl_zigbee_af_ota_header_t

sl_zigbee_af_tag_data_t

sl_zigbee_af_message_struct_t

sl_zigbee_af_link_key_backup_data_t

sl_zigbee_af_trust_center_backup_data_t

sl_zigbee_af_standalone_bootloader_query_response_data_t

sl_zigbee_af_command_metadata_t

sl_zigbee_af_time_struct_t

sl_zigbee_af_date_t

sl_zigbee_af_device_management_tenancy_t

sl_zigbee_af_device_management_supplier_t

sl_zigbee_af_device_management_supply_t

sl_zigbee_af_device_management_site_id_t

sl_zigbee_af_device_management_c_i_n_t

sl_zigbee_af_device_management_supply_status_flags_t

sl_zigbee_af_device_management_uncontrolled_flow_threshold_t

sl_zigbee_af_device_management_supply_status_t

sl_zigbee_af_device_management_password_t

sl_zigbee_af_device_management_info_t

sl_zigbee_af_device_management_attribute_range_t

sl_zigbee_af_device_management_attribute_table_t

sl_zigbee_af_gbz_message_data_t

sl_zigbee_af_gpf_message_t

sl_zigbee_af_remote_cluster_struct_t

sl_zigbee_af_remote_binding_struct_t

sl_zigbee_af_cluster_info_t

sl_zigbee_af_endpoint_info_struct_t

sl_zigbee_af_device_info_t

sl_zigbee_af_device_database_iterator_t

sl_zigbee_af_joining_device_t

0x0000u

0xFFFFu

0x00u

0x08u

0x0Cu

SL_ZIGBEE_AF_INTER_PAN_UNICAST

SL_ZIGBEE_AF_INTER_PAN_BROADCAST

SL_ZIGBEE_AF_INTER_PAN_MULTICAST

0x0000u

0x0001u

0x0002u

sl_zigbee_af_interpan_header_t

0x01u

0x02u

0x03u

0x04u

0x08u

SL_ZIGBEE_ALLOW_TC_LINK_KEY_REQUEST_AND_SEND_CURRENT_KEY

SL_ZIGBEE_DENY_TC_LINK_KEY_REQUESTS

SL_ZIGBEE_ALLOW_APP_LINK_KEY_REQUEST

SL_ZIGBEE_DENY_APP_LINK_KEY_REQUESTS

(0x05u)

(status)

0xFFu

0x00u

16u

0xFFu

0x00u

16u

0x0000u

0x00u

0

11u

0x00u

32u

32u

NO_LOCAL_RESOURCES

16u

0

1

0x00000001

0x00000002

0x00000004

0x00000010

0x00000020

0x000001C0

0x00000E00

0x00001000

0x00002000

0x00004000

0x00008000

0x00010000

0x00020000

0x00040000

0x00080000

0x00100000

0x00200000

0x00400000

0x00800000

0x01000000

0x02000000

0x04000000

0x00000001

0x00000002

0x00000004

0x00000008

0x00000010

0x00000020

0x00000040

0x00000080

0x00000100

0x00000200

0x00000400

0x00001000

0x00002000

0x00004000

0x00008000

0x00000001

0x00000002

0x00000004

0x00000008

0x00000010

0x00000020

0x00000001

0x00000002

0x00000004

0x00000008

0x00000010

0x00000020

0x00000040

0x00000080

0x00000100

0x00000200

0x00000400

0x00000800

0x00000001

0x00000002

0x00000004

0x00000008

0x00000010

0x00000020

0x00000040

0x00000080

0x00000100

(16u)

(18u)

(32u)

(24u)

(10u)

0x0000u

0x0001u

0x0002u

0xFFFFu

3u

1u

0xFFFFu

0xFFu

0xFFu

0xFFFFu

0xFFu

0xFEu

2u