/*
 *
 *    Copyright (c) 2020-2022 Project CHIP Authors
 *    Copyright (c) 2013-2017 Nest Labs, Inc.
 *
 *    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.
 */

/**
 *    @file
 *      This file defines error constants for the CHIP core
 *      subsystem.
 *
 *      Error types, ranges, and mappings overrides may be made by
 *      defining the appropriate CHIP_CONFIG_* or _CHIP_CONFIG_*
 *      macros.
 */

#pragma once

#include <lib/core/CHIPConfig.h>
#include <lib/support/TypeTraits.h>

#include <inttypes.h>
#include <limits>
#include <stdint.h>
#include <type_traits>

namespace chip {

/**
 * This class represents CHIP errors.
 *
 * At the top level, an error belongs to a Range and has an integral Value whose meaning depends on the Range.
 * One, Range::kSDK, is used for the CHIP SDK's own errors; others encapsulate error codes from external sources
 * (e.g. libraries, OS) into a CHIP_ERROR.
 *
 * CHIP SDK errors inside Range::kSDK consist of a component identifier given by SdkPart and an arbitrary small
 * integer Code.
 */
class ChipError
{
public:
    /// Internal representation of an error.
    using StorageType = uint32_t;

    /// Type for encapsulated error values.
    using ValueType = StorageType;

    /// Integer `printf` format for errors. This is a C macro in order to allow for string literal concatenation.
#define CHIP_ERROR_INTEGER_FORMAT PRIx32

#if CHIP_CONFIG_ERROR_FORMAT_AS_STRING

    /// Type returned by Format().
    using FormatType = const char *;
    /// `printf` format for Format(). This is a C macro in order to allow for string literal concatenation.
#define CHIP_ERROR_FORMAT "s"

#else // CHIP_CONFIG_ERROR_FORMAT_AS_STRING

    /// Type returned by Format().
    using FormatType = StorageType;
    /// `printf` format for Format(). This is a C macro in order to allow for string literal concatenation.
#define CHIP_ERROR_FORMAT CHIP_ERROR_INTEGER_FORMAT

#endif // CHIP_CONFIG_ERROR_FORMAT_AS_STRING

    /**
     * Top-level error classification.
     *
     * Every error belongs to a Range and has an integral Value whose meaning depends on the Range.
     * All native CHIP SDK errors belong to the kSDK range. Other ranges are used to encapsulate error
     * codes from other subsystems (e.g. platform or library) used by the CHIP SDK.
     */
    enum class Range : uint8_t
    {
        kSDK        = 0x0, ///< CHIP SDK errors.
        kOS         = 0x1, ///< Encapsulated OS errors, other than POSIX errno.
        kPOSIX      = 0x2, ///< Encapsulated POSIX errno values.
        kLwIP       = 0x3, ///< Encapsulated LwIP errors.
        kOpenThread = 0x4, ///< Encapsulated OpenThread errors.
        kPlatform   = 0x5, ///< Platform-defined encapsulation.
        kLastRange  = kPlatform,
    };

    /**
     * Secondary classification of CHIP SDK errors (Range::kSDK).
     */
    enum class SdkPart : uint8_t
    {
        kCore            = 0, ///< SDK core errors.
        kInet            = 1, ///< Inet layer errors; see <inet/InetError.h>.
        kDevice          = 2, ///< Device layer errors; see <platform/CHIPDeviceError.h>.
        kASN1            = 3, ///< ASN1 errors; see <asn1/ASN1Error.h>.
        kBLE             = 4, ///< BLE layer errors; see <ble/BleError.h>.
        kIMGlobalStatus  = 5, ///< Interaction Model global status code.
        kIMClusterStatus = 6, ///< Interaction Model cluster-specific status code.
        kApplication     = 7, ///< Application-defined errors; see CHIP_APPLICATION_ERROR
    };

    ChipError() = default;

    // Helper for declaring constructors without too much repetition.
#if CHIP_CONFIG_ERROR_SOURCE
#define CHIP_INITIALIZE_ERROR_SOURCE(f, l) , mFile((f)), mLine((l))
#else // CHIP_CONFIG_ERROR_SOURCE
#define CHIP_INITIALIZE_ERROR_SOURCE(f, l)
#endif // CHIP_CONFIG_ERROR_SOURCE

    /**
     * Construct a CHIP_ERROR encapsulating @a value inside the Range @a range.
     *
     * @note
     *  The result is valid only if CanEncapsulate() is true.
     */
    constexpr ChipError(Range range, ValueType value) :
        mError(MakeInteger(range, (value & MakeMask(0, kValueLength)))) CHIP_INITIALIZE_ERROR_SOURCE(nullptr, 0)
    {}
    constexpr ChipError(Range range, ValueType value, const char * file, unsigned int line) :
        mError(MakeInteger(range, (value & MakeMask(0, kValueLength)))) CHIP_INITIALIZE_ERROR_SOURCE(file, line)
    {}

    /**
     * Construct a CHIP_ERROR for SdkPart @a part with @a code.
     *
     * @note
     *  The macro version CHIP_SDK_ERROR checks that the numeric value is constant and well-formed.
     */
    constexpr ChipError(SdkPart part, uint8_t code) : mError(MakeInteger(part, code)) CHIP_INITIALIZE_ERROR_SOURCE(nullptr, 0) {}
    constexpr ChipError(SdkPart part, uint8_t code, const char * file, unsigned int line) :
        mError(MakeInteger(part, code)) CHIP_INITIALIZE_ERROR_SOURCE(file, line)
    {}

    /**
     * Construct a CHIP_ERROR constant for SdkPart @a part with @a code at the current source line.
     * This checks that the numeric value is constant and well-formed.
     * (In C++20 this could be replaced by a consteval constructor.)
     */
#if CHIP_CONFIG_ERROR_SOURCE
#define CHIP_SDK_ERROR(part, code)                                                                                                 \
    (::chip::ChipError(::chip::ChipError::SdkErrorConstant<(part), (code)>::value, __FILE__, __LINE__))
#else // CHIP_CONFIG_ERROR_SOURCE
#define CHIP_SDK_ERROR(part, code) (::chip::ChipError(::chip::ChipError::SdkErrorConstant<(part), (code)>::value))
#endif // CHIP_CONFIG_ERROR_SOURCE

    /**
     * Construct a CHIP_ERROR from the underlying storage type.
     *
     * @note
     *  This is intended to be used only in foreign function interfaces.
     */
    explicit constexpr ChipError(StorageType error) : mError(error) CHIP_INITIALIZE_ERROR_SOURCE(nullptr, 0) {}
    explicit constexpr ChipError(StorageType error, const char * file, unsigned int line) :
        mError(error) CHIP_INITIALIZE_ERROR_SOURCE(file, line)
    {}

#undef CHIP_INITIALIZE_ERROR_SOURCE

    /**
     * Compare errors for equality.
     *
     * @note
     *  This only compares the error code. Under the CHIP_CONFIG_ERROR_SOURCE configuration, errors compare equal
     *  if they have the same error code, even if they have different source locations.
     */
    bool operator==(const ChipError & other) const { return mError == other.mError; }
    bool operator!=(const ChipError & other) const { return mError != other.mError; }

    /**
     * Return an integer code for the error.
     */
    constexpr StorageType AsInteger() const { return mError; }

    /*
     * IsSuccess() is intended to support macros that can take either a ChipError or an integer error code.
     * The latter follows the C convention that a non-zero integer indicates an error.
     *
     * @note
     *  Normal code should use `status == CHIP_NO_ERROR` rather than `IsSuccess(status)`.
     */
    static constexpr bool IsSuccess(ChipError error) { return error.mError == 0; }
    static constexpr bool IsSuccess(StorageType error) { return error == 0; }

    /**
     * Format an @a error for printing.
     *
     * Normally, this is used with the `printf()`-style macro CHIP_ERROR_FORMAT.
     * For example,
     *  @code
     *      ChipLogError(subsystem, "A bad thing happened! %" CHIP_ERROR_FORMAT, status.Format());
     *  @endcode
     */
#if CHIP_CONFIG_ERROR_FORMAT_AS_STRING
    FormatType Format() const { return AsString(); }
#else  // CHIP_CONFIG_ERROR_FORMAT_AS_STRING
    FormatType Format() const { return mError; }
#endif // CHIP_CONFIG_ERROR_FORMAT_AS_STRING

    /**
     * Format an @a error as a string for printing.
     *
     * @note
     *  Normally, prefer to use Format()
     */
    const char * AsString() const
    {
        extern const char * ErrorStr(ChipError);
        return ErrorStr(*this);
    }

    /**
     * Test whether @a error belongs to the Range @a range.
     */
    constexpr bool IsRange(Range range) const
    {
        return (mError & MakeMask(kRangeStart, kRangeLength)) == MakeField(kRangeStart, static_cast<StorageType>(range));
    }

    /**
     * Get the Range to which the @a error belongs.
     */
    constexpr Range GetRange() const { return static_cast<Range>(GetField(kRangeStart, kRangeLength, mError)); }

    /**
     * Get the encapsulated value of an @a error.
     */
    constexpr ValueType GetValue() const { return GetField(kValueStart, kValueLength, mError); }

    /**
     * Test whether type @a T can always be losslessly encapsulated in a CHIP_ERROR.
     */
    template <typename T>
    static constexpr bool CanEncapsulate()
    {
        return std::numeric_limits<typename std::make_unsigned_t<T>>::digits <= kValueLength;
    }

    /**
     * Test whether if @a value can be losslessly encapsulated in a CHIP_ERROR.
     */
    template <typename T>
    static constexpr bool CanEncapsulate(T value)
    {
        return CanEncapsulate<T>() || FitsInField(kValueLength, static_cast<ValueType>(value));
    }

    /**
     * Test whether @a error is an SDK error belonging to the SdkPart @a part.
     */
    constexpr bool IsPart(SdkPart part) const
    {
        return (mError & (MakeMask(kRangeStart, kRangeLength) | MakeMask(kSdkPartStart, kSdkPartLength))) ==
            (MakeField(kRangeStart, static_cast<StorageType>(Range::kSDK)) |
             MakeField(kSdkPartStart, static_cast<StorageType>(part)));
    }

    /**
     * Get the SDK code for an SDK error.
     */
    constexpr uint8_t GetSdkCode() const { return static_cast<uint8_t>(GetField(kSdkCodeStart, kSdkCodeLength, mError)); }

    /**
     * Test whether @a error is an SDK error representing an Interaction Model
     * status.  If it is, it can be converted to/from an interaction model
     * StatusIB struct.
     */
    constexpr bool IsIMStatus() const
    {
        // Open question: should CHIP_NO_ERROR be treated as an IM status for
        // purposes of this test?
        return IsPart(SdkPart::kIMGlobalStatus) || IsPart(SdkPart::kIMClusterStatus);
    }

#if CHIP_CONFIG_ERROR_SOURCE

