C++ custom exception handling using std::error_category and std::system_error
Here are some things that may help you improve your code.
Separate interface from implementation
The interface goes into a header file and the implementation (that is, everything that actually emits bytes including all functions and data) should be in a separate .cpp file.  The reason is that you might have multiple source files including the .h file but only one instance of the corresponding .cpp file.  In other words, split your existing CustomException namespace into into a .h file and a .cpp file.
Correctly override functions
The code currently contains this as part of class ErrorC:
bool equivalent(int const code, std::error_condition const &amp;condition) const noexcept
override {
    (void) code;
    (void) condition;
    return false;
}

This is not right for several reasons.  First, the standard says that this should return true if the error is equivalent, but this does not do that.  Instead, I'd write:
return default_error_condition(code) == condition; 

Better still, omit it, since this is not a pure virtual method in std::error_category.
Don't create pointless classes
The CustomException class is doing very little here and I would strongly recommend omitting it and just deriving directly from std::error_category.  See C.120 for further guidance.
Don't use all caps for enum name
ALL CAPS have been traditionally used for macros.  To avoid misleading the reader, don't use them if it's not a macro.  See ES.9.
Fix the spelling
If the machine has &quot;breaks&quot; it is broken.  If it has &quot;brakes&quot; it has the ability to slow down.  These homonyms are easily confused, but it's important to make sure you don't have spelling errors, especially in interface code, so that you don't confuse users of your code.
Consider combining error codes
It appears that you are intending to have non-overlapping and unique error codes for each type of error, but that is not assured because the errors are in three different enum classes.  I'd suggest combining them.
Reconsider your classes
If the error codes were combined, as suggested above, then the differentiation among them would be by the error code.  Having different classes doing exactly the same thing makes little sense to me.  I'd suggest a single error class derived from std::error_category would be sufficient.