#include <iostream>

using namespace std;

template<int size>
class A 
{
};

template<int size>
A<size> operator&(const A<size>&, const A<size>&);

enum class En : int { a, b, c };

int main() {
    
    En en1 = En::a;
    En en2 = En::b;
    En en3 = En::a & En::b;
    
    return 0;
}

using A0 = A<0>;

A0 a =...
A0 b =...
A0 c = a + b

template<int size>
class A 
{
public:
    A<size> operator&(const A<size>&);
};

int main() {
    using A0 = A<0>;
    A0 a;
    A0 b;
    A0 c = a & b;

    return 0;
}

prog.cc:19:20: error: invalid operands to binary expression ('En' and 'En')
    En en3 = En::a & En::b;
             ~~~~~ ^ ~~~~~
/opt/wandbox/clang-head/include/c++/v1/bitset:1061:1: note: candidate template ignored: could not match 'bitset<_Size>' against 'En'
operator&(const bitset<_Size>& __x, const bitset<_Size>& __y) _NOEXCEPT
^
prog.cc:11:9: note: candidate template ignored: could not match 'A<size>' against 'En'
A<size> operator&(const A<size>&, const A<size>&);
        ^
1 error generated.

En operator&(En e1, En e2);

namespace impl
{
    En operator&(const En&, const En&);
}

using impl;

10.3.4.3
A using-directive does not add any members to the declarative region in which it appears.

#include <iostream>

using namespace std;

namespace impl
{
    template<typename Enum, class = decltype(enable_bitmask_operators(*(Enum*)nullptr))>
    inline Enum operator&(Enum left, Enum right)
    {
        using Underlying = std::underlying_type_t<Enum>;
        return static_cast<Enum>(static_cast<Underlying>(left) & static_cast<Underlying>(right));
    }
}

namespace my
{
using namespace impl;

enum class Enum : int { a, b, c };
void enable_bitmask_operators(Enum);

template<int size>
class A 
{
};

//template<int size>                      // Если это раскомментраить то то перестает компилироваться
//A<size> operator&(const A<size>&, const A<size>&);    // Если это раскомментраить то то перестает компилироваться

void func()
{
    Enum en1 = Enum::a;
    Enum en2 = Enum::b;
    Enum en3 = Enum::a & Enum::b;
}

} // namespace my

namespace my2
{
    using namespace impl;

    my::Enum en3 = my::Enum::a & my::Enum::b;
} // namespace my2

int main() 
{    
    return 0;
}

V>#include <iostream>

V>using namespace std;

V>namespace impl
V>{
V>    template<typename Enum, class = decltype(enable_bitmask_operators(*(Enum*)nullptr))>
V>    inline Enum operator&(Enum left, Enum right)
V>    {
V>        using Underlying = std::underlying_type_t<Enum>;
V>        return static_cast<Enum>(static_cast<Underlying>(left) & static_cast<Underlying>(right));
V>    }
V>}

V>namespace my
V>{
V>using namespace impl;

V>enum class Enum : int { a, b, c };
V>void enable_bitmask_operators(Enum);

V>template<int size>
V>class A 
V>{
V>};

V>//template<int size>                      // Если это раскомментраить то то перестает компилироваться
V>//A<size> operator&(const A<size>&, const A<size>&);    // Если это раскомментраить то то перестает компилироваться

V>void func()
V>{
V>    Enum en1 = Enum::a;
V>    Enum en2 = Enum::b;
V>    Enum en3 = Enum::a & Enum::b;
V>}

V>} // namespace my

V>namespace my2
V>{
V>    using namespace impl;

V>    my::Enum en3 = my::Enum::a & my::Enum::b;
V>} // namespace my2

V>int main() 
V>{    
V>    return 0;
V>}
V>

   using impl::operator&;

V>Действительно работает, спасибо большое . Тогда, для общего развития, можно пояснить два вопроса:

namespace ns1
{

void foo(int){}

namespace ns2
{

void foo(){}

void test()
{
    //using ns1::foo;
    foo(42); // error: too many arguments to function ‘void ns1::ns2::foo()’
}

} // namespace ns2
} // namespace ns1