    /**
     * Get the source file name of the point where the error occurred.
     *
     * @note
     *  This will be `nullptr` if the error was not created with a file name.
     */
    const char * GetFile() const { return mFile; }

    /**
     * Get the source line number of the point where the error occurred.
     *
     * @note
     *  This will be 0 if the error was not created with a file name.
     */
    unsigned int GetLine() const { return mLine; }

#endif // CHIP_CONFIG_ERROR_SOURCE

private:
    /*
     * The representation of a CHIP_ERROR is structured so that SDK error code constants are small, in order to improve code
     * density on embedded builds. Arm 32, Xtensa, and RISC-V can all handle 11-bit values in a move-immediate instruction.
     * Further, SdkPart::kCore is 0 so that the most common errors fit in 8 bits for additional density on some processors.
     *
     *  31    28      24      20      16      12       8       4       0    Bit
     *  |       |       |       |       |       |       |       |       |
     *  |     range     |                     value                     |
     *  |    kSdk==0    |       0               |0| part|    code       |   SDK error
     *  |    01 - FF    |          encapsulated error code              |   Encapsulated error
     */
    static constexpr int kRangeStart  = 24;
    static constexpr int kRangeLength = 8;
    static constexpr int kValueStart  = 0;
    static constexpr int kValueLength = 24;

    static constexpr int kSdkPartStart  = 8;
    static constexpr int kSdkPartLength = 3;
    static constexpr int kSdkCodeStart  = 0;
    static constexpr int kSdkCodeLength = 8;

    static constexpr StorageType GetField(unsigned int start, unsigned int length, StorageType value)
    {
        return (value >> start) & ((1u << length) - 1);
    }
    static constexpr StorageType MakeMask(unsigned int start, unsigned int length) { return ((1u << length) - 1) << start; }
    static constexpr StorageType MakeField(unsigned int start, StorageType value) { return value << start; }
    static constexpr bool FitsInField(unsigned int length, StorageType value) { return value < (1u << length); }

    static constexpr StorageType MakeInteger(Range range, StorageType value)
    {
        return MakeField(kRangeStart, to_underlying(range)) | MakeField(kValueStart, value);
    }
    static constexpr StorageType MakeInteger(SdkPart part, uint8_t code)
    {
        return MakeInteger(Range::kSDK, MakeField(kSdkPartStart, to_underlying(part)) | MakeField(kSdkCodeStart, code));
    }
    template <unsigned int START, unsigned int LENGTH>
    struct MaskConstant
    {
        static constexpr StorageType value = ((1u << LENGTH) - 1) << START;
    };

    // Assert that Range and Value fields fit in StorageType and don't overlap.
    static_assert(kRangeStart + kRangeLength <= std::numeric_limits<StorageType>::digits, "Range does not fit in StorageType");
    static_assert(kValueStart + kValueLength <= std::numeric_limits<StorageType>::digits, "Value does not fit in StorageType");
    static_assert((MaskConstant<kRangeStart, kRangeLength>::value & MaskConstant<kValueStart, kValueLength>::value) == 0,
                  "Range and Value overlap");

    // Assert that SDK Part and Code fields fit in SdkCode field and don't overlap.
    static_assert(kSdkPartStart + kSdkPartLength <= kValueLength, "SdkPart does not fit in Value");
    static_assert(kSdkCodeStart + kSdkCodeLength <= kValueLength, "SdkCode does not fit in Value");
    static_assert((MaskConstant<kSdkPartStart, kSdkPartLength>::value & MaskConstant<kSdkCodeStart, kSdkCodeLength>::value) == 0,
                  "SdkPart and SdkCode overlap");

    // Assert that Value fits in ValueType.
    static_assert(kValueStart + kValueLength <= std::numeric_limits<ValueType>::digits, "Value does not fit in ValueType");

    StorageType mError;

#if CHIP_CONFIG_ERROR_SOURCE
    const char * mFile;
    unsigned int mLine;
#endif // CHIP_CONFIG_ERROR_SOURCE

public:
    /**
     * Helper for constructing error constants.
     *
     * This template ensures that the numeric value is constant and well-formed.
     */
    template <SdkPart PART, StorageType CODE>
    struct SdkErrorConstant
    {
        static_assert(FitsInField(kSdkPartLength, to_underlying(PART)), "part is too large");
        static_assert(FitsInField(kSdkCodeLength, CODE), "code is too large");
        static_assert(MakeInteger(PART, CODE) != 0, "value is zero");
        static constexpr StorageType value = MakeInteger(PART, CODE);
    };
};

} // namespace chip

/**
 *  The basic type for all CHIP errors.
 */
using CHIP_ERROR = ::chip::ChipError;

/**
 * Applications using the CHIP SDK can use this to define error codes in the CHIP_ERROR space for their own purposes.
 * This is suitable for a small fixed set of errors, similar to `CHIP_ERROR_…` constants. For embedding arbitrary or
 * larger values, use a custom Range offset from Range::kLastRange.
 */
#define CHIP_APPLICATION_ERROR(e) CHIP_SDK_ERROR(::chip::ChipError::SdkPart::kApplication, (e))

#define CHIP_CORE_ERROR(e) CHIP_SDK_ERROR(::chip::ChipError::SdkPart::kCore, (e))

#define CHIP_IM_GLOBAL_STATUS(type)                                                                                                \
    CHIP_SDK_ERROR(::chip::ChipError::SdkPart::kIMGlobalStatus,                                                                    \
                   ::chip::to_underlying(::chip::Protocols::InteractionModel::Status::type))

//
// type must be a compile-time constant as mandated by CHIP_SDK_ERROR.
//
#define CHIP_IM_CLUSTER_STATUS(type) CHIP_SDK_ERROR(::chip::ChipError::SdkPart::kIMClusterStatus, type)

// clang-format off

/**
 *  @name Error Definitions
 *
 *  @{
 */

/**
 *  @def CHIP_NO_ERROR
 *
 *  @brief
 *    This defines the CHIP error code for success or no error.
 *
 */
#if CHIP_CONFIG_ERROR_SOURCE && CHIP_CONFIG_ERROR_SOURCE_NO_ERROR
#define CHIP_NO_ERROR                                          CHIP_ERROR(0, __FILE__, __LINE__)
#else // CHIP_CONFIG_ERROR_SOURCE && CHIP_CONFIG_ERROR_SOURCE_NO_ERROR
#define CHIP_NO_ERROR                                          CHIP_ERROR(0)
#endif // CHIP_CONFIG_ERROR_SOURCE && CHIP_CONFIG_ERROR_SOURCE_NO_ERROR

/**
 *  @def CHIP_ERROR_SENDING_BLOCKED
 *
 *  @brief
 *    A message exceeds the sent limit.
 *
 */
#define CHIP_ERROR_SENDING_BLOCKED                             CHIP_CORE_ERROR(0x01)

/**
 *  @def CHIP_ERROR_CONNECTION_ABORTED
 *
 *  @brief
 *    A connection has been aborted.
 *
 */
#define CHIP_ERROR_CONNECTION_ABORTED                          CHIP_CORE_ERROR(0x02)

/**
 *  @def CHIP_ERROR_INCORRECT_STATE
 *
 *  @brief
 *    An unexpected state was encountered.
 *
 */
#define CHIP_ERROR_INCORRECT_STATE                             CHIP_CORE_ERROR(0x03)

/**
 *  @def CHIP_ERROR_MESSAGE_TOO_LONG
 *
 *  @brief
 *    A message is too long.
 *
 */
#define CHIP_ERROR_MESSAGE_TOO_LONG                            CHIP_CORE_ERROR(0x04)

/**
 *  @def CHIP_ERROR_UNSUPPORTED_EXCHANGE_VERSION
 *
 *  @brief
 *    An exchange version is not supported.
 *
 */
#define CHIP_ERROR_UNSUPPORTED_EXCHANGE_VERSION                CHIP_CORE_ERROR(0x05)

/**
 *  @def CHIP_ERROR_TOO_MANY_UNSOLICITED_MESSAGE_HANDLERS
 *
 *  @brief
 *    The attempt to register an unsolicited message handler failed because the
 *    unsolicited message handler pool is full.
 *
 */
#define CHIP_ERROR_TOO_MANY_UNSOLICITED_MESSAGE_HANDLERS       CHIP_CORE_ERROR(0x06)

/**
 *  @def CHIP_ERROR_NO_UNSOLICITED_MESSAGE_HANDLER
 *
 *  @brief
 *    The attempt to unregister an unsolicited message handler failed because
 *    the target handler was not found in the unsolicited message handler pool.
 *
 */
#define CHIP_ERROR_NO_UNSOLICITED_MESSAGE_HANDLER              CHIP_CORE_ERROR(0x07)

/**
 *  @def CHIP_ERROR_NO_CONNECTION_HANDLER
 *
 *  @brief
 *    No callback has been registered for handling a connection.
 *
 */
#define CHIP_ERROR_NO_CONNECTION_HANDLER                       CHIP_CORE_ERROR(0x08)

/**
 *  @def CHIP_ERROR_TOO_MANY_PEER_NODES
 *
 *  @brief
 *    The number of peer nodes exceeds the maximum limit of a local node.
 *
 */
#define CHIP_ERROR_TOO_MANY_PEER_NODES                         CHIP_CORE_ERROR(0x09)

/**
 *  @def CHIP_ERROR_SENTINEL
 *
 *  @brief
 *    For use locally to mark conditions such as value found or end of iteration.
 *
 */
#define CHIP_ERROR_SENTINEL                                    CHIP_CORE_ERROR(0x0a)

/**
 *  @def CHIP_ERROR_NO_MEMORY
 *
 *  @brief
 *    The attempt to allocate a buffer or object failed due to a lack of memory.
 *
 */
#define CHIP_ERROR_NO_MEMORY                                   CHIP_CORE_ERROR(0x0b)

/**
 *  @def CHIP_ERROR_NO_MESSAGE_HANDLER
 *
 *  @brief
 *    No callback has been registered for handling a message.
 *
 */
#define CHIP_ERROR_NO_MESSAGE_HANDLER                          CHIP_CORE_ERROR(0x0c)

/**
 *  @def CHIP_ERROR_MESSAGE_INCOMPLETE
 *
 *  @brief
 *    A message is incomplete.
 *
 */
#define CHIP_ERROR_MESSAGE_INCOMPLETE                          CHIP_CORE_ERROR(0x0d)

/**
 *  @def CHIP_ERROR_DATA_NOT_ALIGNED
 *
 *  @brief
 *    The data is not aligned.
 *
 */
