# Types

Types in TypeScript allow you to define custom data structures and enforce specific constraints on the data. They are similar to interfaces but offer additional features.

**Example Type**:

```typescript
type User = {
    firstName: string;
    lastName: string;
    age: number;
};
```

**1. Unions**

Unions allow you to specify that a value can be one of several types. This is useful when a variable or parameter can accept multiple data types.

**Example**:

```typescript
type StringOrNumber = string | number;

function printId(id: StringOrNumber) {
    console.log(`ID: ${id}`);
}

printId(101);     // Output: ID: 101
printId("202");   // Output: ID: 202
```

**2. Intersection**

Intersection types combine multiple types into one. This allows you to create a type that has all properties of the individual types.

**Example**:

```typescript
type Employee = {
    name: string;
    startDate: Date;
};

type Manager = {
    name: string;
    department: string;
};

type TeamLead = Employee & Manager;

const teamLead: TeamLead = {
    name: "harkirat",
    startDate: new Date(),
    department: "Software developer"
};
```

In this example, `TeamLead` is an intersection of `Employee` and `Manager`, meaning it must have all properties defined in both types.

**3. Type Aliases**

Type aliases allow you to create custom names for types, making your code more readable and maintainable.

**Example**:

```typescript
type Point = {
    x: number;
    y: number;
};

type Rectangle = {
    topLeft: Point;
    bottomRight: Point;
};

const rect: Rectangle = {
    topLeft: { x: 0, y: 0 },
    bottomRight: { x: 10, y: 10 }
};
```

**4. Literal Types**

Literal types allow you to specify exact values that a variable can have.

**Example**:

```typescript
type Color = "red" | "green" | "blue";

function printColor(color: Color) {
    console.log(`Selected color: ${color}`);
}

printColor("red");   // Output: Selected color: red
```

**Summary**

* Types in TypeScript allow you to define custom data structures and enforce specific constraints on the data.
* Unions and intersections provide flexibility in specifying variable types and combining multiple types.
* Type aliases improve code readability by creating custom names for complex types.
* Literal types allow you to specify exact values that variables can have, enhancing type safety and expressiveness in your code.


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://docs.bashschool.in/v1/javascript/typescript/types.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.