This is the only solution I can think of (Thanks to the comment of @Fahd Lihidheb)

type NotEmpty<T> = keyof T extends never ? never : T

function createTest<T extends {[key: string]: any}>(test: NotEmpty<T>): T {
  return test
}

const obj = createTest({})                            // error
const anotherObj = createTest({ something: "thing" }) // works

I don't think it is possible with just a type definition. We have to use a factory method instead so we can infer the type of T and check if any keys exist.

Caveats

Here are two worthy caveats from the comments.

Either you want user to be of type User | {} or Partial<User>, or you need to redefine the User type to allow an empty object. Right now, the compiler is correctly telling you that user is not a User. – jcalz

I don't think this should be considered a proper answer because it creates an inconsistent instance of the type, undermining the whole purpose of TypeScript. In this example, the property Username is left undefined, while the type annotation is saying it can't be undefined. – Ian Liu Rodrigues

Answer

One of the design goals of TypeScript is to "strike a balance between correctness and productivity." If it will be productive for you to do this, use Type Assertions to create empty objects for typed variables.

type User = {
    Username: string;
    Email: string;
}

const user01 = {} as User;
const user02 = <User>{};

user01.Email = "[email protected]";

Here is a working example for you.

Use Object.keys(obj).length to check if it is empty.

Output : 3

Source: Object.keys()