#define CHIP_ERROR_DATA_NOT_ALIGNED                            CHIP_CORE_ERROR(0x0e)

/**
 *  @def CHIP_ERROR_UNKNOWN_KEY_TYPE
 *
 *  @brief
 *    The encryption key type is unknown.
 *
 */
#define CHIP_ERROR_UNKNOWN_KEY_TYPE                            CHIP_CORE_ERROR(0x0f)

/**
 *  @def CHIP_ERROR_KEY_NOT_FOUND
 *
 *  @brief
 *    The encryption key is not found.
 *
 */
#define CHIP_ERROR_KEY_NOT_FOUND                               CHIP_CORE_ERROR(0x10)

/**
 *  @def CHIP_ERROR_WRONG_ENCRYPTION_TYPE
 *
 *  @brief
 *    The encryption type is incorrect for the specified key.
 *
 */
#define CHIP_ERROR_WRONG_ENCRYPTION_TYPE                       CHIP_CORE_ERROR(0x11)

/**
 *  @def CHIP_ERROR_TOO_MANY_KEYS
 *
 *  @brief
 *    The attempt to allocate a key failed because the number of active keys
 *    exceeds the maximum limit.
 *
 */
#define CHIP_ERROR_TOO_MANY_KEYS                               CHIP_CORE_ERROR(0x12)

/**
 *  @def CHIP_ERROR_INTEGRITY_CHECK_FAILED
 *
 *  @brief
 *    The integrity check in the message does not match the expected integrity
 *    check.
 *
 */
#define CHIP_ERROR_INTEGRITY_CHECK_FAILED                      CHIP_CORE_ERROR(0x13)

/**
 *  @def CHIP_ERROR_INVALID_SIGNATURE
 *
 *  @brief
 *    Invalid signature.
 *
 */
#define CHIP_ERROR_INVALID_SIGNATURE                           CHIP_CORE_ERROR(0x14)

/**
 *  @def CHIP_ERROR_UNSUPPORTED_MESSAGE_VERSION
 *
 *  @brief
 *    A message version is unsupported.
 *
 */
#define CHIP_ERROR_UNSUPPORTED_MESSAGE_VERSION                 CHIP_CORE_ERROR(0x15)

/**
 *  @def CHIP_ERROR_UNSUPPORTED_ENCRYPTION_TYPE
 *
 *  @brief
 *    An encryption type is unsupported.
 *
 */
#define CHIP_ERROR_UNSUPPORTED_ENCRYPTION_TYPE                 CHIP_CORE_ERROR(0x16)

/**
 *  @def CHIP_ERROR_UNSUPPORTED_SIGNATURE_TYPE
 *
 *  @brief
 *    A signature type is unsupported.
 *
 */
#define CHIP_ERROR_UNSUPPORTED_SIGNATURE_TYPE                  CHIP_CORE_ERROR(0x17)

/**
 *  @def CHIP_ERROR_INVALID_MESSAGE_LENGTH
 *
 *  @brief
 *    A message length is invalid.
 *
 */
#define CHIP_ERROR_INVALID_MESSAGE_LENGTH                      CHIP_CORE_ERROR(0x18)

/**
 *  @def CHIP_ERROR_BUFFER_TOO_SMALL
 *
 *  @brief
 *    A buffer is too small.
 *
 */
#define CHIP_ERROR_BUFFER_TOO_SMALL                            CHIP_CORE_ERROR(0x19)

/**
 *  @def CHIP_ERROR_DUPLICATE_KEY_ID
 *
 *  @brief
 *    A key id is duplicate.
 *
 */
#define CHIP_ERROR_DUPLICATE_KEY_ID                            CHIP_CORE_ERROR(0x1a)

/**
 *  @def CHIP_ERROR_WRONG_KEY_TYPE
 *
 *  @brief
 *    A key type does not match the expected key type.
 *
 */
#define CHIP_ERROR_WRONG_KEY_TYPE                              CHIP_CORE_ERROR(0x1b)

/**
 *  @def CHIP_ERROR_WELL_UNINITIALIZED
 *
 *  @brief
 *    A requested object is uninitialized.
 *
 */
#define CHIP_ERROR_WELL_UNINITIALIZED                          CHIP_CORE_ERROR(0x1c)

/**
 *  @def CHIP_ERROR_WELL_EMPTY
 *
 *  @brief
 *    A requested object is empty.
 *
 */
#define CHIP_ERROR_WELL_EMPTY                                  CHIP_CORE_ERROR(0x1d)

/**
 *  @def CHIP_ERROR_INVALID_STRING_LENGTH
 *
 *  @brief
 *    A string length is invalid.
 *
 */
#define CHIP_ERROR_INVALID_STRING_LENGTH                       CHIP_CORE_ERROR(0x1e)

/**
 *  @def CHIP_ERROR_INVALID_LIST_LENGTH
 *
 *  @brief
 *    A list length is invalid.
 *
 */
#define CHIP_ERROR_INVALID_LIST_LENGTH                         CHIP_CORE_ERROR(0x1f)

/**
 *  @def CHIP_ERROR_INVALID_INTEGRITY_TYPE
 *
 *  @brief
 *    An integrity type is invalid.
 *
 */
#define CHIP_ERROR_INVALID_INTEGRITY_TYPE                      CHIP_CORE_ERROR(0x20)

/**
 *  @def CHIP_END_OF_TLV
 *
 *  @brief
 *    The end of a TLV encoding,
 *    or the end of a TLV container element has been reached.
 *
 */
#define CHIP_ERROR_END_OF_TLV                                  CHIP_CORE_ERROR(0x21)
#define CHIP_END_OF_TLV CHIP_ERROR_END_OF_TLV

/**
 *  @def CHIP_ERROR_TLV_UNDERRUN
 *
 *  @brief
 *    The TLV encoding ended prematurely.
 *
 */
#define CHIP_ERROR_TLV_UNDERRUN                                CHIP_CORE_ERROR(0x22)

/**
 *  @def CHIP_ERROR_INVALID_TLV_ELEMENT
 *
 *  @brief
 *    A TLV element is invalid.
 *
 */
#define CHIP_ERROR_INVALID_TLV_ELEMENT                         CHIP_CORE_ERROR(0x23)

/**
 *  @def CHIP_ERROR_INVALID_TLV_TAG
 *
 *  @brief
 *    A TLV tag is invalid.
 *
 */
#define CHIP_ERROR_INVALID_TLV_TAG                             CHIP_CORE_ERROR(0x24)

/**
 *  @def CHIP_ERROR_UNKNOWN_IMPLICIT_TLV_TAG
 *
 *  @brief
 *    An implicitly encoded TLV tag was encountered,
 *    but an implicit profile id has not been defined.
 *
 */
#define CHIP_ERROR_UNKNOWN_IMPLICIT_TLV_TAG                    CHIP_CORE_ERROR(0x25)

/**
 *  @def CHIP_ERROR_WRONG_TLV_TYPE
 *
 *  @brief
 *    A TLV type is wrong.
 *
 */
#define CHIP_ERROR_WRONG_TLV_TYPE                              CHIP_CORE_ERROR(0x26)

/**
 *  @def CHIP_ERROR_TLV_CONTAINER_OPEN
 *
 *  @brief
 *    A TLV container is unexpectedly open.
 *
 */
#define CHIP_ERROR_TLV_CONTAINER_OPEN                          CHIP_CORE_ERROR(0x27)

/**
 *  @def CHIP_ERROR_INVALID_TRANSFER_MODE
 *
 *  @brief
 *    A transfer mode is invalid.
 *
 */
#define CHIP_ERROR_INVALID_TRANSFER_MODE                       CHIP_CORE_ERROR(0x28)

/**
 *  @def CHIP_ERROR_INVALID_PROFILE_ID
 *
 *  @brief
 *    A profile id is invalid.
 *
 */
#define CHIP_ERROR_INVALID_PROFILE_ID                          CHIP_CORE_ERROR(0x29)

/**
 *  @def CHIP_ERROR_INVALID_MESSAGE_TYPE
 *
 *  @brief
 *    A message type is invalid.
 *
 */
#define CHIP_ERROR_INVALID_MESSAGE_TYPE                        CHIP_CORE_ERROR(0x2a)

/**
 *  @def CHIP_ERROR_UNEXPECTED_TLV_ELEMENT
 *
 *  @brief
 *    An unexpected TLV element was encountered.
 *
 */
#define CHIP_ERROR_UNEXPECTED_TLV_ELEMENT                      CHIP_CORE_ERROR(0x2b)

/**
 *  @def CHIP_ERROR_STATUS_REPORT_RECEIVED
 *
 *  @brief
 *    A status report is received from a peer node.
 *
 */
#define CHIP_ERROR_STATUS_REPORT_RECEIVED                      CHIP_CORE_ERROR(0x2c)

/**
 *  @def CHIP_ERROR_NOT_IMPLEMENTED
 *
 *  @brief
 *    A requested function or feature is not implemented.
 *
 */
#define CHIP_ERROR_NOT_IMPLEMENTED                             CHIP_CORE_ERROR(0x2d)

/**
 *  @def CHIP_ERROR_INVALID_ADDRESS
 *
 *  @brief
 *    An address is invalid.
 *
 */
#define CHIP_ERROR_INVALID_ADDRESS                             CHIP_CORE_ERROR(0x2e)

/**
 *  @def CHIP_ERROR_INVALID_ARGUMENT
 *
 *  @brief
 *    An argument is invalid.
 *
 */
#define CHIP_ERROR_INVALID_ARGUMENT                            CHIP_CORE_ERROR(0x2f)

/**
 *  @def CHIP_ERROR_INVALID_PATH_LIST
 *
 *  @brief
 *    A TLV path list is invalid.
 *
 */
#define CHIP_ERROR_INVALID_PATH_LIST                           CHIP_CORE_ERROR(0x30)

/**
 *  @def CHIP_ERROR_INVALID_DATA_LIST
 *
 *  @brief
 *    A TLV data list is invalid.
 *
 */
#define CHIP_ERROR_INVALID_DATA_LIST                           CHIP_CORE_ERROR(0x31)

/**
 *  @def CHIP_ERROR_TIMEOUT
 *
 *  @brief
 *    A request timed out.
 *
 */
#define CHIP_ERROR_TIMEOUT                                     CHIP_CORE_ERROR(0x32)

/**
 *  @def CHIP_ERROR_INVALID_DEVICE_DESCRIPTOR
 *
 *  @brief
 *    A device descriptor is invalid.
 *
 */
#define CHIP_ERROR_INVALID_DEVICE_DESCRIPTOR                   CHIP_CORE_ERROR(0x33)

