What is the "type" reserved word in TypeScript?

I just noticed when trying to create an interface in TypeScript that "type" is either a keyword or a reserved word. When creating the following interface, for example, "type" is shown in blue in Visual Studio 2013 with TypeScript 1.4:

interface IExampleInterface {
	type: string;
}

Let's say that you then try to implement the interface in a class, like this:

class ExampleClass implements IExampleInterface {
	public type: string;

	constructor() {
		this.type = "Example";
    }
}

In the first line of the class, as you type (sorry) the word "type" in order to implement the property required by the interface, IntelliSense appears with "type" having the same icon as other keywords like "typeof" or "new".

I've had a look around, and could find this GitHub issue which lists "type" as a "strict mode reserved word" in TypeScript, but I have not found any further information about what its purpose actually is.

I suspect I'm having a brain fart and this is something obvious I should already know, but what is the "type" reserved word in TypeScript for?

It's used for "type aliases". For example:

type StringOrNumber = string | number;
type DictionaryOfStringAndPerson = Dictionary<string, Person>;

Reference: (edit: removed outdated link) TypeScript Specification v1.5 (section 3.9, "Type Aliases", pages 46 & 47)

Update: (edit: removed outdated link) Now on section 3.10 of the 1.8 spec. Thanks @RandallFlagg for the updated spec and link

Update: (edit: deprecated link) TypeScript Handbook, search "Type Aliases" can get you to the corresponding section.

Update: Now it's here in the TypeScript Handbook.

Type keyword in typescript:

In typescript the type keyword defines an alias to a type. We can also use the type keyword to define user defined types. This is best explained via an example:

type Age = number | string;    // pipe means number OR string
type color = "blue" | "red" | "yellow" | "purple";
type random = 1 | 2 | 'random' | boolean;

// random and color refer to user defined types, so type madness can contain anything which
// within these types + the number value 3 and string value 'foo'
type madness = random | 3 | 'foo' | color;  

type error = Error | null;
type callBack = (err: error, res: color) => random;

You can compose types of scalar types (string, number, etc), but also of literal values like 1 or 'mystring'. You can even compose types of other user-defined types. For example type madness has the types random and color in it.

Then when we try to make a string literal our (and we have IntelliSense in our IDE) it shows suggestions:

It shows all the colors, which type madness derives from having type color, 'random' which is derived from type random, and finally, the string 'foo' which is on the type madness itself.