text: /*
   *
   *    Copyright (c) 2021 Project CHIP Authors
   *
   *    Licensed under the Apache License, Version 2.0 (the "License");
   *    you may not use this file except in compliance with the License.
   *    You may obtain a copy of the License at
   *
   *        http://www.apache.org/licenses/LICENSE-2.0
   *
   *    Unless required by applicable law or agreed to in writing, software
   *    distributed under the License is distributed on an "AS IS" BASIS,
   *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   *    See the License for the specific language governing permissions and
   *    limitations under the License.
   */
  
  // THIS FILE IS GENERATED BY ZAP
  
  // Prevent multiple inclusion
  #pragma once
  
  #include "af-structs.h"
  #include <app/util/af-types.h>
  #include <app/util/basic-types.h>
  
  #include <app/Command.h>
  #include <lib/support/Span.h>
  
  /** @brief Cluster Init
   *
   * This function is called when a specific cluster is initialized. It gives the
   * application an opportunity to take care of cluster initialization procedures.
   * It is called exactly once for each endpoint where cluster is present.
   *
   * @param endpoint   Ver.: always
   * @param clusterId   Ver.: always
   */
  void emberAfClusterInitCallback(chip::EndpointId endpoint, chip::ClusterId clusterId);
  
  // Cluster Init Functions
  
  /** @brief Account Login Cluster Init
   *
   * Cluster Init
   *
   * @param endpoint    Endpoint that is being initialized
   */
  void emberAfAccountLoginClusterInitCallback(chip::EndpointId endpoint);
  
  /** @brief Application Basic Cluster Init
   *
   * Cluster Init
   *
   * @param endpoint    Endpoint that is being initialized
   */
  void emberAfApplicationBasicClusterInitCallback(chip::EndpointId endpoint);
  
  /** @brief Application Launcher Cluster Init
   *
   * Cluster Init
   *
   * @param endpoint    Endpoint that is being initialized
   */
  void emberAfApplicationLauncherClusterInitCallback(chip::EndpointId endpoint);
  
  /** @brief Audio Output Cluster Init
   *
   * Cluster Init
   *
   * @param endpoint    Endpoint that is being initialized
   */
  void emberAfAudioOutputClusterInitCallback(chip::EndpointId endpoint);
  
  /** @brief Color Control Cluster Init
   *
   * Cluster Init
   *
   * @param endpoint    Endpoint that is being initialized
   */
  void emberAfColorControlClusterInitCallback(chip::EndpointId endpoint);
  
  /** @brief Content Launch Cluster Init
   *
   * Cluster Init
   *
   * @param endpoint    Endpoint that is being initialized
   */
  void emberAfContentLaunchClusterInitCallback(chip::EndpointId endpoint);
  
  /** @brief General Commissioning Cluster Init
   *
   * Cluster Init
   *
   * @param endpoint    Endpoint that is being initialized
   */
  void emberAfGeneralCommissioningClusterInitCallback(chip::EndpointId endpoint);
  
  /** @brief General Diagnostics Cluster Init
   *
   * Cluster Init
   *
   * @param endpoint    Endpoint that is being initialized
   */
  void emberAfGeneralDiagnosticsClusterInitCallback(chip::EndpointId endpoint);
  
  /** @brief Keypad Input Cluster Init
   *
   * Cluster Init
   *
   * @param endpoint    Endpoint that is being initialized
   */
  void emberAfKeypadInputClusterInitCallback(chip::EndpointId endpoint);
  
  /** @brief Level Control Cluster Init
   *
   * Cluster Init
   *
   * @param endpoint    Endpoint that is being initialized
   */
  void emberAfLevelControlClusterInitCallback(chip::EndpointId endpoint);
  
  /** @brief Low Power Cluster Init
   *
   * Cluster Init
   *
   * @param endpoint    Endpoint that is being initialized
   */
  void emberAfLowPowerClusterInitCallback(chip::EndpointId endpoint);
  
  /** @brief Media Input Cluster Init
   *
   * Cluster Init
   *
   * @param endpoint    Endpoint that is being initialized
   */
  void emberAfMediaInputClusterInitCallback(chip::EndpointId endpoint);
  
  /** @brief Media Playback Cluster Init
   *
   * Cluster Init
   *
   * @param endpoint    Endpoint that is being initialized
   */
  void emberAfMediaPlaybackClusterInitCallback(chip::EndpointId endpoint);
  
  /** @brief On/off Cluster Init
   *
   * Cluster Init
   *
   * @param endpoint    Endpoint that is being initialized
   */
  void emberAfOnOffClusterInitCallback(chip::EndpointId endpoint);
  
  /** @brief TV Channel Cluster Init
   *
   * Cluster Init
   *
   * @param endpoint    Endpoint that is being initialized
   */
  void emberAfTvChannelClusterInitCallback(chip::EndpointId endpoint);
  
  /** @brief Target Navigator Cluster Init
   *
   * Cluster Init
   *
   * @param endpoint    Endpoint that is being initialized
   */
  void emberAfTargetNavigatorClusterInitCallback(chip::EndpointId endpoint);
  
  /** @brief Thread Network Diagnostics Cluster Init
   *
   * Cluster Init
   *
   * @param endpoint    Endpoint that is being initialized
   */
  void emberAfThreadNetworkDiagnosticsClusterInitCallback(chip::EndpointId endpoint);
  
  /** @brief Wake on LAN Cluster Init
   *
   * Cluster Init
   *
   * @param endpoint    Endpoint that is being initialized
   */
  void emberAfWakeOnLanClusterInitCallback(chip::EndpointId endpoint);
  
  /** @brief WiFi Network Diagnostics Cluster Init
   *
   * Cluster Init
   *
   * @param endpoint    Endpoint that is being initialized
   */
  void emberAfWiFiNetworkDiagnosticsClusterInitCallback(chip::EndpointId endpoint);
  
  // Cluster Server/Client Init Functions
  
  //
  // Account Login Cluster server
  //
  
  /** @brief Account Login Cluster Server Init
   *
   * Server Init
   *
   * @param endpoint    Endpoint that is being initialized
   */
  void emberAfAccountLoginClusterServerInitCallback(chip::EndpointId endpoint);
  
  /** @brief Account Login Cluster Server Attribute Changed
   *
   * Server Attribute Changed
   *
   * @param endpoint    Endpoint that is being initialized
   * @param attributeId Attribute that changed
   */
  void emberAfAccountLoginClusterServerAttributeChangedCallback(chip::EndpointId endpoint, chip::AttributeId attributeId);
  
  /** @brief Account Login Cluster Server Manufacturer Specific Attribute Changed
   *
   * Server Manufacturer Specific Attribute Changed
   *
   * @param endpoint          Endpoint that is being initialized
   * @param attributeId       Attribute that changed
   * @param manufacturerCode  Manufacturer Code of the attribute that changed
   */
  void emberAfAccountLoginClusterServerManufacturerSpecificAttributeChangedCallback(chip::EndpointId endpoint,
                                                                                    chip::AttributeId attributeId,
                                                                                    uint16_t manufacturerCode);
  
  /** @brief Account Login Cluster Server Message Sent
   *
   * Server Message Sent
   *
   * @param type               The type of message sent
   * @param destination        The destination to which the message was sent
   * @param apsFrame           The APS frame for the message
   * @param msgLen             The length of the message
   * @param message            The message that was sent
   * @param status             The status of the sent message
   */
  void emberAfAccountLoginClusterServerMessageSentCallback(EmberOutgoingMessageType type, chip::MessageSendDestination destination,
                                                           EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message,
                                                           EmberStatus status);
  
  /** @brief Account Login Cluster Server Pre Attribute Changed
   *
   * server Pre Attribute Changed
   *
   * @param endpoint      Endpoint that is being initialized
   * @param attributeId   Attribute to be changed
   * @param attributeType Attribute type
   * @param size          Attribute size
   * @param value         Attribute value
   */
  EmberAfStatus emberAfAccountLoginClusterServerPreAttributeChangedCallback(chip::EndpointId endpoint, chip::AttributeId attributeId,
                                                                            EmberAfAttributeType attributeType, uint16_t size,
                                                                            uint8_t * value);
  
  /** @brief Account Login Cluster Server Tick
   *
   * server Tick
   *
   * @param endpoint  Endpoint that is being served
   */
  void emberAfAccountLoginClusterServerTickCallback(chip::EndpointId endpoint);
  
  //
  // Application Basic Cluster server
  //
  
  /** @brief Application Basic Cluster Server Init
   *
   * Server Init
   *
   * @param endpoint    Endpoint that is being initialized
   */
  void emberAfApplicationBasicClusterServerInitCallback(chip::EndpointId endpoint);
  
  /** @brief Application Basic Cluster Server Attribute Changed
   *
   * Server Attribute Changed
   *
   * @param endpoint    Endpoint that is being initialized
   * @param attributeId Attribute that changed
   */
  void emberAfApplicationBasicClusterServerAttributeChangedCallback(chip::EndpointId endpoint, chip::AttributeId attributeId);
  
  /** @brief Application Basic Cluster Server Manufacturer Specific Attribute Changed
   *
   * Server Manufacturer Specific Attribute Changed
   *
   * @param endpoint          Endpoint that is being initialized
   * @param attributeId       Attribute that changed
   * @param manufacturerCode  Manufacturer Code of the attribute that changed
   */
  void emberAfApplicationBasicClusterServerManufacturerSpecificAttributeChangedCallback(chip::EndpointId endpoint,
                                                                                        chip::AttributeId attributeId,
                                                                                        uint16_t manufacturerCode);
  
  /** @brief Application Basic Cluster Server Message Sent
   *
   * Server Message Sent
   *
   * @param type               The type of message sent
   * @param destination        The destination to which the message was sent
   * @param apsFrame           The APS frame for the message
   * @param msgLen             The length of the message
   * @param message            The message that was sent
   * @param status             The status of the sent message
   */
  void emberAfApplicationBasicClusterServerMessageSentCallback(EmberOutgoingMessageType type,
                                                               chip::MessageSendDestination destination, EmberApsFrame * apsFrame,
                                                               uint16_t msgLen, uint8_t * message, EmberStatus status);
  
  /** @brief Application Basic Cluster Server Pre Attribute Changed
   *
   * server Pre Attribute Changed
   *
   * @param endpoint      Endpoint that is being initialized
   * @param attributeId   Attribute to be changed
   * @param attributeType Attribute type
   * @param size          Attribute size
   * @param value         Attribute value
   */
  EmberAfStatus emberAfApplicationBasicClusterServerPreAttributeChangedCallback(chip::EndpointId endpoint,
                                                                                chip::AttributeId attributeId,
                                                                                EmberAfAttributeType attributeType, uint16_t size,
                                                                                uint8_t * value);
  
  /** @brief Application Basic Cluster Server Tick
   *
   * server Tick
   *
   * @param endpoint  Endpoint that is being served
   */
  void emberAfApplicationBasicClusterServerTickCallback(chip::EndpointId endpoint);
  
  //
  // Application Launcher Cluster server
  //
  
  /** @brief Application Launcher Cluster Server Init
   *
   * Server Init
   *
   * @param endpoint    Endpoint that is being initialized
   */
  void emberAfApplicationLauncherClusterServerInitCallback(chip::EndpointId endpoint);
  
  /** @brief Application Launcher Cluster Server Attribute Changed
   *
   * Server Attribute Changed
   *
   * @param endpoint    Endpoint that is being initialized
   * @param attributeId Attribute that changed
   */
  void emberAfApplicationLauncherClusterServerAttributeChangedCallback(chip::EndpointId endpoint, chip::AttributeId attributeId);
  
  /** @brief Application Launcher Cluster Server Manufacturer Specific Attribute Changed
   *
   * Server Manufacturer Specific Attribute Changed
   *
   * @param endpoint          Endpoint that is being initialized
   * @param attributeId       Attribute that changed
   * @param manufacturerCode  Manufacturer Code of the attribute that changed
   */
  void emberAfApplicationLauncherClusterServerManufacturerSpecificAttributeChangedCallback(chip::EndpointId endpoint,
                                                                                           chip::AttributeId attributeId,
                                                                                           uint16_t manufacturerCode);
  
  /** @brief Application Launcher Cluster Server Message Sent
   *
   * Server Message Sent
   *
   * @param type               The type of message sent
   * @param destination        The destination to which the message was sent
   * @param apsFrame           The APS frame for the message
   * @param msgLen             The length of the message
   * @param message            The message that was sent
   * @param status             The status of the sent message
   */
  void emberAfApplicationLauncherClusterServerMessageSentCallback(EmberOutgoingMessageType type,
                                                                  chip::MessageSendDestination destination, EmberApsFrame * apsFrame,
                                                                  uint16_t msgLen, uint8_t * message, EmberStatus status);
  
  /** @brief Application Launcher Cluster Server Pre Attribute Changed
   *
   * server Pre Attribute Changed
   *
   * @param endpoint      Endpoint that is being initialized
   * @param attributeId   Attribute to be changed
   * @param attributeType Attribute type
   * @param size          Attribute size
   * @param value         Attribute value
   */
  EmberAfStatus emberAfApplicationLauncherClusterServerPreAttributeChangedCallback(chip::EndpointId endpoint,
                                                                                   chip::AttributeId attributeId,
                                                                                   EmberAfAttributeType attributeType, uint16_t size,
                                                                                   uint8_t * value);
  
  /** @brief Application Launcher Cluster Server Tick
   *
   * server Tick
   *
   * @param endpoint  Endpoint that is being served
   */
  void emberAfApplicationLauncherClusterServerTickCallback(chip::EndpointId endpoint);
  
  //
  // Audio Output Cluster server
  //
  
  /** @brief Audio Output Cluster Server Init
   *
   * Server Init
   *
   * @param endpoint    Endpoint that is being initialized
   */
  void emberAfAudioOutputClusterServerInitCallback(chip::EndpointId endpoint);
  
  /** @brief Audio Output Cluster Server Attribute Changed
   *
   * Server Attribute Changed
   *
   * @param endpoint    Endpoint that is being initialized
   * @param attributeId Attribute that changed
   */
  void emberAfAudioOutputClusterServerAttributeChangedCallback(chip::EndpointId endpoint, chip::AttributeId attributeId);
  
  /** @brief Audio Output Cluster Server Manufacturer Specific Attribute Changed
   *
   * Server Manufacturer Specific Attribute Changed
   *
   * @param endpoint          Endpoint that is being initialized
   * @param attributeId       Attribute that changed
   * @param manufacturerCode  Manufacturer Code of the attribute that changed
   */
  void emberAfAudioOutputClusterServerManufacturerSpecificAttributeChangedCallback(chip::EndpointId endpoint,
                                                                                   chip::AttributeId attributeId,
                                                                                   uint16_t manufacturerCode);
  
  /** @brief Audio Output Cluster Server Message Sent
   *
   * Server Message Sent
   *
   * @param type               The type of message sent
   * @param destination        The destination to which the message was sent
   * @param apsFrame           The APS frame for the message
   * @param msgLen             The length of the message
   * @param message            The message that was sent
   * @param status             The status of the sent message
   */
  void emberAfAudioOutputClusterServerMessageSentCallback(EmberOutgoingMessageType type, chip::MessageSendDestination destination,
                                                          EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message,
                                                          EmberStatus status);
  
  /** @brief Audio Output Cluster Server Pre Attribute Changed
   *
   * server Pre Attribute Changed
   *
   * @param endpoint      Endpoint that is being initialized
   * @param attributeId   Attribute to be changed
   * @param attributeType Attribute type
   * @param size          Attribute size
   * @param value         Attribute value
   */
  EmberAfStatus emberAfAudioOutputClusterServerPreAttributeChangedCallback(chip::EndpointId endpoint, chip::AttributeId attributeId,
                                                                           EmberAfAttributeType attributeType, uint16_t size,
                                                                           uint8_t * value);
  
  /** @brief Audio Output Cluster Server Tick
   *
   * server Tick
   *
   * @param endpoint  Endpoint that is being served
   */
  void emberAfAudioOutputClusterServerTickCallback(chip::EndpointId endpoint);
  
  //
  // Color Control Cluster server
  //
  
  /** @brief Color Control Cluster Server Init
   *
   * Server Init
   *
   * @param endpoint    Endpoint that is being initialized
   */
  void emberAfColorControlClusterServerInitCallback(chip::EndpointId endpoint);
  
  /** @brief Color Control Cluster Server Attribute Changed
   *
   * Server Attribute Changed
   *
   * @param endpoint    Endpoint that is being initialized
   * @param attributeId Attribute that changed
   */
  void emberAfColorControlClusterServerAttributeChangedCallback(chip::EndpointId endpoint, chip::AttributeId attributeId);
  
  /** @brief Color Control Cluster Server Manufacturer Specific Attribute Changed
   *
   * Server Manufacturer Specific Attribute Changed
   *
   * @param endpoint          Endpoint that is being initialized
   * @param attributeId       Attribute that changed
   * @param manufacturerCode  Manufacturer Code of the attribute that changed
   */
  void emberAfColorControlClusterServerManufacturerSpecificAttributeChangedCallback(chip::EndpointId endpoint,
                                                                                    chip::AttributeId attributeId,
                                                                                    uint16_t manufacturerCode);
  
  /** @brief Color Control Cluster Server Message Sent
   *
   * Server Message Sent
   *
   * @param type               The type of message sent
   * @param destination        The destination to which the message was sent
   * @param apsFrame           The APS frame for the message
   * @param msgLen             The length of the message
   * @param message            The message that was sent
   * @param status             The status of the sent message
   */
  void emberAfColorControlClusterServerMessageSentCallback(EmberOutgoingMessageType type, chip::MessageSendDestination destination,
                                                           EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message,
                                                           EmberStatus status);
  
  /** @brief Color Control Cluster Server Pre Attribute Changed
   *
   * server Pre Attribute Changed
   *
   * @param endpoint      Endpoint that is being initialized
   * @param attributeId   Attribute to be changed
   * @param attributeType Attribute type
   * @param size          Attribute size
   * @param value         Attribute value
   */
  EmberAfStatus emberAfColorControlClusterServerPreAttributeChangedCallback(chip::EndpointId endpoint, chip::AttributeId attributeId,
                                                                            EmberAfAttributeType attributeType, uint16_t size,
                                                                            uint8_t * value);
  
  /** @brief Color Control Cluster Server Tick
   *
   * server Tick
   *
   * @param endpoint  Endpoint that is being served
   */
  void emberAfColorControlClusterServerTickCallback(chip::EndpointId endpoint);
  
  //
  // Content Launch Cluster server
  //
  
  /** @brief Content Launch Cluster Server Init
   *
   * Server Init
   *
   * @param endpoint    Endpoint that is being initialized
   */
  void emberAfContentLaunchClusterServerInitCallback(chip::EndpointId endpoint);
  
  /** @brief Content Launch Cluster Server Attribute Changed
   *
   * Server Attribute Changed
   *
   * @param endpoint    Endpoint that is being initialized
   * @param attributeId Attribute that changed
   */
  void emberAfContentLaunchClusterServerAttributeChangedCallback(chip::EndpointId endpoint, chip::AttributeId attributeId);
  
  /** @brief Content Launch Cluster Server Manufacturer Specific Attribute Changed
   *
   * Server Manufacturer Specific Attribute Changed
   *
   * @param endpoint          Endpoint that is being initialized
   * @param attributeId       Attribute that changed
   * @param manufacturerCode  Manufacturer Code of the attribute that changed
   */
  void emberAfContentLaunchClusterServerManufacturerSpecificAttributeChangedCallback(chip::EndpointId endpoint,
                                                                                     chip::AttributeId attributeId,
                                                                                     uint16_t manufacturerCode);
  
  /** @brief Content Launch Cluster Server Message Sent
   *
   * Server Message Sent
   *
   * @param type               The type of message sent
   * @param destination        The destination to which the message was sent
   * @param apsFrame           The APS frame for the message
   * @param msgLen             The length of the message
   * @param message            The message that was sent
   * @param status             The status of the sent message
   */
  void emberAfContentLaunchClusterServerMessageSentCallback(EmberOutgoingMessageType type, chip::MessageSendDestination destination,
                                                            EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message,
                                                            EmberStatus status);
  
  /** @brief Content Launch Cluster Server Pre Attribute Changed
   *
   * server Pre Attribute Changed
   *
   * @param endpoint      Endpoint that is being initialized
   * @param attributeId   Attribute to be changed
   * @param attributeType Attribute type
   * @param size          Attribute size
   * @param value         Attribute value
   */
  EmberAfStatus emberAfContentLaunchClusterServerPreAttributeChangedCallback(chip::EndpointId endpoint, chip::AttributeId attributeId,
                                                                             EmberAfAttributeType attributeType, uint16_t size,
                                                                             uint8_t * value);
  
  /** @brief Content Launch Cluster Server Tick
   *
   * server Tick
   *
   * @param endpoint  Endpoint that is being served
   */
  void emberAfContentLaunchClusterServerTickCallback(chip::EndpointId endpoint);
  
  //
  // General Commissioning Cluster server
  //
  
  /** @brief General Commissioning Cluster Server Init
   *
   * Server Init
   *
   * @param endpoint    Endpoint that is being initialized
   */
  void emberAfGeneralCommissioningClusterServerInitCallback(chip::EndpointId endpoint);
  
  /** @brief General Commissioning Cluster Server Attribute Changed
   *
   * Server Attribute Changed
   *
   * @param endpoint    Endpoint that is being initialized
   * @param attributeId Attribute that changed
   */
  void emberAfGeneralCommissioningClusterServerAttributeChangedCallback(chip::EndpointId endpoint, chip::AttributeId attributeId);
  
  /** @brief General Commissioning Cluster Server Manufacturer Specific Attribute Changed
   *
   * Server Manufacturer Specific Attribute Changed
   *
   * @param endpoint          Endpoint that is being initialized
   * @param attributeId       Attribute that changed
   * @param manufacturerCode  Manufacturer Code of the attribute that changed
   */
  void emberAfGeneralCommissioningClusterServerManufacturerSpecificAttributeChangedCallback(chip::EndpointId endpoint,
                                                                                            chip::AttributeId attributeId,
                                                                                            uint16_t manufacturerCode);
  
  /** @brief General Commissioning Cluster Server Message Sent
   *
   * Server Message Sent
   *
   * @param type               The type of message sent
   * @param destination        The destination to which the message was sent
   * @param apsFrame           The APS frame for the message
   * @param msgLen             The length of the message
   * @param message            The message that was sent
   * @param status             The status of the sent message
   */
  void emberAfGeneralCommissioningClusterServerMessageSentCallback(EmberOutgoingMessageType type,
                                                                   chip::MessageSendDestination destination, EmberApsFrame * apsFrame,
                                                                   uint16_t msgLen, uint8_t * message, EmberStatus status);
  
  /** @brief General Commissioning Cluster Server Pre Attribute Changed
   *
   * server Pre Attribute Changed
   *
   * @param endpoint      Endpoint that is being initialized
   * @param attributeId   Attribute to be changed
   * @param attributeType Attribute type
   * @param size          Attribute size
   * @param value         Attribute value
   */
  EmberAfStatus emberAfGeneralCommissioningClusterServerPreAttributeChangedCallback(chip::EndpointId endpoint,
                                                                                    chip::AttributeId attributeId,
                                                                                    EmberAfAttributeType attributeType, uint16_t size,
                                                                                    uint8_t * value);
  
  /** @brief General Commissioning Cluster Server Tick
   *
   * server Tick
   *
   * @param endpoint  Endpoint that is being served
   */
  void emberAfGeneralCommissioningClusterServerTickCallback(chip::EndpointId endpoint);
  
  //
  // General Diagnostics Cluster server
  //
  
  /** @brief General Diagnostics Cluster Server Init
   *
   * Server Init
   *
   * @param endpoint    Endpoint that is being initialized
   */
  void emberAfGeneralDiagnosticsClusterServerInitCallback(chip::EndpointId endpoint);
  
  /** @brief General Diagnostics Cluster Server Attribute Changed
   *
   * Server Attribute Changed
   *
   * @param endpoint    Endpoint that is being initialized
   * @param attributeId Attribute that changed
   */
  void emberAfGeneralDiagnosticsClusterServerAttributeChangedCallback(chip::EndpointId endpoint, chip::AttributeId attributeId);
  
  /** @brief General Diagnostics Cluster Server Manufacturer Specific Attribute Changed
   *
   * Server Manufacturer Specific Attribute Changed
   *
   * @param endpoint          Endpoint that is being initialized
   * @param attributeId       Attribute that changed
   * @param manufacturerCode  Manufacturer Code of the attribute that changed
   */
  void emberAfGeneralDiagnosticsClusterServerManufacturerSpecificAttributeChangedCallback(chip::EndpointId endpoint,
                                                                                          chip::AttributeId attributeId,
                                                                                          uint16_t manufacturerCode);
  
  /** @brief General Diagnostics Cluster Server Message Sent
   *
   * Server Message Sent
   *
   * @param type               The type of message sent
   * @param destination        The destination to which the message was sent
   * @param apsFrame           The APS frame for the message
   * @param msgLen             The length of the message
   * @param message            The message that was sent
   * @param status             The status of the sent message
   */
  void emberAfGeneralDiagnosticsClusterServerMessageSentCallback(EmberOutgoingMessageType type,
                                                                 chip::MessageSendDestination destination, EmberApsFrame * apsFrame,
                                                                 uint16_t msgLen, uint8_t * message, EmberStatus status);
  
  /** @brief General Diagnostics Cluster Server Pre Attribute Changed
   *
   * server Pre Attribute Changed
   *
   * @param endpoint      Endpoint that is being initialized
   * @param attributeId   Attribute to be changed
   * @param attributeType Attribute type
   * @param size          Attribute size
   * @param value         Attribute value
   */
  EmberAfStatus emberAfGeneralDiagnosticsClusterServerPreAttributeChangedCallback(chip::EndpointId endpoint,
                                                                                  chip::AttributeId attributeId,
                                                                                  EmberAfAttributeType attributeType, uint16_t size,
                                                                                  uint8_t * value);
  
  /** @brief General Diagnostics Cluster Server Tick
   *
   * server Tick
   *
   * @param endpoint  Endpoint that is being served
   */
  void emberAfGeneralDiagnosticsClusterServerTickCallback(chip::EndpointId endpoint);
  
  //
  // Keypad Input Cluster server
  //
  
  /** @brief Keypad Input Cluster Server Init
   *
   * Server Init
   *
   * @param endpoint    Endpoint that is being initialized
   */
  void emberAfKeypadInputClusterServerInitCallback(chip::EndpointId endpoint);
  
  /** @brief Keypad Input Cluster Server Attribute Changed
   *
   * Server Attribute Changed
   *
   * @param endpoint    Endpoint that is being initialized
   * @param attributeId Attribute that changed
   */
  void emberAfKeypadInputClusterServerAttributeChangedCallback(chip::EndpointId endpoint, chip::AttributeId attributeId);
  
  /** @brief Keypad Input Cluster Server Manufacturer Specific Attribute Changed
   *
   * Server Manufacturer Specific Attribute Changed
   *
   * @param endpoint          Endpoint that is being initialized
   * @param attributeId       Attribute that changed
   * @param manufacturerCode  Manufacturer Code of the attribute that changed
   */
  void emberAfKeypadInputClusterServerManufacturerSpecificAttributeChangedCallback(chip::EndpointId endpoint,
                                                                                   chip::AttributeId attributeId,
                                                                                   uint16_t manufacturerCode);
  
  /** @brief Keypad Input Cluster Server Message Sent
   *
   * Server Message Sent
   *
   * @param type               The type of message sent
   * @param destination        The destination to which the message was sent
   * @param apsFrame           The APS frame for the message
   * @param msgLen             The length of the message
   * @param message            The message that was sent
   * @param status             The status of the sent message
   */
  void emberAfKeypadInputClusterServerMessageSentCallback(EmberOutgoingMessageType type, chip::MessageSendDestination destination,
                                                          EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message,
                                                          EmberStatus status);
  
  /** @brief Keypad Input Cluster Server Pre Attribute Changed
   *
   * server Pre Attribute Changed
   *
   * @param endpoint      Endpoint that is being initialized
   * @param attributeId   Attribute to be changed
   * @param attributeType Attribute type
   * @param size          Attribute size
   * @param value         Attribute value
   */
  EmberAfStatus emberAfKeypadInputClusterServerPreAttributeChangedCallback(chip::EndpointId endpoint, chip::AttributeId attributeId,
                                                                           EmberAfAttributeType attributeType, uint16_t size,
                                                                           uint8_t * value);
  
  /** @brief Keypad Input Cluster Server Tick
   *
   * server Tick
   *
   * @param endpoint  Endpoint that is being served
   */
  void emberAfKeypadInputClusterServerTickCallback(chip::EndpointId endpoint);
  
  //
  // Level Control Cluster server
  //
  
  /** @brief Level Control Cluster Server Init
   *
   * Server Init
   *
   * @param endpoint    Endpoint that is being initialized
   */
  void emberAfLevelControlClusterServerInitCallback(chip::EndpointId endpoint);
  
  /** @brief Level Control Cluster Server Attribute Changed
   *
   * Server Attribute Changed
   *
   * @param endpoint    Endpoint that is being initialized
   * @param attributeId Attribute that changed
   */
  void emberAfLevelControlClusterServerAttributeChangedCallback(chip::EndpointId endpoint, chip::AttributeId attributeId);
  
  /** @brief Level Control Cluster Server Manufacturer Specific Attribute Changed
   *
   * Server Manufacturer Specific Attribute Changed
   *
   * @param endpoint          Endpoint that is being initialized
   * @param attributeId       Attribute that changed
   * @param manufacturerCode  Manufacturer Code of the attribute that changed
   */
  void emberAfLevelControlClusterServerManufacturerSpecificAttributeChangedCallback(chip::EndpointId endpoint,
                                                                                    chip::AttributeId attributeId,
                                                                                    uint16_t manufacturerCode);
  
  /** @brief Level Control Cluster Server Message Sent
   *
   * Server Message Sent
   *
   * @param type               The type of message sent
   * @param destination        The destination to which the message was sent
   * @param apsFrame           The APS frame for the message
   * @param msgLen             The length of the message
   * @param message            The message that was sent
   * @param status             The status of the sent message
   */
  void emberAfLevelControlClusterServerMessageSentCallback(EmberOutgoingMessageType type, chip::MessageSendDestination destination,
                                                           EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message,
                                                           EmberStatus status);
  
  /** @brief Level Control Cluster Server Pre Attribute Changed
   *
   * server Pre Attribute Changed
   *
   * @param endpoint      Endpoint that is being initialized
   * @param attributeId   Attribute to be changed
   * @param attributeType Attribute type
   * @param size          Attribute size
   * @param value         Attribute value
   */
  EmberAfStatus emberAfLevelControlClusterServerPreAttributeChangedCallback(chip::EndpointId endpoint, chip::AttributeId attributeId,
                                                                            EmberAfAttributeType attributeType, uint16_t size,
                                                                            uint8_t * value);
  
  /** @brief Level Control Cluster Server Tick
   *
   * server Tick
   *
   * @param endpoint  Endpoint that is being served
   */
  void emberAfLevelControlClusterServerTickCallback(chip::EndpointId endpoint);
  
  //
  // Low Power Cluster server
  //
  
  /** @brief Low Power Cluster Server Init
   *
   * Server Init
   *
   * @param endpoint    Endpoint that is being initialized
   */
  void emberAfLowPowerClusterServerInitCallback(chip::EndpointId endpoint);
  
  /** @brief Low Power Cluster Server Attribute Changed
   *
   * Server Attribute Changed
   *
   * @param endpoint    Endpoint that is being initialized
   * @param attributeId Attribute that changed
   */
  void emberAfLowPowerClusterServerAttributeChangedCallback(chip::EndpointId endpoint, chip::AttributeId attributeId);
  
  /** @brief Low Power Cluster Server Manufacturer Specific Attribute Changed
   *
   * Server Manufacturer Specific Attribute Changed
   *
   * @param endpoint          Endpoint that is being initialized
   * @param attributeId       Attribute that changed
   * @param manufacturerCode  Manufacturer Code of the attribute that changed
   */
  void emberAfLowPowerClusterServerManufacturerSpecificAttributeChangedCallback(chip::EndpointId endpoint,
                                                                                chip::AttributeId attributeId,
                                                                                uint16_t manufacturerCode);
  
  /** @brief Low Power Cluster Server Message Sent
   *
   * Server Message Sent
   *
   * @param type               The type of message sent
   * @param destination        The destination to which the message was sent
   * @param apsFrame           The APS frame for the message
   * @param msgLen             The length of the message
   * @param message            The message that was sent
   * @param status             The status of the sent message
   */
  void emberAfLowPowerClusterServerMessageSentCallback(EmberOutgoingMessageType type, chip::MessageSendDestination destination,
                                                       EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message,
                                                       EmberStatus status);
  
  /** @brief Low Power Cluster Server Pre Attribute Changed
   *
   * server Pre Attribute Changed
   *
   * @param endpoint      Endpoint that is being initialized
   * @param attributeId   Attribute to be changed
   * @param attributeType Attribute type
   * @param size          Attribute size
   * @param value         Attribute value
   */
  EmberAfStatus emberAfLowPowerClusterServerPreAttributeChangedCallback(chip::EndpointId endpoint, chip::AttributeId attributeId,
                                                                        EmberAfAttributeType attributeType, uint16_t size,
                                                                        uint8_t * value);
  
  /** @brief Low Power Cluster Server Tick
   *
   * server Tick
   *
   * @param endpoint  Endpoint that is being served
   */
  void emberAfLowPowerClusterServerTickCallback(chip::EndpointId endpoint);
  
  //
  // Media Input Cluster server
  //
  
  /** @brief Media Input Cluster Server Init
   *
   * Server Init
   *
   * @param endpoint    Endpoint that is being initialized
   */
  void emberAfMediaInputClusterServerInitCallback(chip::EndpointId endpoint);
  
  /** @brief Media Input Cluster Server Attribute Changed
   *
   * Server Attribute Changed
   *
   * @param endpoint    Endpoint that is being initialized
   * @param attributeId Attribute that changed
   */
  void emberAfMediaInputClusterServerAttributeChangedCallback(chip::EndpointId endpoint, chip::AttributeId attributeId);
  
  /** @brief Media Input Cluster Server Manufacturer Specific Attribute Changed
   *
   * Server Manufacturer Specific Attribute Changed
   *
   * @param endpoint          Endpoint that is being initialized
   * @param attributeId       Attribute that changed
   * @param manufacturerCode  Manufacturer Code of the attribute that changed
   */
  void emberAfMediaInputClusterServerManufacturerSpecificAttributeChangedCallback(chip::EndpointId endpoint,
                                                                                  chip::AttributeId attributeId,
                                                                                  uint16_t manufacturerCode);
  
  /** @brief Media Input Cluster Server Message Sent
   *
   * Server Message Sent
   *
   * @param type               The type of message sent
   * @param destination        The destination to which the message was sent
   * @param apsFrame           The APS frame for the message
   * @param msgLen             The length of the message
   * @param message            The message that was sent
   * @param status             The status of the sent message
   */
  void emberAfMediaInputClusterServerMessageSentCallback(EmberOutgoingMessageType type, chip::MessageSendDestination destination,
                                                         EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message,
                                                         EmberStatus status);
  
  /** @brief Media Input Cluster Server Pre Attribute Changed
   *
   * server Pre Attribute Changed
   *
   * @param endpoint      Endpoint that is being initialized
   * @param attributeId   Attribute to be changed
   * @param attributeType Attribute type
   * @param size          Attribute size
   * @param value         Attribute value
   */
  EmberAfStatus emberAfMediaInputClusterServerPreAttributeChangedCallback(chip::EndpointId endpoint, chip::AttributeId attributeId,
                                                                          EmberAfAttributeType attributeType, uint16_t size,
                                                                          uint8_t * value);
  
  /** @brief Media Input Cluster Server Tick
   *
   * server Tick
   *
   * @param endpoint  Endpoint that is being served
   */
  void emberAfMediaInputClusterServerTickCallback(chip::EndpointId endpoint);
  
  //
  // Media Playback Cluster server
  //
  
  /** @brief Media Playback Cluster Server Init
   *
   * Server Init
   *
   * @param endpoint    Endpoint that is being initialized
   */
  void emberAfMediaPlaybackClusterServerInitCallback(chip::EndpointId endpoint);
  
  /** @brief Media Playback Cluster Server Attribute Changed
   *
   * Server Attribute Changed
   *
   * @param endpoint    Endpoint that is being initialized
   * @param attributeId Attribute that changed
   */
  void emberAfMediaPlaybackClusterServerAttributeChangedCallback(chip::EndpointId endpoint, chip::AttributeId attributeId);
  
  /** @brief Media Playback Cluster Server Manufacturer Specific Attribute Changed
   *
   * Server Manufacturer Specific Attribute Changed
   *
   * @param endpoint          Endpoint that is being initialized
   * @param attributeId       Attribute that changed
   * @param manufacturerCode  Manufacturer Code of the attribute that changed
   */
  void emberAfMediaPlaybackClusterServerManufacturerSpecificAttributeChangedCallback(chip::EndpointId endpoint,
                                                                                     chip::AttributeId attributeId,
                                                                                     uint16_t manufacturerCode);
  
  /** @brief Media Playback Cluster Server Message Sent
   *
   * Server Message Sent
   *
   * @param type               The type of message sent
   * @param destination        The destination to which the message was sent
   * @param apsFrame           The APS frame for the message
   * @param msgLen             The length of the message
   * @param message            The message that was sent
   * @param status             The status of the sent message
   */
  void emberAfMediaPlaybackClusterServerMessageSentCallback(EmberOutgoingMessageType type, chip::MessageSendDestination destination,
                                                            EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message,
                                                            EmberStatus status);
  
  /** @brief Media Playback Cluster Server Pre Attribute Changed
   *
   * server Pre Attribute Changed
   *
   * @param endpoint      Endpoint that is being initialized
   * @param attributeId   Attribute to be changed
   * @param attributeType Attribute type
   * @param size          Attribute size
   * @param value         Attribute value
   */
  EmberAfStatus emberAfMediaPlaybackClusterServerPreAttributeChangedCallback(chip::EndpointId endpoint, chip::AttributeId attributeId,
                                                                             EmberAfAttributeType attributeType, uint16_t size,
                                                                             uint8_t * value);
  
  /** @brief Media Playback Cluster Server Tick
   *
   * server Tick
   *
   * @param endpoint  Endpoint that is being served
   */
  void emberAfMediaPlaybackClusterServerTickCallback(chip::EndpointId endpoint);
  
  //
  // On/off Cluster server
  //
  
  /** @brief On/off Cluster Server Init
   *
   * Server Init
   *
   * @param endpoint    Endpoint that is being initialized
   */
  void emberAfOnOffClusterServerInitCallback(chip::EndpointId endpoint);
  
  /** @brief On/off Cluster Server Attribute Changed
   *
   * Server Attribute Changed
   *
   * @param endpoint    Endpoint that is being initialized
   * @param attributeId Attribute that changed
   */
  void emberAfOnOffClusterServerAttributeChangedCallback(chip::EndpointId endpoint, chip::AttributeId attributeId);
  
  /** @brief On/off Cluster Server Manufacturer Specific Attribute Changed
   *
   * Server Manufacturer Specific Attribute Changed
   *
   * @param endpoint          Endpoint that is being initialized
   * @param attributeId       Attribute that changed
   * @param manufacturerCode  Manufacturer Code of the attribute that changed
   */
  void emberAfOnOffClusterServerManufacturerSpecificAttributeChangedCallback(chip::EndpointId endpoint, chip::AttributeId attributeId,
                                                                             uint16_t manufacturerCode);
  
  /** @brief On/off Cluster Server Message Sent
   *
   * Server Message Sent
   *
   * @param type               The type of message sent
   * @param destination        The destination to which the message was sent
   * @param apsFrame           The APS frame for the message
   * @param msgLen             The length of the message
   * @param message            The message that was sent
   * @param status             The status of the sent message
   */
  void emberAfOnOffClusterServerMessageSentCallback(EmberOutgoingMessageType type, chip::MessageSendDestination destination,
                                                    EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message, EmberStatus status);
  
  /** @brief On/off Cluster Server Pre Attribute Changed
   *
   * server Pre Attribute Changed
   *
   * @param endpoint      Endpoint that is being initialized
   * @param attributeId   Attribute to be changed
   * @param attributeType Attribute type
   * @param size          Attribute size
   * @param value         Attribute value
   */
  EmberAfStatus emberAfOnOffClusterServerPreAttributeChangedCallback(chip::EndpointId endpoint, chip::AttributeId attributeId,
                                                                     EmberAfAttributeType attributeType, uint16_t size,
                                                                     uint8_t * value);
  
  /** @brief On/off Cluster Server Tick
   *
   * server Tick
   *
   * @param endpoint  Endpoint that is being served
   */
  void emberAfOnOffClusterServerTickCallback(chip::EndpointId endpoint);
  
  //
  // TV Channel Cluster server
  //
  
  /** @brief TV Channel Cluster Server Init
   *
   * Server Init
   *
   * @param endpoint    Endpoint that is being initialized
   */
  void emberAfTvChannelClusterServerInitCallback(chip::EndpointId endpoint);
  
  /** @brief TV Channel Cluster Server Attribute Changed
   *
   * Server Attribute Changed
   *
   * @param endpoint    Endpoint that is being initialized
   * @param attributeId Attribute that changed
   */
  void emberAfTvChannelClusterServerAttributeChangedCallback(chip::EndpointId endpoint, chip::AttributeId attributeId);
  
  /** @brief TV Channel Cluster Server Manufacturer Specific Attribute Changed
   *
   * Server Manufacturer Specific Attribute Changed
   *
   * @param endpoint          Endpoint that is being initialized
   * @param attributeId       Attribute that changed
   * @param manufacturerCode  Manufacturer Code of the attribute that changed
   */
  void emberAfTvChannelClusterServerManufacturerSpecificAttributeChangedCallback(chip::EndpointId endpoint,
                                                                                 chip::AttributeId attributeId,
                                                                                 uint16_t manufacturerCode);
  
  /** @brief TV Channel Cluster Server Message Sent
   *
   * Server Message Sent
   *
   * @param type               The type of message sent
   * @param destination        The destination to which the message was sent
   * @param apsFrame           The APS frame for the message
   * @param msgLen             The length of the message
   * @param message            The message that was sent
   * @param status             The status of the sent message
   */
  void emberAfTvChannelClusterServerMessageSentCallback(EmberOutgoingMessageType type, chip::MessageSendDestination destination,
                                                        EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message,
                                                        EmberStatus status);
  
  /** @brief TV Channel Cluster Server Pre Attribute Changed
   *
   * server Pre Attribute Changed
   *
   * @param endpoint      Endpoint that is being initialized
   * @param attributeId   Attribute to be changed
   * @param attributeType Attribute type
   * @param size          Attribute size
   * @param value         Attribute value
   */
  EmberAfStatus emberAfTvChannelClusterServerPreAttributeChangedCallback(chip::EndpointId endpoint, chip::AttributeId attributeId,
                                                                         EmberAfAttributeType attributeType, uint16_t size,
                                                                         uint8_t * value);
  
  /** @brief TV Channel Cluster Server Tick
   *
   * server Tick
   *
   * @param endpoint  Endpoint that is being served
   */
  void emberAfTvChannelClusterServerTickCallback(chip::EndpointId endpoint);
  
  //
  // Target Navigator Cluster server
  //
  
  /** @brief Target Navigator Cluster Server Init
   *
   * Server Init
   *
   * @param endpoint    Endpoint that is being initialized
   */
  void emberAfTargetNavigatorClusterServerInitCallback(chip::EndpointId endpoint);
  
  /** @brief Target Navigator Cluster Server Attribute Changed
   *
   * Server Attribute Changed
   *
   * @param endpoint    Endpoint that is being initialized
   * @param attributeId Attribute that changed
   */
  void emberAfTargetNavigatorClusterServerAttributeChangedCallback(chip::EndpointId endpoint, chip::AttributeId attributeId);
  
  /** @brief Target Navigator Cluster Server Manufacturer Specific Attribute Changed
   *
   * Server Manufacturer Specific Attribute Changed
   *
   * @param endpoint          Endpoint that is being initialized
   * @param attributeId       Attribute that changed
   * @param manufacturerCode  Manufacturer Code of the attribute that changed
   */
  void emberAfTargetNavigatorClusterServerManufacturerSpecificAttributeChangedCallback(chip::EndpointId endpoint,
                                                                                       chip::AttributeId attributeId,
                                                                                       uint16_t manufacturerCode);
  
  /** @brief Target Navigator Cluster Server Message Sent
   *
   * Server Message Sent
   *
   * @param type               The type of message sent
   * @param destination        The destination to which the message was sent
   * @param apsFrame           The APS frame for the message
   * @param msgLen             The length of the message
   * @param message            The message that was sent
   * @param status             The status of the sent message
   */
  void emberAfTargetNavigatorClusterServerMessageSentCallback(EmberOutgoingMessageType type, chip::MessageSendDestination destination,
                                                              EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message,
                                                              EmberStatus status);
  
  /** @brief Target Navigator Cluster Server Pre Attribute Changed
   *
   * server Pre Attribute Changed
   *
   * @param endpoint      Endpoint that is being initialized
   * @param attributeId   Attribute to be changed
   * @param attributeType Attribute type
   * @param size          Attribute size
   * @param value         Attribute value
   */
  EmberAfStatus emberAfTargetNavigatorClusterServerPreAttributeChangedCallback(chip::EndpointId endpoint,
                                                                               chip::AttributeId attributeId,
                                                                               EmberAfAttributeType attributeType, uint16_t size,
                                                                               uint8_t * value);
  
  /** @brief Target Navigator Cluster Server Tick
   *
   * server Tick
   *
   * @param endpoint  Endpoint that is being served
   */
  void emberAfTargetNavigatorClusterServerTickCallback(chip::EndpointId endpoint);
  
  //
  // Thread Network Diagnostics Cluster server
  //
  
  /** @brief Thread Network Diagnostics Cluster Server Init
   *
   * Server Init
   *
   * @param endpoint    Endpoint that is being initialized
   */
  void emberAfThreadNetworkDiagnosticsClusterServerInitCallback(chip::EndpointId endpoint);
  
  /** @brief Thread Network Diagnostics Cluster Server Attribute Changed
   *
   * Server Attribute Changed
   *
   * @param endpoint    Endpoint that is being initialized
   * @param attributeId Attribute that changed
   */
  void emberAfThreadNetworkDiagnosticsClusterServerAttributeChangedCallback(chip::EndpointId endpoint, chip::AttributeId attributeId);
  
  /** @brief Thread Network Diagnostics Cluster Server Manufacturer Specific Attribute Changed
   *
   * Server Manufacturer Specific Attribute Changed
   *
   * @param endpoint          Endpoint that is being initialized
   * @param attributeId       Attribute that changed
   * @param manufacturerCode  Manufacturer Code of the attribute that changed
   */
  void emberAfThreadNetworkDiagnosticsClusterServerManufacturerSpecificAttributeChangedCallback(chip::EndpointId endpoint,
                                                                                                chip::AttributeId attributeId,
                                                                                                uint16_t manufacturerCode);
  
  /** @brief Thread Network Diagnostics Cluster Server Message Sent
   *
   * Server Message Sent
   *
   * @param type               The type of message sent
   * @param destination        The destination to which the message was sent
   * @param apsFrame           The APS frame for the message
   * @param msgLen             The length of the message
   * @param message            The message that was sent
   * @param status             The status of the sent message
   */
  void emberAfThreadNetworkDiagnosticsClusterServerMessageSentCallback(EmberOutgoingMessageType type,
                                                                       chip::MessageSendDestination destination,
                                                                       EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message,
                                                                       EmberStatus status);
  
  /** @brief Thread Network Diagnostics Cluster Server Pre Attribute Changed
   *
   * server Pre Attribute Changed
   *
   * @param endpoint      Endpoint that is being initialized
   * @param attributeId   Attribute to be changed
   * @param attributeType Attribute type
   * @param size          Attribute size
   * @param value         Attribute value
   */
  EmberAfStatus emberAfThreadNetworkDiagnosticsClusterServerPreAttributeChangedCallback(chip::EndpointId endpoint,
                                                                                        chip::AttributeId attributeId,
                                                                                        EmberAfAttributeType attributeType,
                                                                                        uint16_t size, uint8_t * value);
  
  /** @brief Thread Network Diagnostics Cluster Server Tick
   *
   * server Tick
   *
   * @param endpoint  Endpoint that is being served
   */
  void emberAfThreadNetworkDiagnosticsClusterServerTickCallback(chip::EndpointId endpoint);
  
  //
  // Wake on LAN Cluster server
  //
  
  /** @brief Wake on LAN Cluster Server Init
   *
   * Server Init
   *
   * @param endpoint    Endpoint that is being initialized
   */
  void emberAfWakeOnLanClusterServerInitCallback(chip::EndpointId endpoint);
  
  /** @brief Wake on LAN Cluster Server Attribute Changed
   *
   * Server Attribute Changed
   *
   * @param endpoint    Endpoint that is being initialized
   * @param attributeId Attribute that changed
   */
  void emberAfWakeOnLanClusterServerAttributeChangedCallback(chip::EndpointId endpoint, chip::AttributeId attributeId);
  
  /** @brief Wake on LAN Cluster Server Manufacturer Specific Attribute Changed
   *
   * Server Manufacturer Specific Attribute Changed
   *
   * @param endpoint          Endpoint that is being initialized
   * @param attributeId       Attribute that changed
   * @param manufacturerCode  Manufacturer Code of the attribute that changed
   */
  void emberAfWakeOnLanClusterServerManufacturerSpecificAttributeChangedCallback(chip::EndpointId endpoint,
                                                                                 chip::AttributeId attributeId,
                                                                                 uint16_t manufacturerCode);
  
  /** @brief Wake on LAN Cluster Server Message Sent
   *
   * Server Message Sent
   *
   * @param type               The type of message sent
   * @param destination        The destination to which the message was sent
   * @param apsFrame           The APS frame for the message
   * @param msgLen             The length of the message
   * @param message            The message that was sent
   * @param status             The status of the sent message
   */
  void emberAfWakeOnLanClusterServerMessageSentCallback(EmberOutgoingMessageType type, chip::MessageSendDestination destination,
                                                        EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message,
                                                        EmberStatus status);
  
  /** @brief Wake on LAN Cluster Server Pre Attribute Changed
   *
   * server Pre Attribute Changed
   *
   * @param endpoint      Endpoint that is being initialized
   * @param attributeId   Attribute to be changed
   * @param attributeType Attribute type
   * @param size          Attribute size
   * @param value         Attribute value
   */
  EmberAfStatus emberAfWakeOnLanClusterServerPreAttributeChangedCallback(chip::EndpointId endpoint, chip::AttributeId attributeId,
                                                                         EmberAfAttributeType attributeType, uint16_t size,
                                                                         uint8_t * value);
  
  /** @brief Wake on LAN Cluster Server Tick
   *
   * server Tick
   *
   * @param endpoint  Endpoint that is being served
   */
  void emberAfWakeOnLanClusterServerTickCallback(chip::EndpointId endpoint);
  
  //
  // WiFi Network Diagnostics Cluster server
  //
  
  /** @brief WiFi Network Diagnostics Cluster Server Init
   *
   * Server Init
   *
   * @param endpoint    Endpoint that is being initialized
   */
  void emberAfWiFiNetworkDiagnosticsClusterServerInitCallback(chip::EndpointId endpoint);
  
  /** @brief WiFi Network Diagnostics Cluster Server Attribute Changed
   *
   * Server Attribute Changed
   *
   * @param endpoint    Endpoint that is being initialized
   * @param attributeId Attribute that changed
   */
  void emberAfWiFiNetworkDiagnosticsClusterServerAttributeChangedCallback(chip::EndpointId endpoint, chip::AttributeId attributeId);
  
  /** @brief WiFi Network Diagnostics Cluster Server Manufacturer Specific Attribute Changed
   *
   * Server Manufacturer Specific Attribute Changed
   *
   * @param endpoint          Endpoint that is being initialized
   * @param attributeId       Attribute that changed
   * @param manufacturerCode  Manufacturer Code of the attribute that changed
   */
  void emberAfWiFiNetworkDiagnosticsClusterServerManufacturerSpecificAttributeChangedCallback(chip::EndpointId endpoint,
                                                                                              chip::AttributeId attributeId,
                                                                                              uint16_t manufacturerCode);
  
  /** @brief WiFi Network Diagnostics Cluster Server Message Sent
   *
   * Server Message Sent
   *
   * @param type               The type of message sent
   * @param destination        The destination to which the message was sent
   * @param apsFrame           The APS frame for the message
   * @param msgLen             The length of the message
   * @param message            The message that was sent
   * @param status             The status of the sent message
   */
  void emberAfWiFiNetworkDiagnosticsClusterServerMessageSentCallback(EmberOutgoingMessageType type,
                                                                     chip::MessageSendDestination destination,
                                                                     EmberApsFrame * apsFrame, uint16_t msgLen, uint8_t * message,
                                                                     EmberStatus status);
  
  /** @brief WiFi Network Diagnostics Cluster Server Pre Attribute Changed
   *
   * server Pre Attribute Changed
   *
   * @param endpoint      Endpoint that is being initialized
   * @param attributeId   Attribute to be changed
   * @param attributeType Attribute type
   * @param size          Attribute size
   * @param value         Attribute value
   */
  EmberAfStatus emberAfWiFiNetworkDiagnosticsClusterServerPreAttributeChangedCallback(chip::EndpointId endpoint,
                                                                                      chip::AttributeId attributeId,
                                                                                      EmberAfAttributeType attributeType,
                                                                                      uint16_t size, uint8_t * value);
  
  /** @brief WiFi Network Diagnostics Cluster Server Tick
   *
   * server Tick
   *
   * @param endpoint  Endpoint that is being served
   */
  void emberAfWiFiNetworkDiagnosticsClusterServerTickCallback(chip::EndpointId endpoint);
  
  // Cluster Commands Callback
  
  /**
   * @brief Account Login Cluster GetSetupPIN Command callback
   */
  
  bool emberAfAccountLoginClusterGetSetupPINCallback(chip::app::Command * commandObj, uint8_t * tempAccountIdentifier);
  
  /**
   * @brief Account Login Cluster Login Command callback
   */
  
  bool emberAfAccountLoginClusterLoginCallback(chip::app::Command * commandObj, uint8_t * tempAccountIdentifier, uint8_t * setupPIN);
  
  /**
   * @brief Application Launcher Cluster LaunchApp Command callback
   */
  
  bool emberAfApplicationLauncherClusterLaunchAppCallback(chip::app::Command * commandObj, uint8_t * data,
                                                          /* TYPE WARNING: array array defaults to */ uint8_t * application);
  
  /**
   * @brief Audio Output Cluster RenameOutput Command callback
   */
  
  bool emberAfAudioOutputClusterRenameOutputCallback(chip::app::Command * commandObj, uint8_t index, uint8_t * name);
  
  /**
   * @brief Audio Output Cluster SelectOutput Command callback
   */
  
  bool emberAfAudioOutputClusterSelectOutputCallback(chip::app::Command * commandObj, uint8_t index);
  
  /**
   * @brief Content Launch Cluster LaunchContent Command callback
   */
  
  bool emberAfContentLaunchClusterLaunchContentCallback(chip::app::Command * commandObj, uint8_t autoPlay, uint8_t * data);
  
  /**
   * @brief Content Launch Cluster LaunchURL Command callback
   */
  
  bool emberAfContentLaunchClusterLaunchURLCallback(chip::app::Command * commandObj, uint8_t * contentURL, uint8_t * displayString);
  
  /**
   * @brief General Commissioning Cluster ArmFailSafe Command callback
   */
  
  bool emberAfGeneralCommissioningClusterArmFailSafeCallback(chip::app::Command * commandObj, uint16_t expiryLengthSeconds,
                                                             uint64_t breadcrumb, uint32_t timeoutMs);
  
  /**
   * @brief General Commissioning Cluster CommissioningComplete Command callback
   */
  
  bool emberAfGeneralCommissioningClusterCommissioningCompleteCallback(chip::app::Command * commandObj);
  
  /**
   * @brief General Commissioning Cluster SetRegulatoryConfig Command callback
   */
  
  bool emberAfGeneralCommissioningClusterSetRegulatoryConfigCallback(chip::app::Command * commandObj, uint8_t location,
                                                                     uint8_t * countryCode, uint64_t breadcrumb, uint32_t timeoutMs);
  
  /**
   * @brief Keypad Input Cluster SendKey Command callback
   */
  
  bool emberAfKeypadInputClusterSendKeyCallback(chip::app::Command * commandObj, uint8_t keyCode);
  
  /**
   * @brief Level Control Cluster Move Command callback
   */
  
  bool emberAfLevelControlClusterMoveCallback(chip::app::Command * commandObj, uint8_t moveMode, uint8_t rate, uint8_t optionMask,
                                              uint8_t optionOverride);
  
  /**
   * @brief Level Control Cluster MoveToLevel Command callback
   */
  
  bool emberAfLevelControlClusterMoveToLevelCallback(chip::app::Command * commandObj, uint8_t level, uint16_t transitionTime,
                                                     uint8_t optionMask, uint8_t optionOverride);
  
  /**
   * @brief Level Control Cluster MoveToLevelWithOnOff Command callback
   */
  
  bool emberAfLevelControlClusterMoveToLevelWithOnOffCallback(chip::app::Command * commandObj, uint8_t level,
                                                              uint16_t transitionTime);
  
  /**
   * @brief Level Control Cluster MoveWithOnOff Command callback
   */
  
  bool emberAfLevelControlClusterMoveWithOnOffCallback(chip::app::Command * commandObj, uint8_t moveMode, uint8_t rate);
  
  /**
   * @brief Level Control Cluster Step Command callback
   */
  
  bool emberAfLevelControlClusterStepCallback(chip::app::Command * commandObj, uint8_t stepMode, uint8_t stepSize,
                                              uint16_t transitionTime, uint8_t optionMask, uint8_t optionOverride);
  
  /**
   * @brief Level Control Cluster StepWithOnOff Command callback
   */
  
  bool emberAfLevelControlClusterStepWithOnOffCallback(chip::app::Command * commandObj, uint8_t stepMode, uint8_t stepSize,
                                                       uint16_t transitionTime);
  
  /**
   * @brief Level Control Cluster Stop Command callback
   */
  
  bool emberAfLevelControlClusterStopCallback(chip::app::Command * commandObj, uint8_t optionMask, uint8_t optionOverride);
  
  /**
   * @brief Level Control Cluster StopWithOnOff Command callback
   */
  
  bool emberAfLevelControlClusterStopWithOnOffCallback(chip::app::Command * commandObj);
  
  /**
   * @brief Low Power Cluster Sleep Command callback
   */
  
  bool emberAfLowPowerClusterSleepCallback(chip::app::Command * commandObj);
  
  /**
   * @brief Media Input Cluster HideInputStatus Command callback
   */
  
  bool emberAfMediaInputClusterHideInputStatusCallback(chip::app::Command * commandObj);
  
  /**
   * @brief Media Input Cluster RenameInput Command callback
   */
  
  bool emberAfMediaInputClusterRenameInputCallback(chip::app::Command * commandObj, uint8_t index, uint8_t * name);
  
  /**
   * @brief Media Input Cluster SelectInput Command callback
   */
  
  bool emberAfMediaInputClusterSelectInputCallback(chip::app::Command * commandObj, uint8_t index);
  
  /**
   * @brief Media Input Cluster ShowInputStatus Command callback
   */
  
  bool emberAfMediaInputClusterShowInputStatusCallback(chip::app::Command * commandObj);
  
  /**
   * @brief Media Playback Cluster MediaFastForward Command callback
   */
  
  bool emberAfMediaPlaybackClusterMediaFastForwardCallback(chip::app::Command * commandObj);
  
  /**
   * @brief Media Playback Cluster MediaNext Command callback
   */
  
  bool emberAfMediaPlaybackClusterMediaNextCallback(chip::app::Command * commandObj);
  
  /**
   * @brief Media Playback Cluster MediaPause Command callback
   */
  
  bool emberAfMediaPlaybackClusterMediaPauseCallback(chip::app::Command * commandObj);
  
  /**
   * @brief Media Playback Cluster MediaPlay Command callback
   */
  
  bool emberAfMediaPlaybackClusterMediaPlayCallback(chip::app::Command * commandObj);
  
  /**
   * @brief Media Playback Cluster MediaPrevious Command callback
   */
  
  bool emberAfMediaPlaybackClusterMediaPreviousCallback(chip::app::Command * commandObj);
  
  /**
   * @brief Media Playback Cluster MediaRewind Command callback
   */
  
  bool emberAfMediaPlaybackClusterMediaRewindCallback(chip::app::Command * commandObj);
  
  /**
   * @brief Media Playback Cluster MediaSkipBackward Command callback
   */
  
  bool emberAfMediaPlaybackClusterMediaSkipBackwardCallback(chip::app::Command * commandObj, uint64_t deltaPositionMilliseconds);
  
  /**
   * @brief Media Playback Cluster MediaSkipForward Command callback
   */
  
  bool emberAfMediaPlaybackClusterMediaSkipForwardCallback(chip::app::Command * commandObj, uint64_t deltaPositionMilliseconds);
  
  /**
   * @brief Media Playback Cluster MediaSkipSeek Command callback
   */
  
  bool emberAfMediaPlaybackClusterMediaSkipSeekCallback(chip::app::Command * commandObj, uint64_t position);
  
  /**
   * @brief Media Playback Cluster MediaStartOver Command callback
   */
  
  bool emberAfMediaPlaybackClusterMediaStartOverCallback(chip::app::Command * commandObj);
  
  /**
   * @brief Media Playback Cluster MediaStop Command callback
   */
  
  bool emberAfMediaPlaybackClusterMediaStopCallback(chip::app::Command * commandObj);
  
  /**
   * @brief On/off Cluster Off Command callback
   */
  
  bool emberAfOnOffClusterOffCallback(chip::app::Command * commandObj);
  
  /**
   * @brief On/off Cluster On Command callback
   */
  
  bool emberAfOnOffClusterOnCallback(chip::app::Command * commandObj);
  
  /**
   * @brief On/off Cluster Toggle Command callback
   */
  
  bool emberAfOnOffClusterToggleCallback(chip::app::Command * commandObj);
  
  /**
   * @brief TV Channel Cluster ChangeChannel Command callback
   */
  
  bool emberAfTvChannelClusterChangeChannelCallback(chip::app::Command * commandObj, uint8_t * match);
  
  /**
   * @brief TV Channel Cluster ChangeChannelByNumber Command callback
   */
  
  bool emberAfTvChannelClusterChangeChannelByNumberCallback(chip::app::Command * commandObj, uint16_t majorNumber,
                                                            uint16_t minorNumber);
  
  /**
   * @brief TV Channel Cluster SkipChannel Command callback
   */
  
  bool emberAfTvChannelClusterSkipChannelCallback(chip::app::Command * commandObj, uint16_t Count);
  
  /**
   * @brief Target Navigator Cluster NavigateTarget Command callback
   */
  
  bool emberAfTargetNavigatorClusterNavigateTargetCallback(chip::app::Command * commandObj, uint8_t target, uint8_t * data);
  
  //
  // Non-Cluster Related Callbacks
  //
  
  /** @brief Add To Current App Tasks
   *
   * This function is only useful to sleepy end devices.  This function will note
   * the passed item as part of a set of tasks the application has outstanding
   * (e.g. message sent requiring APS acknwoledgement).  This will affect how the
   * application behaves with regard to sleeping and polling.  Until the
   * outstanding task is completed, the device may poll more frequently and sleep
   * less often.
   *
   * @param tasks   Ver.: always
   */
  void emberAfAddToCurrentAppTasksCallback(EmberAfApplicationTask tasks);
  
  /** @brief Remove From Current App Tasks
   *
   * This function is only useful to sleepy end devices.  This function will
   * remove the passed item from the set of tasks the application has outstanding
   * (e.g. message sent requiring APS acknwoledgement).  This will affect how the
   * application behaves with regard to sleeping and polling.  Removing the item
   * from the list of outstanding tasks may allow the device to sleep longer and
   * poll less frequently.  If there are other outstanding tasks the system may
   * still have to stay away and poll more often.
   *
   * @param tasks   Ver.: always
   */
  void emberAfRemoveFromCurrentAppTasksCallback(EmberAfApplicationTask tasks);
  
  /** @brief Allow Network Write Attribute
   *
   * This function is called by the application framework before it writes an
   * attribute in response to a write attribute request from an external device.
   * The value passed into this callback is the value to which the attribute is to
   * be set by the framework.
          Example:	In mirroring simple metering data
   * on an Energy Services Interface (ESI) (formerly called Energy Service Portal
   * (ESP) in SE 1.0).), a mirrored simple meter needs to write read-only
   * attributes on its mirror. The-meter-mirror sample application, located in
   * app/framework/sample-apps, uses this callback to allow the mirrored device to
   * write simple metering attributes on the mirror regardless of the fact that
   * most simple metering attributes are defined as read-only by the ZigBee
   * specification.
          Note:	The ZCL specification does not (as of this
   * writing) specify any permission-level security for writing writeable
   * attributes. As far as the ZCL specification is concerned, if an attribute is
   * writeable, any device that has a link key for the device should be able to
   * write that attribute. Furthermore if an attribute is read only, it should not
   * be written over the air. Thus, if you implement permissions for writing
   * attributes as a feature, you MAY be operating outside the specification. This
   * is unlikely to be a problem for writing read-only attributes, but it may be a
   * problem for attributes that are writeable according to the specification but
   * restricted by the application implementing this callback.
   *
   * @param endpoint   Ver.: always
   * @param clusterId   Ver.: always
   * @param attributeId   Ver.: always
   * @param mask   Ver.: always
   * @param manufacturerCode   Ver.: always
   * @param value   Ver.: always
   * @param type   Ver.: always
   */
  EmberAfAttributeWritePermission emberAfAllowNetworkWriteAttributeCallback(chip::EndpointId endpoint, chip::ClusterId clusterId,
                                                                            chip::AttributeId attributeId, uint8_t mask,
                                                                            uint16_t manufacturerCode, uint8_t * value, uint8_t type);
  
  /** @brief Attribute Read Access
   *
   * This function is called whenever the Application Framework needs to check
   * access permission for an attribute read.
   *
   * @param endpoint   Ver.: always
   * @param clusterId   Ver.: always
   * @param manufacturerCode   Ver.: always
   * @param attributeId   Ver.: always
   */
  bool emberAfAttributeReadAccessCallback(chip::EndpointId endpoint, chip::ClusterId clusterId, uint16_t manufacturerCode,
                                          chip::AttributeId attributeId);
  
  /** @brief Attribute Write Access
   *
   * This function is called whenever the Application Framework needs to check
   * access permission for an attribute write.
   *
   * @param endpoint   Ver.: always
   * @param clusterId   Ver.: always
   * @param manufacturerCode   Ver.: always
   * @param attributeId   Ver.: always
   */
  bool emberAfAttributeWriteAccessCallback(chip::EndpointId endpoint, chip::ClusterId clusterId, uint16_t manufacturerCode,
                                           chip::AttributeId attributeId);
  
  /** @brief Default Response
   *
   * This function is called by the application framework when a Default Response
   * command is received from an external device.  The application should return
   * true if the message was processed or false if it was not.
   *
   * @param clusterId The cluster identifier of this response.  Ver.: always
   * @param commandId The command identifier to which this is a response.  Ver.:
   * always
   * @param status Specifies either SUCCESS or the nature of the error that was
   * detected in the received command.  Ver.: always
   */
  bool emberAfDefaultResponseCallback(chip::ClusterId clusterId, chip::CommandId commandId, EmberAfStatus status);
  
  /** @brief Configure Reporting Response
   *
   * This function is called by the application framework when a Configure
   * Reporting Response command is received from an external device.  The
   * application should return true if the message was processed or false if it
   * was not.
   *
   * @param clusterId The cluster identifier of this response.  Ver.: always
   * @param buffer Buffer containing the list of attribute status records.  Ver.:
   * always
   * @param bufLen The length in bytes of the list.  Ver.: always
   */
  bool emberAfConfigureReportingResponseCallback(chip::ClusterId clusterId, uint8_t * buffer, uint16_t bufLen);
  
  /** @brief Read Reporting Configuration Response
   *
   * This function is called by the application framework when a Read Reporting
   * Configuration Response command is received from an external device.  The
   * application should return true if the message was processed or false if it
   * was not.
   *
   * @param clusterId The cluster identifier of this response.  Ver.: always
   * @param buffer Buffer containing the list of attribute reporting configuration
   * records.  Ver.: always
   * @param bufLen The length in bytes of the list.  Ver.: always
   */
  bool emberAfReadReportingConfigurationResponseCallback(chip::ClusterId clusterId, uint8_t * buffer, uint16_t bufLen);
  
  /** @brief Discover Attributes Response
   *
   * This function is called by the application framework when a Discover
   * Attributes Response or Discover Attributes Extended Response command is
   * received from an external device.  The Discover Attributes Response command
   * contains a bool indicating if discovery is complete and a list of zero or
   * more attribute identifier/type records. The final argument indicates whether
   * the response is in the extended format or not.  The application should return
   * true if the message was processed or false if it was not.
   *
   * @param clusterId The cluster identifier of this response.  Ver.: always
   * @param discoveryComplete Indicates whether there are more attributes to be
   * discovered.  true if there are no more attributes to be discovered.  Ver.:
   * always
   * @param buffer Buffer containing the list of attribute identifier/type
   * records.  Ver.: always
   * @param bufLen The length in bytes of the list.  Ver.: always
   * @param extended Indicates whether the response is in the extended format or
   * not.  Ver.: always
   */
  bool emberAfDiscoverAttributesResponseCallback(chip::ClusterId clusterId, bool discoveryComplete, uint8_t * buffer, uint16_t bufLen,
                                                 bool extended);
  
  /** @brief Discover Commands Generated Response
   *
   * This function is called by the framework when Discover Commands Generated
   * Response is received.
   *
   * @param clusterId The cluster identifier of this response.  Ver.: always
   * @param manufacturerCode Manufacturer code  Ver.: always
   * @param discoveryComplete Indicates whether there are more commands to be
   * discovered.  Ver.: always
   * @param commandIds Buffer containing the list of command identifiers.  Ver.:
   * always
   * @param commandIdCount The length of bytes of the list, whish is the same as
   * the number of identifiers.  Ver.: always
   */
  bool emberAfDiscoverCommandsGeneratedResponseCallback(chip::ClusterId clusterId, uint16_t manufacturerCode, bool discoveryComplete,
                                                        chip::CommandId * commandIds, uint16_t commandIdCount);
  
  /** @brief Discover Commands Received Response
   *
   * This function is called by the framework when Discover Commands Received
   * Response is received.
   *
   * @param clusterId The cluster identifier of this response.  Ver.: always
   * @param manufacturerCode Manufacturer code  Ver.: always
   * @param discoveryComplete Indicates whether there are more commands to be
   * discovered.  Ver.: always
   * @param commandIds Buffer containing the list of command identifiers.  Ver.:
   * always
   * @param commandIdCount The length of bytes of the list, whish is the same as
   * the number of identifiers.  Ver.: always
   */
  bool emberAfDiscoverCommandsReceivedResponseCallback(chip::ClusterId clusterId, uint16_t manufacturerCode, bool discoveryComplete,
                                                       chip::CommandId * commandIds, uint16_t commandIdCount);
  
  /** @brief Pre Command Received
   *
   * This callback is the second in the Application Framework's message processing
   * chain. At this point in the processing of incoming over-the-air messages, the
   * application has determined that the incoming message is a ZCL command. It
   * parses enough of the message to populate an EmberAfClusterCommand struct. The
   * Application Framework defines this struct value in a local scope to the
   * command processing but also makes it available through a global pointer
   * called emberAfCurrentCommand, in app/framework/util/util.c. When command
   * processing is complete, this pointer is cleared.
   *
   * @param cmd   Ver.: always
   */
  bool emberAfPreCommandReceivedCallback(EmberAfClusterCommand * cmd);
  
  /** @brief Pre Message Send
   *
   * This function is called by the framework when it is about to pass a message
   * to the stack primitives for sending.   This message may or may not be ZCL,
   * ZDO, or some other protocol.  This is called prior to
          any ZigBee
   * fragmentation that may be done.  If the function returns true it is assumed
   * the callback has consumed and processed the message.  The callback must also
   * set the EmberStatus status code to be passed back to the caller.  The
   * framework will do no further processing on the message.
          If the
   * function returns false then it is assumed that the callback has not processed
   * the mesasge and the framework will continue to process accordingly.
   *
   * @param messageStruct The structure containing the parameters of the APS
   * message to be sent.  Ver.: always
   * @param status A pointer to the status code value that will be returned to the
   * caller.  Ver.: always
   */
  bool emberAfPreMessageSendCallback(EmberAfMessageStruct * messageStruct, EmberStatus * status);
  
  /** @brief Message Sent
   *
   * This function is called by the application framework from the message sent
   * handler, when it is informed by the stack regarding the message sent status.
   * All of the values passed to the emberMessageSentHandler are passed on to this
   * callback. This provides an opportunity for the application to verify that its
   * message has been sent successfully and take the appropriate action. This
   * callback should return a bool value of true or false. A value of true
   * indicates that the message sent notification has been handled and should not
   * be handled by the application framework.
   *
   * @param type   Ver.: always
   * @param destination   Ver.: always
   * @param apsFrame   Ver.: always
   * @param msgLen   Ver.: always
   * @param message   Ver.: always
   * @param status   Ver.: always
   */
  bool emberAfMessageSentCallback(EmberOutgoingMessageType type, chip::MessageSendDestination destination, EmberApsFrame * apsFrame,
                                  uint16_t msgLen, uint8_t * message, EmberStatus status);
  
  /** @brief Pre Attribute Change
   *
   * This function is called by the application framework before it changes an
   * attribute value.  The value passed into this callback is the value to which
   * the attribute is to be set by the framework.  The application should return
   * ::EMBER_ZCL_STATUS_SUCCESS to permit the change or any other ::EmberAfStatus
   * to reject it.
   *
   * @param endpoint   Ver.: always
   * @param clusterId   Ver.: always
   * @param attributeId   Ver.: always
   * @param mask   Ver.: always
   * @param manufacturerCode   Ver.: always
   * @param type   Ver.: always
   * @param size   Ver.: always
   * @param value   Ver.: always
   */
  EmberAfStatus emberAfPreAttributeChangeCallback(chip::EndpointId endpoint, chip::ClusterId clusterId, chip::AttributeId attributeId,
                                                  uint8_t mask, uint16_t manufacturerCode, uint8_t type, uint16_t size,
                                                  uint8_t * value);
  
  /** @brief Post Attribute Change
   *
   * This function is called by the application framework after it changes an
   * attribute value. The value passed into this callback is the value to which
   * the attribute was set by the framework.
   *
   * @param endpoint   Ver.: always
   * @param clusterId   Ver.: always
   * @param attributeId   Ver.: always
   * @param mask   Ver.: always
   * @param manufacturerCode   Ver.: always
   * @param type   Ver.: always
   * @param size   Ver.: always
   * @param value   Ver.: always
   */
  void emberAfPostAttributeChangeCallback(chip::EndpointId endpoint, chip::ClusterId clusterId, chip::AttributeId attributeId,
                                          uint8_t mask, uint16_t manufacturerCode, uint8_t type, uint16_t size, uint8_t * value);
  
  /** @brief Read Attributes Response
   *
   * This function is called by the application framework when a Read Attributes
   * Response command is received from an external device.  The application should
   * return true if the message was processed or false if it was not.
   *
   * @param clusterId The cluster identifier of this response.  Ver.: always
   * @param buffer Buffer containing the list of read attribute status records.
   * Ver.: always
   * @param bufLen The length in bytes of the list.  Ver.: always
   */
  bool emberAfReadAttributesResponseCallback(chip::ClusterId clusterId, uint8_t * buffer, uint16_t bufLen);
  
  /** @brief External Attribute Read
   *
   * Like emberAfExternalAttributeWriteCallback above, this function is called
   * when the framework needs to read an attribute that is not stored within the
   * Application Framework's data structures.
          All of the important
   * information about the attribute itself is passed as a pointer to an
   * EmberAfAttributeMetadata struct, which is stored within the application and
   * used to manage the attribute. A complete description of the
   * EmberAfAttributeMetadata struct is provided in
   * app/framework/include/af-types.h
          This function assumes that the
   * application is able to read the attribute, write it into the passed buffer,
   * and return immediately. Any attributes that require a state machine for
   * reading and writing are not really candidates for externalization at the
   * present time. The Application Framework does not currently include a state
   * machine for reading or writing attributes that must take place across a
   * series of application ticks. Attributes that cannot be read in a timely
   * manner should be stored within the Application Framework and updated
   * occasionally by the application code from within the
   * emberAfMainTickCallback.
          If the application was successfully able to
   * read the attribute and write it into the passed buffer, it should return a
   * value of EMBER_ZCL_STATUS_SUCCESS. Ensure that the size of the externally
   * managed attribute value is smaller than what the buffer can hold. In the case
   * of a buffer overflow throw an appropriate error such as
   * EMBER_ZCL_STATUS_INSUFFICIENT_SPACE. Any other return value indicates the
   * application was not able to read the attribute.
   *
   * @param endpoint   Ver.: always
   * @param clusterId   Ver.: always
   * @param attributeMetadata   Ver.: always
   * @param manufacturerCode   Ver.: always
   * @param buffer   Ver.: always
   * @param maxReadLength   Ver.: always
   */
  EmberAfStatus emberAfExternalAttributeReadCallback(chip::EndpointId endpoint, chip::ClusterId clusterId,
                                                     EmberAfAttributeMetadata * attributeMetadata, uint16_t manufacturerCode,
                                                     uint8_t * buffer, uint16_t maxReadLength);
  
  /** @brief Write Attributes Response
   *
   * This function is called by the application framework when a Write Attributes
   * Response command is received from an external device.  The application should
   * return true if the message was processed or false if it was not.
   *
   * @param clusterId The cluster identifier of this response.  Ver.: always
   * @param buffer Buffer containing the list of write attribute status records.
   * Ver.: always
   * @param bufLen The length in bytes of the list.  Ver.: always
   */
  bool emberAfWriteAttributesResponseCallback(chip::ClusterId clusterId, uint8_t * buffer, uint16_t bufLen);
  
  /** @brief External Attribute Write
   *
   * This function is called whenever the Application Framework needs to write an
   * attribute which is not stored within the data structures of the Application
   * Framework itself. One of the new features in Version 2 is the ability to
   * store attributes outside the Framework. This is particularly useful for
   * attributes that do not need to be stored because they can be read off the
   * hardware when they are needed, or are stored in some central location used by
   * many modules within the system. In this case, you can indicate that the
   * attribute is stored externally. When the framework needs to write an external
   * attribute, it makes a call to this callback.
          This callback is very
   * useful for host micros which need to store attributes in persistent memory.
   * Because each host micro (used with an Ember NCP) has its own type of
   * persistent memory storage, the Application Framework does not include the
   * ability to mark attributes as stored in flash the way that it does for Ember
   * SoCs like the EM35x. On a host micro, any attributes that need to be stored
   * in persistent memory should be marked as external and accessed through the
   * external read and write callbacks. Any host code associated with the
   * persistent storage should be implemented within this callback.
          All of
   * the important information about the attribute itself is passed as a pointer
   * to an EmberAfAttributeMetadata struct, which is stored within the application
   * and used to manage the attribute. A complete description of the
   * EmberAfAttributeMetadata struct is provided in
   * app/framework/include/af-types.h.
          This function assumes that the
   * application is able to write the attribute and return immediately. Any
   * attributes that require a state machine for reading and writing are not
   * candidates for externalization at the present time. The Application Framework
   * does not currently include a state machine for reading or writing attributes
   * that must take place across a series of application ticks. Attributes that
   * cannot be written immediately should be stored within the Application
   * Framework and updated occasionally by the application code from within the
   * emberAfMainTickCallback.
          If the application was successfully able to
   * write the attribute, it returns a value of EMBER_ZCL_STATUS_SUCCESS. Any
   * other return value indicates the application was not able to write the
   * attribute.
   *
   * @param endpoint   Ver.: always
   * @param clusterId   Ver.: always
   * @param attributeMetadata   Ver.: always
   * @param manufacturerCode   Ver.: always
   * @param buffer   Ver.: always
   */
  EmberAfStatus emberAfExternalAttributeWriteCallback(chip::EndpointId endpoint, chip::ClusterId clusterId,
                                                      EmberAfAttributeMetadata * attributeMetadata, uint16_t manufacturerCode,
                                                      uint8_t * buffer);
  
  /** @brief Report Attributes
   *
   * This function is called by the application framework when a Report Attributes
   * command is received from an external device.  The application should return
   * true if the message was processed or false if it was not.
   *
   * @param clusterId The cluster identifier of this command.  Ver.: always
   * @param buffer Buffer containing the list of attribute report records.  Ver.:
   * always
   * @param bufLen The length in bytes of the list.  Ver.: always
   */
  bool emberAfReportAttributesCallback(chip::ClusterId clusterId, uint8_t * buffer, uint16_t bufLen);
  
  /** @brief Get Current Time
   *
   * This callback is called when device attempts to get current time from the
   * hardware. If this device has means to retrieve exact time, then this method
   * should implement it. If the callback can't provide the exact time it should
   * return 0 to indicate failure. Default action is to return 0, which indicates
   * that device does not have access to real time.
   *
   */
  uint32_t emberAfGetCurrentTimeCallback();
  
  /** @brief Get Endpoint Info
   *
   * This function is a callback to an application implemented endpoint that
   * operates outside the normal application framework.  When the framework wishes
   * to perform operations with that endpoint it uses this callback to retrieve
   * the endpoint's information.  If the endpoint exists and the application can
   * provide data then true shall be returned.  Otherwise the callback must return
   * false.
   *
   * @param endpoint The endpoint to retrieve data for.  Ver.: always
   * @param returnNetworkIndex The index corresponding to the ZigBee network the
   * endpoint belongs to.  If not using a multi-network device, 0 must be
   * returned.  Otherwise on a multi-network device the stack will switch to this
   * network before sending the message.  Ver.: always
   * @param returnEndpointInfo A pointer to a data struct that will be written
   * with information about the endpoint.  Ver.: always
   */
  bool emberAfGetEndpointInfoCallback(chip::EndpointId endpoint, uint8_t * returnNetworkIndex,
                                      EmberAfEndpointInfoStruct * returnEndpointInfo);
  
  /** @brief Registration Abort
   *
   * This callback is called when the device should abort the registration
   * process.
   *
   */
  void emberAfRegistrationAbortCallback();
  
  /** @brief Interpan Send Message
   *
   * This function will send a raw MAC message with interpan frame format using
   * the passed parameters.
   *
   * @param header Interpan header info  Ver.: always
   * @param messageLength The length of the message received or to send  Ver.:
   * always
   * @param message The message data received or to send.  Ver.: always
   */
  EmberStatus emberAfInterpanSendMessageCallback(EmberAfInterpanHeader * header, uint16_t messageLength, uint8_t * message);
  
  /** @brief Start Move
   *
   * This function is called to initiate the process for a device to move (rejoin)
   * to a new parent.
   *
   */
  bool emberAfStartMoveCallback();
  