/**
 *  @def CHIP_ERROR_UNSUPPORTED_DEVICE_DESCRIPTOR_VERSION
 *
 *  @brief
 *    A device descriptor version is unsupported.
 *
 */
#define CHIP_ERROR_UNSUPPORTED_DEVICE_DESCRIPTOR_VERSION       CHIP_CORE_ERROR(0x34)

/**
 *  @def CHIP_END_OF_INPUT
 *
 *  @brief
 *    An input ended.
 *
 */
#define CHIP_ERROR_END_OF_INPUT                                CHIP_CORE_ERROR(0x35)
#define CHIP_END_OF_INPUT CHIP_ERROR_END_OF_INPUT

/**
 *  @def CHIP_ERROR_RATE_LIMIT_EXCEEDED
 *
 *  @brief
 *    A rate limit is exceeded.
 *
 */
#define CHIP_ERROR_RATE_LIMIT_EXCEEDED                         CHIP_CORE_ERROR(0x36)

/**
 *  @def CHIP_ERROR_SECURITY_MANAGER_BUSY
 *
 *  @brief
 *    A security manager is busy.
 *
 */
#define CHIP_ERROR_SECURITY_MANAGER_BUSY                       CHIP_CORE_ERROR(0x37)

/**
 *  @def CHIP_ERROR_INVALID_PASE_PARAMETER
 *
 *  @brief
 *    A PASE parameter is invalid.
 *
 */
#define CHIP_ERROR_INVALID_PASE_PARAMETER                      CHIP_CORE_ERROR(0x38)

/**
 *  @def CHIP_ERROR_PASE_SUPPORTS_ONLY_CONFIG1
 *
 *  @brief
 *    PASE supports only config1.
 *
 */
#define CHIP_ERROR_PASE_SUPPORTS_ONLY_CONFIG1                  CHIP_CORE_ERROR(0x39)

/**
 *  @def CHIP_ERROR_KEY_CONFIRMATION_FAILED
 *
 *  @brief
 *    A key confirmation failed.
 *
 */
#define CHIP_ERROR_KEY_CONFIRMATION_FAILED                     CHIP_CORE_ERROR(0x3a)

/**
 *  @def CHIP_ERROR_INVALID_USE_OF_SESSION_KEY
 *
 *  @brief
 *    A use of session key is invalid.
 *
 */
#define CHIP_ERROR_INVALID_USE_OF_SESSION_KEY                  CHIP_CORE_ERROR(0x3b)

/**
 *  @def CHIP_ERROR_CONNECTION_CLOSED_UNEXPECTEDLY
 *
 *  @brief
 *    A connection is closed unexpectedly.
 *
 */
#define CHIP_ERROR_CONNECTION_CLOSED_UNEXPECTEDLY              CHIP_CORE_ERROR(0x3c)

/**
 *  @def CHIP_ERROR_MISSING_TLV_ELEMENT
 *
 *  @brief
 *    A TLV element is missing.
 *
 */
#define CHIP_ERROR_MISSING_TLV_ELEMENT                         CHIP_CORE_ERROR(0x3d)

/**
 *  @def CHIP_ERROR_RANDOM_DATA_UNAVAILABLE
 *
 *  @brief
 *    Secure random data is not available.
 *
 */
#define CHIP_ERROR_RANDOM_DATA_UNAVAILABLE                     CHIP_CORE_ERROR(0x3e)

/**
 *  @def CHIP_ERROR_UNSUPPORTED_HOST_PORT_ELEMENT
 *
 *  @brief
 *    A type in host/port list is unsupported.
 *
 */
#define CHIP_ERROR_UNSUPPORTED_HOST_PORT_ELEMENT               CHIP_CORE_ERROR(0x3f)

/**
 *  @def CHIP_ERROR_INVALID_HOST_SUFFIX_INDEX
 *
 *  @brief
 *    A suffix index in host/port list is invalid.
 *
 */
#define CHIP_ERROR_INVALID_HOST_SUFFIX_INDEX                   CHIP_CORE_ERROR(0x40)

/**
 *  @def CHIP_ERROR_HOST_PORT_LIST_EMPTY
 *
 *  @brief
 *    A host/port list is empty.
 *
 */
#define CHIP_ERROR_HOST_PORT_LIST_EMPTY                        CHIP_CORE_ERROR(0x41)

/**
 *  @def CHIP_ERROR_UNSUPPORTED_AUTH_MODE
 *
 *  @brief
 *    An authentication mode is unsupported.
 *
 */
#define CHIP_ERROR_UNSUPPORTED_AUTH_MODE                       CHIP_CORE_ERROR(0x42)

/**
 *  @def CHIP_ERROR_INVALID_SERVICE_EP
 *
 *  @brief
 *    A service endpoint is invalid.
 *
 */
#define CHIP_ERROR_INVALID_SERVICE_EP                          CHIP_CORE_ERROR(0x43)

/**
 *  @def CHIP_ERROR_INVALID_DIRECTORY_ENTRY_TYPE
 *
 *  @brief
 *    A directory entry type is unknown.
 *
 */
#define CHIP_ERROR_INVALID_DIRECTORY_ENTRY_TYPE                CHIP_CORE_ERROR(0x44)

/**
 *  @def CHIP_ERROR_FORCED_RESET
 *
 *  @brief
 *    A service manager is forced to reset.
 *
 */
#define CHIP_ERROR_FORCED_RESET                                CHIP_CORE_ERROR(0x45)

/**
 *  @def CHIP_ERROR_NO_ENDPOINT
 *
 *  @brief
 *    No endpoint is available.
 *
 */
#define CHIP_ERROR_NO_ENDPOINT                                 CHIP_CORE_ERROR(0x46)

/**
 *  @def CHIP_ERROR_INVALID_DESTINATION_NODE_ID
 *
 *  @brief
 *    A destination node id is invalid.
 *
 */
#define CHIP_ERROR_INVALID_DESTINATION_NODE_ID                 CHIP_CORE_ERROR(0x47)

/**
 *  @def CHIP_ERROR_NOT_CONNECTED
 *
 *  @brief
 *    The operation cannot be performed because the underlying object is not
 *    connected.
 *
 */
#define CHIP_ERROR_NOT_CONNECTED                               CHIP_CORE_ERROR(0x48)

/**
 *  @def CHIP_ERROR_NO_SW_UPDATE_AVAILABLE
 *
 *  @brief
 *    No software update is available.
 *
 */
#define CHIP_ERROR_NO_SW_UPDATE_AVAILABLE                      CHIP_CORE_ERROR(0x49)

/**
 *  @def CHIP_ERROR_CA_CERT_NOT_FOUND
 *
 *  @brief
 *    CA certificate is not found.
 *
 */
#define CHIP_ERROR_CA_CERT_NOT_FOUND                           CHIP_CORE_ERROR(0x4a)

/**
 *  @def CHIP_ERROR_CERT_PATH_LEN_CONSTRAINT_EXCEEDED
 *
 *  @brief
 *    A certificate path length exceeds the constraint.
 *
 */
#define CHIP_ERROR_CERT_PATH_LEN_CONSTRAINT_EXCEEDED           CHIP_CORE_ERROR(0x4b)

/**
 *  @def CHIP_ERROR_CERT_PATH_TOO_LONG
 *
 *  @brief
 *    A certificate path is too long.
 *
 */
#define CHIP_ERROR_CERT_PATH_TOO_LONG                          CHIP_CORE_ERROR(0x4c)

/**
 *  @def CHIP_ERROR_CERT_USAGE_NOT_ALLOWED
 *
 *  @brief
 *    A requested certificate usage is not allowed.
 *
 */
#define CHIP_ERROR_CERT_USAGE_NOT_ALLOWED                      CHIP_CORE_ERROR(0x4d)

/**
 *  @def CHIP_ERROR_CERT_EXPIRED
 *
 *  @brief
 *    A certificate expired.
 *
 */
#define CHIP_ERROR_CERT_EXPIRED                                CHIP_CORE_ERROR(0x4e)

/**
 *  @def CHIP_ERROR_CERT_NOT_VALID_YET
 *
 *  @brief
 *    A certificate is not valid yet.
 *
 */
#define CHIP_ERROR_CERT_NOT_VALID_YET                          CHIP_CORE_ERROR(0x4f)

/**
 *  @def CHIP_ERROR_UNSUPPORTED_CERT_FORMAT
 *
 *  @brief
 *    A certificate format is unsupported.
 *
 */
#define CHIP_ERROR_UNSUPPORTED_CERT_FORMAT                     CHIP_CORE_ERROR(0x50)

/**
 *  @def CHIP_ERROR_UNSUPPORTED_ELLIPTIC_CURVE
 *
 *  @brief
 *    An elliptic curve is unsupported.
 *
 */
#define CHIP_ERROR_UNSUPPORTED_ELLIPTIC_CURVE                  CHIP_CORE_ERROR(0x51)

/**
 *  @def CHIP_CERT_NOT_USED
 *
 *  @brief
 *    A certificate was not used during the chain validation.
 *
 */
#define CHIP_ERROR_CERT_NOT_USED                               CHIP_CORE_ERROR(0x52)
#define CHIP_CERT_NOT_USED CHIP_ERROR_CERT_NOT_USED

/**
 *  @def CHIP_ERROR_CERT_NOT_FOUND
 *
 *  @brief
 *    A certificate is not found.
 *
 */
#define CHIP_ERROR_CERT_NOT_FOUND                              CHIP_CORE_ERROR(0x53)

/**
 *  @def CHIP_ERROR_INVALID_CASE_PARAMETER
 *
 *  @brief
 *    A CASE parameter is invalid.
 *
 */
#define CHIP_ERROR_INVALID_CASE_PARAMETER                      CHIP_CORE_ERROR(0x54)

/**
 *  @def CHIP_ERROR_UNSUPPORTED_CASE_CONFIGURATION
 *
 *  @brief
 *    A CASE configuration is unsupported.
 *
 */
#define CHIP_ERROR_UNSUPPORTED_CASE_CONFIGURATION              CHIP_CORE_ERROR(0x55)

/**
 *  @def CHIP_ERROR_CERT_LOAD_FAILED
 *
 *  @brief
 *    A certificate load failed.
 *
 */
#define CHIP_ERROR_CERT_LOAD_FAILED                            CHIP_CORE_ERROR(0x56)

/**
 *  @def CHIP_ERROR_CERT_NOT_TRUSTED
 *
 *  @brief
 *    A certificate is not trusted.
 *
 */
#define CHIP_ERROR_CERT_NOT_TRUSTED                            CHIP_CORE_ERROR(0x57)

/**
 *  @def CHIP_ERROR_INVALID_ACCESS_TOKEN
 *
 *  @brief
 *    An access token is invalid.
 *
 */
#define CHIP_ERROR_INVALID_ACCESS_TOKEN                        CHIP_CORE_ERROR(0x58)

