Typescript interfaces versus classes, which one to use?

We are talking about interfaces and classes in Typescript which is a typed superset of Javascript. Here is my advice on deciding whether to use an interface or a class:

Interfaces are like contract for data containers. They tell what properties an object has and allows the compiler to enforce them. They tell you what an object is but refrain from how it should behave. Use interfaces when you have objects that carry data around. Note that this data could be function signatures too but the interface itself does not implement them. It just says that a function should exist.

Classes also contain data but act on that data by implementing instance specific functions with default values. These behaviours can be extended, inherited and overwritten by subclasses just like in other languages. Use classes when you have entities with data dependent encapsulated actions.

Here is an example of a User object within an web application using interfaces and classes, refer to the Typescript cheat sheets for a quick reference:

// Just defines what data is stored
interface User {
    id: string;
    name: string;
    lastLogin: Date;
}

// Construct an instance using a direct object
const user: User = {...};

// ---------------------------

// Additionally adds functionality like default values
// constructor and instance specific actions
class User {
    id: string;
    name: string;
    readonly lastLogin = new Date();

    constructor(id: string) {
        this.id = id;
        this.name = someFetchUserFunction(id).name;
        console.log(name, "has logged in.");
    }

    async signOut() {
        await backendLogoutUser(this.id);
        console.log(name, "has logged out.");
    }
}

// Create an instance using new
const user = new User(userId);

I would say this is just a quick guide and it would depend on the application specifics. It may well be reasonable to create a class to contain data and extend it later on with more functionality. Perhaps as a final note it is important to mention that interfaces are ephemeral and get removed when transpiling to Javascript. So only the Typescript compiler really worries about interfaces which may be sufficient if your code and the libraries you use are in Typescript.