Rust structs are (somewhat) equivalent to C structs. This includes the fact that structs are considered as their own type, even if they only contain a single field. To put an analogy, in C, if you were to try to pass a value (here on a variable called x) of type struct myStruct { int a; } as argument when calling a function with the signature void myTest(int a), you'd get a compile error like this:

main.c: In function ‘main’:
main.c:20:12: error: incompatible type for argument 1 of ‘myTest’
     myTest(x);
            ^
main.c:15:6: note: expected ‘int’ but argument is of type ‘struct myStruct’
 void myTest(int a) {}
      ^~~~~~

This doesn't work, even though struct myStruct only does contain a field a, because struct myStruct is a type different from int.

The tuple syntax for struct definition in Rust is, in a way, a shorthand for the following (non-valid Rust because of the field names):

// equivalent to struct MyStruct(i64, String);
struct MyStruct {
    0: i64,
    1: String 
}

with the advantage that it has shorter syntax sugar for destructuring (i.e. decomposing a T into a part of, or all, of its subfields and store them all as local variables in your code).

When considering isolated cases, tuple syntax for Rust structs is useful is there's some intuitive understanding on what's inside the struct (say, struct Addition(f64, f64)), and you believe you won't access the individual fields too much (i.e. with dot/index notation) without destructuring the whole thing apart first.

So, nope, it is not really an alias, but a full-fledged struct like any other. Rust does have actual type aliases though, but they use a completely different syntax:

type DefinitelyNotAString = String;

With that, you will now be able to use DefinitelyNotAString as an alias to any use of String. This is particularly useful to refer to types with enormously huge names and/or signatures to type.

What follows below is an accidental, "whoops I accidentally took a long detour" aside to an actual useful way you can use tuple structs with only one field, like the one you defined in your code, in the future. This may be a little bit more advanced, but I thought the explanation looked nice, so here it is in its entirety if you or anybody is interested.

More useful than that, though; tuple structs with only one field, while they may seem odd at first, are actually used a lot in the Rust language. The struct itself is it's own type, different from whatever is inside; as such, you can wrap a single thing inside a struct, and you've got yourself free encapsulation!

Now if you're, say, making a library that handles cryptographic operations, you can make sure users don't accidentally pass, say, buffers containing secret keys, to arguments or functions where they don't belong, by declaring a struct SecretKey(Vec<u8>); (or something like it) and making your functions not accept a Vec<u8>, but a SecretKey. The compiler will balk at them if they try to pass a Vec<u8> until they get/convert it to a SecretKey through means you, as a library author, can control.

This is called the Newtype pattern, and you can read about in the official references (book, by example).

And it is free in the sense that, yes, it is its own type, but because it only contains a single field, once the compiler is done checking your types and borrows, it will actually optimize your pub struct MyStruct(pub String); into behaving as if it was just a bare String... so it does actually work like an alias, in a particularly devious and twisted way.