/**
 *  @def CHIP_ERROR_WRONG_CERT_DN
 *
 *  @brief
 *    A certificate subject/issuer distinguished name is wrong.
 *
 */
#define CHIP_ERROR_WRONG_CERT_DN                               CHIP_CORE_ERROR(0x59)

/**
 *  @def CHIP_ERROR_INVALID_PROVISIONING_BUNDLE
 *
 *  @brief
 *    A provisioning bundle is invalid.
 *
 */
#define CHIP_ERROR_INVALID_PROVISIONING_BUNDLE                 CHIP_CORE_ERROR(0x5a)

/**
 *  @def CHIP_ERROR_PROVISIONING_BUNDLE_DECRYPTION_ERROR
 *
 *  @brief
 *    A provision bundle encountered a decryption error.
 *
 */
#define CHIP_ERROR_PROVISIONING_BUNDLE_DECRYPTION_ERROR        CHIP_CORE_ERROR(0x5b)

/**
 *  @def CHIP_ERROR_WRONG_NODE_ID
 *
 *  @brief
 *    A node id is wrong.
 *
 */
#define CHIP_ERROR_WRONG_NODE_ID                               CHIP_CORE_ERROR(0x5c)

/**
 *  @def CHIP_ERROR_CONN_ACCEPTED_ON_WRONG_PORT
 *
 *  @brief
 *    A connection is accepted on a wrong port.
 *
 */
#define CHIP_ERROR_CONN_ACCEPTED_ON_WRONG_PORT                 CHIP_CORE_ERROR(0x5d)

/**
 *  @def CHIP_ERROR_CALLBACK_REPLACED
 *
 *  @brief
 *    An application callback has been replaced.
 *
 */
#define CHIP_ERROR_CALLBACK_REPLACED                           CHIP_CORE_ERROR(0x5e)

/**
 *  @def CHIP_ERROR_NO_CASE_AUTH_DELEGATE
 *
 *  @brief
 *    No CASE authentication delegate is set.
 *
 */
#define CHIP_ERROR_NO_CASE_AUTH_DELEGATE                       CHIP_CORE_ERROR(0x5f)

/**
 *  @def CHIP_ERROR_DEVICE_LOCATE_TIMEOUT
 *
 *  @brief
 *    The attempt to locate device timed out.
 *
 */
#define CHIP_ERROR_DEVICE_LOCATE_TIMEOUT                       CHIP_CORE_ERROR(0x60)

/**
 *  @def CHIP_ERROR_DEVICE_CONNECT_TIMEOUT
 *
 *  @brief
 *    The attempt to connect device timed out.
 *
 */
#define CHIP_ERROR_DEVICE_CONNECT_TIMEOUT                      CHIP_CORE_ERROR(0x61)

/**
 *  @def CHIP_ERROR_DEVICE_AUTH_TIMEOUT
 *
 *  @brief
 *    The attempt to authenticate device timed out.
 *
 */
#define CHIP_ERROR_DEVICE_AUTH_TIMEOUT                         CHIP_CORE_ERROR(0x62)

/**
 *  @def CHIP_ERROR_MESSAGE_NOT_ACKNOWLEDGED
 *
 *  @brief
 *    A message is not acknowledged after max retries.
 *
 */
#define CHIP_ERROR_MESSAGE_NOT_ACKNOWLEDGED                    CHIP_CORE_ERROR(0x63)

/**
 *  @def CHIP_ERROR_RETRANS_TABLE_FULL
 *
 *  @brief
 *    A retransmission table is already full.
 *
 */
#define CHIP_ERROR_RETRANS_TABLE_FULL                          CHIP_CORE_ERROR(0x64)

/**
 *  @def CHIP_ERROR_INVALID_ACK_MESSAGE_COUNTER
 *
 *  @brief
 *    An acknowledgment id is invalid.
 *
 */
#define CHIP_ERROR_INVALID_ACK_MESSAGE_COUNTER                 CHIP_CORE_ERROR(0x65)

/**
 *  @def CHIP_ERROR_SEND_THROTTLED
 *
 *  @brief
 *    A send is throttled.
 *
 */
#define CHIP_ERROR_SEND_THROTTLED                              CHIP_CORE_ERROR(0x66)

/**
 *  @def CHIP_ERROR_WRONG_MSG_VERSION_FOR_EXCHANGE
 *
 *  @brief
 *    A message version is not supported by the current exchange context.
 *
 */
#define CHIP_ERROR_WRONG_MSG_VERSION_FOR_EXCHANGE              CHIP_CORE_ERROR(0x67)

/**
 *  @def CHIP_ERROR_TRANSACTION_CANCELED
 *
 *  @brief
 *    A transaction is cancelled.
 *
 */
#define CHIP_ERROR_TRANSACTION_CANCELED                        CHIP_CORE_ERROR(0x68)

/**
 *  @def CHIP_ERROR_LISTENER_ALREADY_STARTED
 *
 *  @brief
 *    A listener has already started.
 *
 */
#define CHIP_ERROR_LISTENER_ALREADY_STARTED                    CHIP_CORE_ERROR(0x69)

/**
 *  @def CHIP_ERROR_LISTENER_ALREADY_STOPPED
 *
 *  @brief
 *    A listener has already stopped.
 *
 */
#define CHIP_ERROR_LISTENER_ALREADY_STOPPED                    CHIP_CORE_ERROR(0x6a)

/**
 *  @def CHIP_ERROR_INVALID_SUBSCRIPTION
 *
 *  @brief
 *    A message was received as part of a subscription exchange that has a mis-matching subscription id.
 *
 */
#define CHIP_ERROR_INVALID_SUBSCRIPTION                               CHIP_CORE_ERROR(0x6b)

/**
 *  @def CHIP_ERROR_UNSUPPORTED_CHIP_FEATURE
 *
 *  @brief
 *    A CHIP feature is unsupported.
 *
 */
#define CHIP_ERROR_UNSUPPORTED_CHIP_FEATURE                    CHIP_CORE_ERROR(0x6c)

/**
 *  @def CHIP_ERROR_PASE_RECONFIGURE_REQUIRED
 *
 *  @brief
 *    PASE is required to reconfigure.
 *
 */
#define CHIP_ERROR_PASE_RECONFIGURE_REQUIRED                   CHIP_CORE_ERROR(0x6d)

/**
 *  @def CHIP_ERROR_INVALID_PASE_CONFIGURATION
 *
 *  @brief
 *    A PASE configuration is invalid.
 *
 */
#define CHIP_ERROR_INVALID_PASE_CONFIGURATION                  CHIP_CORE_ERROR(0x6e)

/**
 *  @def CHIP_ERROR_NO_COMMON_PASE_CONFIGURATIONS
 *
 *  @brief
 *    No PASE configuration is in common.
 *
 */
#define CHIP_ERROR_NO_COMMON_PASE_CONFIGURATIONS               CHIP_CORE_ERROR(0x6f)

/**
 *  @def CHIP_ERROR_UNSOLICITED_MSG_NO_ORIGINATOR
 *
 *  @brief
 *    An unsolicited message with the originator bit clear.
 *
 */
#define CHIP_ERROR_UNSOLICITED_MSG_NO_ORIGINATOR               CHIP_CORE_ERROR(0x70)

/**
 *  @def CHIP_ERROR_INVALID_FABRIC_INDEX
 *
 *  @brief
 *    A fabric index is invalid.
 *
 */
#define CHIP_ERROR_INVALID_FABRIC_INDEX                        CHIP_CORE_ERROR(0x71)

/**
 *  @def CHIP_ERROR_TOO_MANY_CONNECTIONS
 *
 *  @brief
 *    The attempt to allocate a connection object failed because too many
 *    connections exist.
 *
 */
#define CHIP_ERROR_TOO_MANY_CONNECTIONS                        CHIP_CORE_ERROR(0x72)

/**
 * @def CHIP_ERROR_SHUT_DOWN
 *
 * @brief
 *   The operation cancelled because a shut down was initiated
 */
#define CHIP_ERROR_SHUT_DOWN                                   CHIP_CORE_ERROR(0x73)

/**
 * @def CHIP_ERROR_CANCELLED
 *
 * @brief
 *   The operation has been cancelled, generally by calling a cancel/abort request.
 */
#define CHIP_ERROR_CANCELLED                                   CHIP_CORE_ERROR(0x74)

/**
 *  @def CHIP_ERROR_DRBG_ENTROPY_SOURCE_FAILED
 *
 *  @brief
 *    DRBG entropy source failed to generate entropy data.
 *
 */
#define CHIP_ERROR_DRBG_ENTROPY_SOURCE_FAILED                  CHIP_CORE_ERROR(0x75)

/**
 *  @def CHIP_ERROR_TLV_TAG_NOT_FOUND
 *
 *  @brief
 *    A specified TLV tag was not found.
 *
 */
#define CHIP_ERROR_TLV_TAG_NOT_FOUND                           CHIP_CORE_ERROR(0x76)

/**
 * @def CHIP_ERROR_MISSING_SECURE_SESSION
 *
 * @brief
 *
 *  A secure session is needed to do work, but is missing/is not present.
 */
#define CHIP_ERROR_MISSING_SECURE_SESSION                      CHIP_CORE_ERROR(0x77)

/**
 * @def CHIP_ERROR_INVALID_ADMIN_SUBJECT
 *
 * @brief
 *   The CaseAdminSubject field is not valid in AddNOC command.
 *
 */
#define CHIP_ERROR_INVALID_ADMIN_SUBJECT                      CHIP_CORE_ERROR(0x78)

/**
 * @def CHIP_ERROR_INSUFFICIENT_PRIVILEGE
 *
 * @brief
 *   Required privilege was insufficient during an operation.
 *
 */
#define CHIP_ERROR_INSUFFICIENT_PRIVILEGE                          CHIP_CORE_ERROR(0x79)

/**
 * @def CHIP_ERROR_IM_MALFORMED_ATTRIBUTE_REPORT_IB
 *
 * @brief
 *   The Attribute Report IB is malformed: it does not contain
 *   the required elements
 */
#define CHIP_ERROR_IM_MALFORMED_ATTRIBUTE_REPORT_IB             CHIP_CORE_ERROR(0x7a)

/**
 * @def CHIP_ERROR_IM_MALFORMED_EVENT_STATUS_IB
 *
 * @brief
 *   The Event Status IB is malformed: it does not contain
 *   the required elements
 */
#define CHIP_ERROR_IM_MALFORMED_EVENT_STATUS_IB             CHIP_CORE_ERROR(0x7b)

/**
 * @def CHIP_ERROR_IM_MALFORMED_STATUS_RESPONSE_MESSAGE
 *
 * @brief
 *   The Status Response Message is malformed: it does not contain
 *   the required elements
 */
