C++ template specialization - avoid redefinition

I want to have a generic function (or method) that accepts arguments of different types. If the provided type has 'one' method, the function should use it. If it has 'two' method, the function should use it instead.

Here's the invalid code:

#include <iostream>

template<typename Type> void func(Type t)
{
    t.one();
}

template<typename Type> void func(Type t) // redefinition!
{
    t.two();
}

class One
{
    void one(void) const
    {
        std::cout << "one" << std::endl;
    }
};

class Two
{
    void two(void) const
    {
        std::cout << "two" << std::endl;
    }
};

int main(int argc, char* argv[])
{
    func(One()); // should print "one"
    func(Two()); // should print "two"
    return 0;
}

Is it possible to achieve using SFINAE? Is it possible to achieve using type_traits?

Clarification:

I would be more happy if this would be possible using SFINAE. The best-case scenario is: use first template, if it fails use the second one.

Checking for method existence is only an example. What I really want is also checking for compatibility with other classes.

The task could be rephrased:

1. If the class supports the first interface, use it.
2. If the first interface fails, use the second interface.
3. If both fail, report an error.