You have a few options:

1. You can use an index signature type that allows any string or any number, for instance:

   let myObj: {[key: string]: number} = {};
   myObj[prop] = value;
   

   ...allows any string property name, with the values expected to be numbers. (Or you can use {[key: number]: number} to make the keys numbers. string and number are your only two index signature options.)

2. You can use the Record utility type, for example Record<string, number> which does much the same thing as the above:

   let myObj: Record<string, number> = {};
   myObj[prop] = value;
   

3. You can use a Map instead of an object:

   let myObj: Map<string, number> = new Map();
   myObj.set(prop, value);
   

In all three of those, number as the value type is just an example, it can be any type you want (including a union type), or unknown if you won't know the type, or any if you want to allow any type.

It may be obvious, but I'll say it anyway: This does mean TypeScript can't help you with using the wrong property name on the object. :-) But that's inevitable if the property name is a runtime thing.

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.

TypeScript > v4.1 has the option noUncheckedIndexedAccess which should return T | undefined for all unknown index access.

You could implement your own last and be more accurate in its typing:

function last<T>(array: T[]): T | undefined // Explicit type
{
    return array[array.length - 1];
}

The definition for Record is:

/**
 * Construct a type with a set of properties K of type T
 */
type Record<K extends keyof any, T> = {
    [P in K]: T;
};

When creating a type like type MyType = Record<string, string>;, inlining Record leads to the following type:

type MyType = {
    [P in string]: string;
};

This is saying to create an object type with string property names within the set string. Since string is unbounded there's unlimited possibilities of strings (unlike a union of string literal types like "prop1" | "prop2")... so it's describing an object that can have any number of properties with any name, with the only restriction being that the properties must have a type of string.

So yes, from a type checking perspective it's basically equivalent to the example with the index signature without a mapped type ({ [index: string]: string; }.

Use a plain index signature

Using Record in this fashion is a little strange though and many people might not understand what's going on. A more common way to express intent when there can be any number of properties, is to not use a mapped type:

type ObjectWithStringProperties = {
    [index: string]: string;
};

This has the added benefit of helping explain what the key is supposed to be. For example:

type PersonsByName = {
    [name: string]: Person;
};
const collection: PersonsByName = {};

Note that in this way the types are different because a developer using an object with this type will have this extra described key name information to look at in their editor.

Using Record

Note that Record is usually used like the following:

type ThreeStringProps = Record<"prop1" | "prop2" | "prop3", string>;
// goes to...
type ThreeStringProps = { [P in "prop1" | "prop2" | "prop3"]: string; };
// goes to...
type ThreeStringProps = {
    prop1: string;
    prop2: string;
    prop3: string;
};

I have hundreds of empty variable declarations like this, and I can't know at this point in the code the "type" of variable being stored later,

You don't know what sort of data you're planning on putting in the variable?

  items: object[],

While technically it is a JavaScript object, the type can be better. For Typescript to correctly help you identify mistakes when accessing objects properties, you need to tell it the exact shape of the object. If you type it as object, typescript cannot help you with that. Instead you could tell it the exact properties and datatypes the object has:

  let assistance: { safe: string } = { safe: 1 /* typescript can now tell this is wrong */ };
  assistance.unknown; // typescript can tell this wont really work too

Now in the case that the object can contain any sort of key / value pair, you can at least tell typescript what type the values (and the keys) have, by using an object index type:

 items: {
   [key: string]: number | string,
  }[]

That would be the accurate type in the case given.