#define CHIP_ERROR_IM_MALFORMED_STATUS_RESPONSE_MESSAGE      CHIP_CORE_ERROR(0x7c)

/**
 * @def CHIP_ERROR_MESSAGE_COUNTER_EXHAUSTED
 *
 * @brief
 *   The message counter of the session is exhausted, the session should be closed.
 */
#define CHIP_ERROR_MESSAGE_COUNTER_EXHAUSTED                 CHIP_CORE_ERROR(0x7d)

/**
 *  @def CHIP_ERROR_FABRIC_EXISTS
 *
 *  @brief
 *    The fabric with the given fabric id and root public key already exists.
 *
 */
#define CHIP_ERROR_FABRIC_EXISTS                               CHIP_CORE_ERROR(0x7e)

/**
 *  @def CHIP_ERROR_KEY_NOT_FOUND_FROM_PEER
 *
 *  @brief
 *    The encryption key is not found error received from a peer node.
 *
 */
#define CHIP_ERROR_KEY_NOT_FOUND_FROM_PEER                     CHIP_CORE_ERROR(0x7f)

/**
 *  @def CHIP_ERROR_WRONG_ENCRYPTION_TYPE_FROM_PEER
 *
 *  @brief
 *    The wrong encryption type error received from a peer node.
 *
 */
#define CHIP_ERROR_WRONG_ENCRYPTION_TYPE_FROM_PEER             CHIP_CORE_ERROR(0x80)

/**
 *  @def CHIP_ERROR_UNKNOWN_KEY_TYPE_FROM_PEER
 *
 *  @brief
 *    The unknown key type error received from a peer node.
 *
 */
#define CHIP_ERROR_UNKNOWN_KEY_TYPE_FROM_PEER                  CHIP_CORE_ERROR(0x81)

/**
 *  @def CHIP_ERROR_INVALID_USE_OF_SESSION_KEY_FROM_PEER
 *
 *  @brief
 *    The invalid use of session key error received from a peer node.
 *
 */
#define CHIP_ERROR_INVALID_USE_OF_SESSION_KEY_FROM_PEER        CHIP_CORE_ERROR(0x82)

/**
 *  @def CHIP_ERROR_UNSUPPORTED_ENCRYPTION_TYPE_FROM_PEER
 *
 *  @brief
 *    An unsupported encryption type error received from a peer node.
 *
 */
#define CHIP_ERROR_UNSUPPORTED_ENCRYPTION_TYPE_FROM_PEER       CHIP_CORE_ERROR(0x83)

/**
 *  @def CHIP_ERROR_INTERNAL_KEY_ERROR_FROM_PEER
 *
 *  @brief
 *    The internal key error received from a peer node.
 *
 */
#define CHIP_ERROR_INTERNAL_KEY_ERROR_FROM_PEER                CHIP_CORE_ERROR(0x84)

/**
 *  @def CHIP_ERROR_INVALID_KEY_ID
 *
 *  @brief
 *    A key id is invalid.
 *
 */
#define CHIP_ERROR_INVALID_KEY_ID                              CHIP_CORE_ERROR(0x85)

/**
 *  @def CHIP_ERROR_INVALID_TIME
 *
 *  @brief
 *    Time has invalid value.
 *
 */
#define CHIP_ERROR_INVALID_TIME                                CHIP_CORE_ERROR(0x86)

/**
 *  @def CHIP_ERROR_LOCKING_FAILURE
 *
 *  @brief
 *    Failure to acquire or release an OS provided mutex.
 *
 */
#define CHIP_ERROR_LOCKING_FAILURE                             CHIP_CORE_ERROR(0x87)

/**
 *  @def CHIP_ERROR_UNSUPPORTED_PASSCODE_CONFIG
 *
 *  @brief
 *    A passcode encryption configuration is unsupported.
 *
 */
#define CHIP_ERROR_UNSUPPORTED_PASSCODE_CONFIG                 CHIP_CORE_ERROR(0x88)

/**
 *  @def CHIP_ERROR_PASSCODE_AUTHENTICATION_FAILED
 *
 *  @brief
 *    The CHIP passcode authentication failed.
 *
 */
#define CHIP_ERROR_PASSCODE_AUTHENTICATION_FAILED              CHIP_CORE_ERROR(0x89)

/**
 *  @def CHIP_ERROR_PASSCODE_FINGERPRINT_FAILED
 *
 *  @brief
 *    The CHIP passcode fingerprint failed.
 *
 */
#define CHIP_ERROR_PASSCODE_FINGERPRINT_FAILED                 CHIP_CORE_ERROR(0x8a)

/**
 *  @def CHIP_ERROR_SERIALIZATION_ELEMENT_NULL
 *
 *  @brief
 *      The element of the struct is null.
 *
 */
#define CHIP_ERROR_SERIALIZATION_ELEMENT_NULL                  CHIP_CORE_ERROR(0x8b)

/**
 *  @def CHIP_ERROR_WRONG_CERT_SIGNATURE_ALGORITHM
 *
 *  @brief
 *    The certificate was not signed using the required signature algorithm.
 *
 */
#define CHIP_ERROR_WRONG_CERT_SIGNATURE_ALGORITHM              CHIP_CORE_ERROR(0x8c)

/**
 *  @def CHIP_ERROR_WRONG_CHIP_SIGNATURE_ALGORITHM
 *
 *  @brief
 *    The CHIP signature was not signed using the required signature algorithm.
 *
 */
#define CHIP_ERROR_WRONG_CHIP_SIGNATURE_ALGORITHM              CHIP_CORE_ERROR(0x8d)

/**
 *  @def CHIP_ERROR_SCHEMA_MISMATCH
 *
 *  @brief
 *    A mismatch in schema was encountered.
 *
 */
#define CHIP_ERROR_SCHEMA_MISMATCH                             CHIP_CORE_ERROR(0x8e)

/**
 *  @def CHIP_ERROR_INVALID_INTEGER_VALUE
 *
 *  @brief
 *    An integer does not have the kind of value we expect.
 *
 */
#define CHIP_ERROR_INVALID_INTEGER_VALUE                       CHIP_CORE_ERROR(0x8f)

/**
 *  @def CHIP_ERROR_CASE_RECONFIG_REQUIRED
 *
 *  @brief
 *    CASE is required to reconfigure.
 *
 */
#define CHIP_ERROR_CASE_RECONFIG_REQUIRED                      CHIP_CORE_ERROR(0x90)

/**
 *  @def CHIP_ERROR_TOO_MANY_CASE_RECONFIGURATIONS
 *
 *  @brief
 *    Too many CASE reconfigurations were received.
 *
 */
#define CHIP_ERROR_TOO_MANY_CASE_RECONFIGURATIONS              CHIP_CORE_ERROR(0x91)

/**
 *  @def CHIP_ERROR_BAD_REQUEST
 *
 *  @brief
 *    The request cannot be processed or fulfilled
 *
 */
#define CHIP_ERROR_BAD_REQUEST                                 CHIP_CORE_ERROR(0x92)

/**
 *  @def CHIP_ERROR_INVALID_MESSAGE_FLAG
 *
 *  @brief
 *    One or more message flags have invalid value.
 *
 */
#define CHIP_ERROR_INVALID_MESSAGE_FLAG                        CHIP_CORE_ERROR(0x93)

/**
 *  @def CHIP_ERROR_KEY_EXPORT_RECONFIGURE_REQUIRED
 *
 *  @brief
 *    Key export protocol required to reconfigure.
 *
 */
#define CHIP_ERROR_KEY_EXPORT_RECONFIGURE_REQUIRED             CHIP_CORE_ERROR(0x94)

/**
 *  @def CHIP_ERROR_INVALID_KEY_EXPORT_CONFIGURATION
 *
 *  @brief
 *    A key export protocol configuration is invalid.
 *
 */
#define CHIP_ERROR_INVALID_KEY_EXPORT_CONFIGURATION            CHIP_CORE_ERROR(0x95)

/**
 *  @def CHIP_ERROR_NO_COMMON_KEY_EXPORT_CONFIGURATIONS
 *
 *  @brief
 *    No key export protocol configuration is in common.
 *
 */
#define CHIP_ERROR_NO_COMMON_KEY_EXPORT_CONFIGURATIONS         CHIP_CORE_ERROR(0x96)

/**
 *  @def CHIP_ERROR_NO_KEY_EXPORT_DELEGATE
 *
 *  @brief
 *    No key export delegate is set.
 *
 */
#define CHIP_ERROR_NO_KEY_EXPORT_DELEGATE                      CHIP_CORE_ERROR(0x97)

/**
 *  @def CHIP_ERROR_UNAUTHORIZED_KEY_EXPORT_REQUEST
 *
 *  @brief
 *    Unauthorized key export request.
 *
 */
#define CHIP_ERROR_UNAUTHORIZED_KEY_EXPORT_REQUEST             CHIP_CORE_ERROR(0x98)

/**
 *  @def CHIP_ERROR_UNAUTHORIZED_KEY_EXPORT_RESPONSE
 *
 *  @brief
 *    Unauthorized key export response.
 *
 */
#define CHIP_ERROR_UNAUTHORIZED_KEY_EXPORT_RESPONSE            CHIP_CORE_ERROR(0x99)

/**
 *  @def CHIP_ERROR_EXPORTED_KEY_AUTHENTICATION_FAILED
 *
 *  @brief
 *    The CHIP exported encrypted key authentication failed.
 *
 */
#define CHIP_ERROR_EXPORTED_KEY_AUTHENTICATION_FAILED          CHIP_CORE_ERROR(0x9a)

/**
 *  @def CHIP_ERROR_TOO_MANY_SHARED_SESSION_END_NODES
 *
 *  @brief
 *    The number of shared secure sessions end nodes exceeds
 *    the maximum limit.
 *
 */
#define CHIP_ERROR_TOO_MANY_SHARED_SESSION_END_NODES           CHIP_CORE_ERROR(0x9b)

/**
 * @def CHIP_ERROR_IM_MALFORMED_ATTRIBUTE_DATA_IB
 *
 * @brief
 *   The Attribute Data IB is malformed: it does not contain
 *   the required elements
 */
#define CHIP_ERROR_IM_MALFORMED_ATTRIBUTE_DATA_IB         CHIP_CORE_ERROR(0x9c)

/**
 * @def CHIP_ERROR_WRONG_CERT_TYPE
 *
 * @brief
 *   The presented certificate was of the wrong type.
 */
#define CHIP_ERROR_WRONG_CERT_TYPE                             CHIP_CORE_ERROR(0x9d)

/**
 * @def CHIP_ERROR_DEFAULT_EVENT_HANDLER_NOT_CALLED
 *
 * @brief
 *   The application's event handler failed to call the default event handler function
 *   when presented with an unknown event.
 */
