How can I get the type of array items?

Starting with TypeScript 2.8, you can also do this with the infer keyword. This should only be used for more complicated cases (arrays nested in promises, etc.). Otherwise, it is overly verbose.

type GetElementType<T extends any[]> = T extends (infer U)[] ? U : never;

For example:

// ElementType === string
type ElementType = string[] extends (infer U)[] ? U : never;

The infer keyword is very powerful and can extract any type out of larger type. For example, if the type was a function that returned an array:

type FncType = () => [{ name: string }];

// Output === { name: string }
type Output = FncType extends () => (infer U)[] ? U : never;

You can also use the infer keyword in generic types:

type GetArrayReturnType<T> = T extends () => (infer U)[] ? U : never;

// Output === { name: string }
type Output = GetArrayReturnType<() => [{ name: string }]>;

You can simply get the type of the array using the brackets as follows:

type Foo = Array<{ name: string; test: number; }>
type Bar = Foo[number]; // <- What you want
// Then you can use it as follows
const bar: Bar = {name:"", test:42};

Bonus:

If your array was a tuple (where elements are typed by index), you can specify which type you want to target using the index within the type's brackets.

type foo = [number, string, ...number[]]; // A tuple or typed array
const barA: foo[0] = 42;
const barB: foo[1] = 'hello';
const barC: foo[2] = 256;
// Using type[number] will generate an union of all the possible types.
// Here below string | number. The following is therefore valid
const barStringOrArray: foo[number] = Math.random() < 0.5 ? 42 : 'hello';

This works with any iterable (including readonly Arrays and tuples):

type ElementType<T extends Iterable<any>> = T extends Iterable<infer E>
  ? E
  : never;

Usage:

ElementType<typeof foo>

It was inspired by yeerk.

We can also use an indexed access operator like this:

const someArray = [
    {
        foo: '',
        bar: '',
        baz: ''
    },
    {
        foo: '',
        bar: '',
        baz: ''
    }
];

// Indexed access operator
type SomeArray = typeof someArray[number];

There is a write-up on those here: Advanced Types

The second operator is T[K], the indexed access operator.

Using the popular utility-types library:

type foo = Array<{ name: string; test: number; }>

type fooElements = ValuesType<foo>
// = { name: string; test: number; }

Despite Aleksey's answer, it might be useful to know that, if the instance of that generic type exposes at least one member of the type you want to extract, you could use typeof to query the type of that member.

For a generic Array, the type can be queried from any array item:

Note that line 27 only exists at design time so that will not generate any errors even if arr is empty or undefined at runtime.