An empty object can be written as Record<string,never>, so effectively your type for user is either an empty object or a User

const user : User | Record<string, never> = {};

Really depends on what you're trying to do. Types are documentation in typescript, so you want to show intention about how this thing is supposed to be used when you're creating the type.

Option 1: If Users might have some but not all of the attributes during their lifetime

Make all attributes optional

type User = {
  attr0?: number
  attr1?: string
}

Option 2: If variables containing Users may begin null

type User = {
...
}
let u1: User = null;

Though, really, here if the point is to declare the User object before it can be known what will be assigned to it, you probably want to do let u1:User without any assignment.

Option 3: What you probably want

Really, the premise of typescript is to make sure that you are conforming to the mental model you outline in types in order to avoid making mistakes. If you want to add things to an object one-by-one, this is a habit that TypeScript is trying to get you not to do.

More likely, you want to make some local variables, then assign to the User-containing variable when it's ready to be a full-on User. That way you'll never be left with a partially-formed User. Those things are gross.

let attr1: number = ...
let attr2: string = ...
let user1: User = {
  attr1: attr1,
  attr2: attr2
}

Don't use {} as a type. {} actually means "any non-nullish value".

• If you want a type meaning "empty object", you probably want Record<string, never> instead.
• If you want a type meaning "any object", you probably want object instead.
• If you want a type meaning "any value", you probably want unknown instead.

Note that using const user = {} as UserType just provides intellisense but at runtime user is empty object {} and has no property inside. that means user.Email will give undefined instead of ""

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

So, use class with constructor for actually creating objects with default properties.

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

class User implements UserType {
  constructor() {
    this.Username = "";
    this.Email = "";
  }

  Username: string;
  Email: string;
}

const myUser = new User();
console.log(myUser); // output: {Username: "", Email: ""}
console.log("val: "+myUser.Email); // output: ""

You can also use interface instead of type

interface UserType {
  Username: string;
  Email: string;
};

...and rest of code remains same.

Actually, you can even skip the constructor part and use it like this:

class User implements UserType {
      Username = ""; // will be added to new obj
      Email: string; // will not be added
}

const myUser = new User();
console.log(myUser); // output: {Username: ""}

In my case Record<string, never> helps, it was recommended by eslint

user: USER

this.user = ({} as USER)

you can do this as below in typescript

 const _params = {} as any;

 _params.name ='nazeh abel'

since typescript does not behave like javascript so we have to make the type as any otherwise it won't allow you to assign property dynamically to an object

What i wanted is intellisense help for a chain of middlewares. Record<string, never> worked for me.

type CtxInitialT = Record<string, never>;
type Ctx1T = CtxInitialT & {
  name: string;
};
type Ctx2T = Ctx1T & {
  token: string;
};

cont ctx: CtxInitialT = {};
// ctx.name = ''; // intellisense error Type 'string' is not assignable to type 'never'
cont ctx1: Ctx1T = middleware1AugmentCtx(ctx);
// ctx1.name = 'ddd'; // ok
// ctx1.name1 = ''; // intellisense error Type 'string' is not assignable to type 'never'
cont ctx2: Ctx2T = middleware2AugmentCtx(ctx1);
// ctx2.token = 'ttt'; // ok
// ctx2.name1 = ''; // intellisense error Type 'string' is not assignable to type 'never'

If you want TS to understand that all references to an potentially empty object below a certain check are indeed that full type and not the unset empty object, you likely want an emptiness check that determines if the value is Record<string, never>,

function isEmpty<T>(x: T | Record<string, never>): x is Record<string, never> {
  return  x != null &&
  typeof x === 'object' &&
  Object.keys(x).length === 0
}

A common problem here is when JS logic has determined a nested object, usually in state, has been set, but TS complains, e.g.

import { isEmpty } from 'ramda'
// typed as (x: any) => boolean <--- boolean needs to be narrowed

const [user, setUser] = useState({})

...

const Dashboard = ({user}) => {

if(isEmpty(user)) return null 

user.address.city // <--- city is there, but TS complains 

If you type your object as T | Record<string, never> and write an emptiness check like the one above that types the return as value is Record<string, never>, TS will not complain in the above code and recognizes the entire user to as set.

Emptiness checks are usually generalized, so here are some other types that might be helpful in checking empty objects, arrays, or strings.

type Empty<T> = 
  T extends Array<infer U> ? [] : 
  T extends object ? Record<string, never> : 
  T extends string ? '' : 
  never

type MaybeEmpty<T> = T | Empty<T>

Note the return type for an empty array is x is never[], but I find that getting TS to understand emptiness is usually just an issue with objects.

If you declare an empty object literal and then assign values later on, then you can consider those values optional (may or may not be there), so just type them as optional with a question mark:

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

In case of

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

you can declare an empty object or only one field(for example, only Username); in that case, you will not have an error, which can be a problem.

I will prefer more {} as User version.