using typedef in template instantiation and extern template declaration

There are two cases where typedef confuses me when it comes to extern template declaration and explicit template instantiation.

To illustrate the two see below 2 example code snippets.

Consider following example (Case 1):

// suppose following code in some cpp file    
template <typename T>
    struct example
{
    T value;
};

// valid typedefs
typedef example<int> int_example;
typedef example<std::string> string_example;

// explicit instantiation using above typedefs
template class int_example; // -> compile time error
template class string_example; // -> compile time error

// instead we need to use type names
template class example<int>; // -> OK
template class example<std::string>; // -> OK

// QUESTION 1: Why does this work however? is this valid code?
typedef std::string type_string;
template class example<type_string>;

Why does the template class example<type_string> work with typedef ? and why is it valid while template class string_example is not?

Consider following example (Case 2):

// suppose following code is in some header file
template <typename T>
struct example
{
    T value;
};

// valid typedefs
typedef std::string type_string;
typedef example<type_string> string_example;

// Explicit instantiation declaration
// QUESTION 2: Is this valid code? if not why not?
extern template string_example; // -> at least this compiles, but is it OK?

As questioned in the comment above, is it valid to use typedef in extern template declaration, like in the example above, and why does this compile unlike the Case1 where it does not.

I've read about similar cases but none gives the detailed answer to above 2 questions. detailed elaboration is very much appreciated!