#define CHIP_ERROR_DEFAULT_EVENT_HANDLER_NOT_CALLED            CHIP_CORE_ERROR(0x9e)

/**
 *  @def CHIP_ERROR_PERSISTED_STORAGE_FAILED
 *
 *  @brief
 *    Persisted storage memory read/write failure.
 *
 */
#define CHIP_ERROR_PERSISTED_STORAGE_FAILED                    CHIP_CORE_ERROR(0x9f)

/**
 *  @def CHIP_ERROR_PERSISTED_STORAGE_VALUE_NOT_FOUND
 *
 *  @brief
 *    The specific value is not found in the persisted storage.
 *
 */
#define CHIP_ERROR_PERSISTED_STORAGE_VALUE_NOT_FOUND           CHIP_CORE_ERROR(0xa0)

/**
 * @def CHIP_ERROR_IM_FABRIC_DELETED
 *
 * @brief
 *   The fabric is deleted, and the corresponding IM resources are released
 */
#define CHIP_ERROR_IM_FABRIC_DELETED                            CHIP_CORE_ERROR(0xa1)

/**
 *  @def CHIP_ERROR_PROFILE_STRING_CONTEXT_NOT_REGISTERED
 *
 *  @brief
 *    The specified profile string support context is not registered.
 *
 */
#define CHIP_ERROR_PROFILE_STRING_CONTEXT_NOT_REGISTERED       CHIP_CORE_ERROR(0xa2)

/**
 *  @def CHIP_ERROR_INCOMPATIBLE_SCHEMA_VERSION
 *
 *  @brief
 *    Encountered a mismatch in compatibility w.r.t to IDL schema version
 */
#define CHIP_ERROR_INCOMPATIBLE_SCHEMA_VERSION                 CHIP_CORE_ERROR(0xa3)

/**
 *  @def CHIP_ERROR_ACCESS_DENIED
 *
 *  @brief
 *    The CHIP message is not granted access for further processing.
 */
#define CHIP_ERROR_ACCESS_DENIED                               CHIP_CORE_ERROR(0xa5)

/**
 *  @def CHIP_ERROR_UNKNOWN_RESOURCE_ID
 *
 *  @brief
 *    Unknown resource ID
 *
 */
#define CHIP_ERROR_UNKNOWN_RESOURCE_ID                         CHIP_CORE_ERROR(0xa6)

/**
 * @def CHIP_ERROR_VERSION_MISMATCH
 *
 * @brief
 *   The conditional update of a trait instance path has failed
 *   because the local changes are based on an obsolete version of the
 *   data.
 */
#define CHIP_ERROR_VERSION_MISMATCH                            CHIP_CORE_ERROR(0xa7)

/**
 *  @def CHIP_ERROR_UNSUPPORTED_THREAD_NETWORK_CREATE
 *
 *  @brief
 *    Device doesn't support standalone Thread network creation.
 *    On some legacy devices new Thread network can only be created
 *    together with CHIP Fabric using CrateFabric() message.
 *
 */
#define CHIP_ERROR_UNSUPPORTED_THREAD_NETWORK_CREATE           CHIP_CORE_ERROR(0xa8)

/**
 *  @def CHIP_ERROR_INCONSISTENT_CONDITIONALITY
 *
 *  @brief
 *    A TraitPath was declared updated with a conditionality that
 *    does not match that of other TraitPaths already updated in the
 *    same Trait Instance.
 *
 */
#define CHIP_ERROR_INCONSISTENT_CONDITIONALITY                 CHIP_CORE_ERROR(0xa9)

/**
 *  @def CHIP_ERROR_LOCAL_DATA_INCONSISTENT
 *
 *  @brief
 *    The local data does not match any known version of the
 *    Trait Instance and cannot support the operation requested.
 *
 */
#define CHIP_ERROR_LOCAL_DATA_INCONSISTENT                     CHIP_CORE_ERROR(0xaa)

/**
 * @def CHIP_EVENT_ID_FOUND
 *
 * @brief
 *   Event ID matching the criteria was found
 */
#define CHIP_ERROR_EVENT_ID_FOUND                              CHIP_CORE_ERROR(0xab)
#define CHIP_EVENT_ID_FOUND CHIP_ERROR_EVENT_ID_FOUND

/**
 * @def CHIP_ERROR_INTERNAL
 *
 * @brief
 *   Internal error
 */
#define CHIP_ERROR_INTERNAL                                    CHIP_CORE_ERROR(0xac)

/**
 * @def CHIP_ERROR_OPEN_FAILED
 *
 * @brief
 *   Open file failed
 */
#define CHIP_ERROR_OPEN_FAILED                                 CHIP_CORE_ERROR(0xad)

/**
 * @def CHIP_ERROR_READ_FAILED
 *
 * @brief
 *   Read from file failed
 */
#define CHIP_ERROR_READ_FAILED                                 CHIP_CORE_ERROR(0xae)

/**
 * @def CHIP_ERROR_WRITE_FAILED
 *
 * @brief
 *   Write to file failed
 */
#define CHIP_ERROR_WRITE_FAILED                                CHIP_CORE_ERROR(0xaf)

/**
 * @def CHIP_ERROR_DECODE_FAILED
 *
 * @brief
 *   Decoding failed
 */
#define CHIP_ERROR_DECODE_FAILED                               CHIP_CORE_ERROR(0xb0)

/**
 *  @def CHIP_ERROR_SESSION_KEY_SUSPENDED
 *
 *  @brief
 *    Use of the identified session key is suspended.
 *
 */
#define CHIP_ERROR_SESSION_KEY_SUSPENDED                       CHIP_CORE_ERROR(0xb1)

/**
 *  @def CHIP_ERROR_UNSUPPORTED_WIRELESS_REGULATORY_DOMAIN
 *
 *  @brief
 *    The specified wireless regulatory domain is unsupported.
 *
 */
#define CHIP_ERROR_UNSUPPORTED_WIRELESS_REGULATORY_DOMAIN      CHIP_CORE_ERROR(0xb2)

/**
 *  @def CHIP_ERROR_UNSUPPORTED_WIRELESS_OPERATING_LOCATION
 *
 *  @brief
 *    The specified wireless operating location is unsupported.
 *
 */
#define CHIP_ERROR_UNSUPPORTED_WIRELESS_OPERATING_LOCATION     CHIP_CORE_ERROR(0xb3)

/**
 *  @def CHIP_ERROR_MDNS_COLLISION
 *
 *  @brief
 *    The registered service name has collision on the LAN.
 *
 */
#define CHIP_ERROR_MDNS_COLLISION                             CHIP_CORE_ERROR(0xb4)

/**
 * @def CHIP_ERROR_IM_MALFORMED_ATTRIBUTE_PATH_IB
 *
 * @brief
 *   The Attribute path IB is malformed: it does not contain
 *   the required path
 */
#define CHIP_ERROR_IM_MALFORMED_ATTRIBUTE_PATH_IB                CHIP_CORE_ERROR(0xb5)

/**
 * @def CHIP_ERROR_IM_MALFORMED_EVENT_PATH_IB
 *
 * @brief
 *   The Event Path IB is malformed: it does not contain
 *   the required elements
 */
#define CHIP_ERROR_IM_MALFORMED_EVENT_PATH_IB                     CHIP_CORE_ERROR(0xb6)

/**
 * @def CHIP_ERROR_IM_MALFORMED_COMMAND_PATH_IB
 *
 * @brief
 *   The Command Path IB is malformed: it does not contain
 *   the required elements
 */
#define CHIP_ERROR_IM_MALFORMED_COMMAND_PATH_IB                  CHIP_CORE_ERROR(0xb7)

/**
 * @def CHIP_ERROR_IM_MALFORMED_ATTRIBUTE_STATUS_IB
 *
 * @brief
 *   The Attribute Status IB is malformed: it does not contain
 *   the required elements
 */
#define CHIP_ERROR_IM_MALFORMED_ATTRIBUTE_STATUS_IB       CHIP_CORE_ERROR(0xb8)

/**
 * @def CHIP_ERROR_IM_MALFORMED_COMMAND_DATA_IB
 *
 * @brief
 *   The Command Data IB is malformed: it does not contain
 *   the required elements
 */
#define CHIP_ERROR_IM_MALFORMED_COMMAND_DATA_IB           CHIP_CORE_ERROR(0xb9)

/**
 * @def CHIP_ERROR_IM_MALFORMED_EVENT_DATA_IB
 *
 * @brief
 *   The Event Data IB is malformed: it does not contain
 *   the required elements
 */
#define CHIP_ERROR_IM_MALFORMED_EVENT_DATA_IB             CHIP_CORE_ERROR(0xba)

/**
 * @def CHIP_ERROR_IM_MALFORMED_STATUS_IB
 *
 * @brief
 *   The Attribute Data IB is malformed: it does not contain
 *   the required elements
 */
#define CHIP_ERROR_IM_MALFORMED_STATUS_IB                    CHIP_CORE_ERROR(0xbb)

/**
 * @def CHIP_ERROR_PEER_NODE_NOT_FOUND
 *
 * @brief
 *   Unable to find the peer node
 */
#define CHIP_ERROR_PEER_NODE_NOT_FOUND                         CHIP_CORE_ERROR(0xbc)

/**
 * @def CHIP_ERROR_HSM
 *
 * @brief
 *   Error in Hardware security module. Used for software fallback option.
 */
#define CHIP_ERROR_HSM                                         CHIP_CORE_ERROR(0xbd)

/**
 * @def CHIP_ERROR_INTERMEDIATE_CA_NOT_REQUIRED
 *
 * @brief
 *   The commissioner doesn't require an intermediate CA to sign the operational certificates.
 */
#define CHIP_ERROR_INTERMEDIATE_CA_NOT_REQUIRED                CHIP_CORE_ERROR(0xbe)

/**
 *  @def CHIP_ERROR_REAL_TIME_NOT_SYNCED
 *
 *  @brief
 *      The system's real time clock is not synchronized to an accurate time source.
 */
#define CHIP_ERROR_REAL_TIME_NOT_SYNCED                        CHIP_CORE_ERROR(0xbf)

/**
 *  @def CHIP_ERROR_UNEXPECTED_EVENT
 *
 *  @brief
 *      An unexpected event was encountered.
 */
#define CHIP_ERROR_UNEXPECTED_EVENT                            CHIP_CORE_ERROR(0xc0)

/**
 *  @def CHIP_ERROR_ENDPOINT_POOL_FULL
 *
 *  @brief
 *    No endpoint pool entry is available.
 *
 */
#define CHIP_ERROR_ENDPOINT_POOL_FULL                          CHIP_CORE_ERROR(0xc1)

