This is the expected behavior (docs). Hopefully this sample will clarify it:

let someObj = new MyClass();
// someObj will be of the "MyClass" type.

let anyObject : any;
// since anyObject is typed as any, it can hold any type:
anyObject = 1;
anyObject = "foo";
// including your class:
anyObject = someObj;

// so, if it can hold anything, it's expected that we can assign our custom classes to it:
someObj = anyObj;

But how can typescript accept to assign any object to class object?

That's the fun with the any type. Typescript can't know if your any-typed variable holds an instance of your object or not. It's anything, so it could be an instance of your object.

If you look at the official documentation, it clearly says that with "any" all compile time checks are ignored.

Relevant snippet from the docs:

We may need to describe the type of variables that we do not know when we are writing an application. These values may come from dynamic content, e.g. from the user or a 3rd party library. In these cases, we want to opt-out of type-checking and let the values pass through compile-time checks. To do so, we label these with the any type:

let notSure: any = 4;
notSure = "maybe a string instead";
notSure = false; // okay, definitely a boolean

The any type is a powerful way to work with existing JavaScript, allowing you to gradually opt-in and opt-out of type-checking during compilation. You might expect Object to play a similar role, as it does in other languages. But variables of type Object only allow you to assign any value to them - you can’t call arbitrary methods on them, even ones that actually exist:

Should you choose to use another type e.g. number or string the compile time checks kick in and you know that its not right.

let notSure: any = 4;
notSure.ifItExists(); // okay, ifItExists might exist at runtime
notSure.toFixed(); // okay, toFixed exists (but the compiler doesn't check)

let prettySure: Object = 4;
prettySure.toFixed(); // Error: Property 'toFixed' doesn't exist on type 'Object'.

The any type is also handy if you know some part of the type, but perhaps not all of it. For example, you may have an array but the array has a mix of different types:

let list: any[] = [1, true, "free"];

list[1] = 100;

TypeScript needs a different way of thinking from a traditional statically type language. In languages like C# or Java the compilar gives a type error unless the programer has provided enough information to make clear to the compiler it should not give a type error. In Typescript the compiler only gives a type error if the programer has provided enough information for the compiler to know the types are not valid.

The use of Any takes information away from the compiler.

Typescript was created to allow the incremental addition of type information with as many bugs in the program being found at compile as the type information allows. It can be thought of as a "super lint" that takes advantage of any type information that is provided.

Over the years Typescript has moved closer to what people (like me) who are used to strict compile time type checked languages expect, but it great stenth is that it still, "fits in" well with Javascript.