/**
 *  @def CHIP_ERROR_INBOUND_MESSAGE_TOO_BIG
 *
 *  @brief
 *    More inbound message data is pending than available buffer space available to copy it.
 *
 */
#define CHIP_ERROR_INBOUND_MESSAGE_TOO_BIG                     CHIP_CORE_ERROR(0xc2)

/**
 *  @def CHIP_ERROR_OUTBOUND_MESSAGE_TOO_BIG
 *
 *  @brief
 *    More outbound message data is pending than available buffer space available to copy it.
 *
 */
#define CHIP_ERROR_OUTBOUND_MESSAGE_TOO_BIG                    CHIP_CORE_ERROR(0xc3)

/**
 * @def CHIP_ERROR_DUPLICATE_MESSAGE_RECEIVED
 *
 * @brief
 *   The received message is a duplicate of a previously received message.
 */
#define CHIP_ERROR_DUPLICATE_MESSAGE_RECEIVED                  CHIP_CORE_ERROR(0xc4)

/**
 * @def CHIP_ERROR_INVALID_PUBLIC_KEY
 *
 * @brief
 *   The received public key doesn't match locally generated key.
 */
#define CHIP_ERROR_INVALID_PUBLIC_KEY                          CHIP_CORE_ERROR(0xc5)

/**
 * @def CHIP_ERROR_FABRIC_MISMATCH_ON_ICA
 *
 * @brief
 *   The fabric ID in ICA certificate doesn't match the one in NOC.
 */
#define CHIP_ERROR_FABRIC_MISMATCH_ON_ICA                      CHIP_CORE_ERROR(0xc6)

/**
 * @def CHIP_ERROR_MESSAGE_COUNTER_OUT_OF_WINDOW
 *
 * @brief
 *   The message counter of the received message is out of receiving window
 */
#define CHIP_ERROR_MESSAGE_COUNTER_OUT_OF_WINDOW               CHIP_CORE_ERROR(0xc7)

/**
 * @def CHIP_ERROR_REBOOT_SIGNAL_RECEIVED
 *
 * @brief
 *   Termination signal is received
 */
#define CHIP_ERROR_REBOOT_SIGNAL_RECEIVED                      CHIP_CORE_ERROR(0xc8)

/**
 * @def CHIP_ERROR_NO_SHARED_TRUSTED_ROOT
 *
 * @brief
 *   The CASE session could not be established as peer's credentials do not have
 *   a common root of trust.
 */
#define CHIP_ERROR_NO_SHARED_TRUSTED_ROOT                      CHIP_CORE_ERROR(0xc9)

/*
 * @def CHIP_ERROR_IM_STATUS_CODE_RECEIVED
 *
 * @brief
 *   Indicates an IM status code was received. Usually accompanied with
 *   the actual IM status code.
 */
#define CHIP_ERROR_IM_STATUS_CODE_RECEIVED                     CHIP_CORE_ERROR(0xca)

/**
 * @def CHIP_ERROR_IM_MALFORMED_COMMAND_STATUS_IB
 *
 * @brief
 *   The Command Status IB is malformed: it does not contain
 *   the required elements
 */
#define CHIP_ERROR_IM_MALFORMED_COMMAND_STATUS_IB         CHIP_CORE_ERROR(0xcb)

/**
 * @def CHIP_ERROR_IM_MALFORMED_INVOKE_RESPONSE_IB
 *
 * @brief
 *   The Invoke Response IB is malformed: it does not contain
 *   the required elements
 */
#define CHIP_ERROR_IM_MALFORMED_INVOKE_RESPONSE_IB         CHIP_CORE_ERROR(0xcc)

/**
 * @def CHIP_ERROR_IM_MALFORMED_INVOKE_REQUEST_MESSAGE
 *
 * @brief
 *   The Invoke Request Message is malformed: it does not contain
 *   the required elements
 */
#define CHIP_ERROR_IM_MALFORMED_INVOKE_REQUEST_MESSAGE    CHIP_CORE_ERROR(0xcd)

/**
 * @def CHIP_ERROR_IM_MALFORMED_INVOKE_RESPONSE_MESSAGE
 *
 * @brief
 *   The Invoke Response Message is malformed: it does not contain
 *   the required elements
 */
#define CHIP_ERROR_IM_MALFORMED_INVOKE_RESPONSE_MESSAGE    CHIP_CORE_ERROR(0xce)

/**
 * @def CHIP_ERROR_IM_MALFORMED_ATTRIBUTE_REPORT_MESSAGE
 *
 * @brief
 *   The Attribute Response Message is malformed: it does not contain
 *   the required elements
 */
#define CHIP_ERROR_IM_MALFORMED_ATTRIBUTE_REPORT_MESSAGE    CHIP_CORE_ERROR(0xcf)

/**
 * @def CHIP_ERROR_IM_MALFORMED_WRITE_REQUEST_MESSAGE
 *
 * @brief
 *   The Write Request Message is malformed: it does not contain
 *   the required elements
 */
#define CHIP_ERROR_IM_MALFORMED_WRITE_REQUEST_MESSAGE    CHIP_CORE_ERROR(0xd0)

/**
 * @def CHIP_ERROR_IM_MALFORMED_EVENT_FILTER_IB
 *
 * @brief
 *   The Event Filter IB is malformed: it does not contain
 *   the required elements
 */
#define CHIP_ERROR_IM_MALFORMED_EVENT_FILTER_IB    CHIP_CORE_ERROR(0xd1)

/**
 * @def CHIP_ERROR_IM_MALFORMED_READ_REQUEST_MESSAGE
 *
 * @brief
 *   The Read Request Message is malformed: it does not contain
 *   the required elements
 */
#define CHIP_ERROR_IM_MALFORMED_READ_REQUEST_MESSAGE    CHIP_CORE_ERROR(0xd2)

/**
 * @def CHIP_ERROR_IM_MALFORMED_SUBSCRIBE_REQUEST_MESSAGE
 *
 * @brief
 *   The Subscribe Request Message is malformed: it does not contain
 *   the required elements
 */
#define CHIP_ERROR_IM_MALFORMED_SUBSCRIBE_REQUEST_MESSAGE    CHIP_CORE_ERROR(0xd3)

/**
 * @def CHIP_ERROR_IM_MALFORMED_SUBSCRIBE_RESPONSE_MESSAGE
 *
 * @brief
 *   The Subscribe Response Message is malformed: it does not contain
 *   the required elements
 */
#define CHIP_ERROR_IM_MALFORMED_SUBSCRIBE_RESPONSE_MESSAGE    CHIP_CORE_ERROR(0xd4)

/**
 * @def CHIP_ERROR_IM_MALFORMED_EVENT_REPORT_IB
 *
 * @brief
 *   The Event Report IB is malformed: it does not contain
 *   the required elements
 */
#define CHIP_ERROR_IM_MALFORMED_EVENT_REPORT_IB             CHIP_CORE_ERROR(0xd5)

/**
 * @def CHIP_ERROR_IM_MALFORMED_CLUSTER_PATH_IB
 *
 * @brief
 *   The Cluster Path IB is malformed: it does not contain
 *   the required elements
 */
#define CHIP_ERROR_IM_MALFORMED_CLUSTER_PATH_IB                CHIP_CORE_ERROR(0xd6)

/**
 * @def CHIP_ERROR_IM_MALFORMED_DATA_VERSION_FILTER_IB
 *
 * @brief
 *   The Data Version Filter IB is malformed: it does not contain
 *   the required elements
 */
#define CHIP_ERROR_IM_MALFORMED_DATA_VERSION_FILTER_IB             CHIP_CORE_ERROR(0xd7)

/**
 * @def CHIP_ERROR_NOT_FOUND
 *
 * @brief
 *   The item referenced in the function call was not found
 */
#define CHIP_ERROR_NOT_FOUND                                       CHIP_CORE_ERROR(0xd8)

/**
 * @def CHIP_ERROR_IM_MALFORMED_TIMED_REQUEST_MESSAGE
 *
 * @brief
 *   The Timed Request Message is malformed: it does not contain
 *   the required elements
 */
#define CHIP_ERROR_IM_MALFORMED_TIMED_REQUEST_MESSAGE                    CHIP_CORE_ERROR(0xd9)

/**
 * @def CHIP_ERROR_INVALID_FILE_IDENTIFIER
 *
 * @brief
 *   The file identifier, encoded in the first few bytes of a processed file,
 *   has unexpected value.
 */
#define CHIP_ERROR_INVALID_FILE_IDENTIFIER                     CHIP_CORE_ERROR(0xda)

/**
 * @def CHIP_ERROR_BUSY
 *
 * @brief
 *   The Resource is busy and cannot process the request. Trying again might work.
 */
#define CHIP_ERROR_BUSY                                        CHIP_CORE_ERROR(0xdb)

/**
  * @def CHIP_ERROR_MAX_RETRY_EXCEEDED
  *
  * @brief
  *   The maximum retry limit has been exceeded.
  */
 #define CHIP_ERROR_MAX_RETRY_EXCEEDED                         CHIP_CORE_ERROR(0xdc)

 /**
  * @def CHIP_ERROR_PROVIDER_LIST_EXHAUSTED
  *
  * @brief
  *   The provider list has been exhausted.
  */
 #define CHIP_ERROR_PROVIDER_LIST_EXHAUSTED                    CHIP_CORE_ERROR(0xdd)

/*
 * @def CHIP_ERROR_ANOTHER_COMMISSIONING_IN_PROGRESS
 *
 * @brief
 *   Indicates that the commissioning window on the device is already open, and another
 *   commissioning is in progress
 */
#define CHIP_ERROR_ANOTHER_COMMISSIONING_IN_PROGRESS           CHIP_CORE_ERROR(0xde)

/**
 * @def CHIP_ERROR_INVALID_SCHEME_PREFIX
 *
 * @brief
 *   The scheme field contains an invalid prefix
 */
#define CHIP_ERROR_INVALID_SCHEME_PREFIX                      CHIP_CORE_ERROR(0xdf)

/**
 * @def CHIP_ERROR_MISSING_URI_SEPARATOR
 *
 * @brief
 *   The URI separator is missing
 */
#define CHIP_ERROR_MISSING_URI_SEPARATOR                      CHIP_CORE_ERROR(0xe0)

// clang-format on

// !!!!! IMPORTANT !!!!!  If you add new CHIP errors, please update the translation
// of error codes to strings in CHIPError.cpp, and add them to kTestElements[]
// in core/tests/TestCHIPErrorStr.cpp

namespace chip {

extern void RegisterCHIPLayerErrorFormatter();
extern bool FormatCHIPError(char * buf, uint16_t bufSize, CHIP_ERROR err);

} // namespace chip