Interfaces are used to create reusable, modular types that describe the shape of objects. They serve almost the exact same purposes as type aliases with a slightly different syntax.

```ts
// Interface
interface Person = {
name: string
age: number
}

// Use interface in the annotation
const greetPerson = (person: Person) => {
    return `Hello, ${person.name}! You are ${person.age} years old.`;
}
```

 **Reopening Interfaces:** you can declare the same interface more than once, and TypeScript will merge all declarations together.
 
 ```ts
// Interface
interface Person = {
name: string;
}

interface Person = {
age: number;
}

const person: Person = {
  name: "Valentin",
  age: 100
};

```

**Extending interfaces** allows one interface to inherit the properties of another.

 ```ts
// Interface
interface Person = {
name: string;
age: number;
}


interface Employee  extends Person {
email: string
}

const person: Employee = {
  name: "Valentin",
  age: 100,
  email: valentin@gmail.com
};

```

**Multiple Inheritance**: typeScript lets an interface extend multiple interfaces , combining all their properties. 


 ```ts

interface Person = {
name: string;
age: number;
}


interface Employee   {
readonly id: number;
email: string
}

interface Engineer extends Person,Employee {
 level: string.
 languages: string[]
}

const person: Engineer = {
  id: 12345,
  name: "Valentin",
  age: 100,
  email: valentin@gmail.com,
  level: "Senior",
  languages: ["Javascript", "Typescript"]
};

```


Typescript Interfaces

Typescript Interfaces, reopening Interfaces, extending interfaces, multiple inheritance

TypeScript

Interfaces in Typescript

**Type aliases** let you create new names for types. This makes your code easier to read and reuse.


```ts
// Type alias
type Person = {
name:string
age:number
}

// Use type alias in the annotation
const greetPerson = (person: Person) => {
    return `Hello, ${person.name}! You are ${person.age} years old.`;
}
```

**Union Types** allow us to give a value a few different possible types. We can create a union type by using the single | (pipe character) to separate the types we want to include

```ts
function formatInput(input: string | number) {
  if (typeof input === "number") {
    return input.toFixed(2);
  } else {
    return input.toUpperCase();
  }
}
```
**Intersection Types** combine multiple types into one that has all properties of the intersected types.

```ts

type Circle ={
radius: number;
}

type Colored = {
color: string;
}

type ColoredCircle = Circle & Colored;

const circleExample: ColoredCircle = {
color: "red",
radius:  5
}

```

A **literal type** allows a variable to be assigned **only one specific value**.  A **union of literal types** is a type that allows a value to be **one of several exact, predefined values**, enhancing type safety by restricting inputs to a specific set of possibilities.

```ts

const getTrafficLight = (trafficLight: "red" | "yellow" | "green") => {
     return `The traffic light is : ${trafficLight}`
}

getTrafficLight("red");     //  Works
getTrafficLight("yellow");  //  Works
getTrafficLight("green");   //  Works

getTrafficLight("blue");    //  Error

```


Type Aliases, Union, Literal, and Intersection Types in TypeScript

Define custom types using type aliases, combine types with unions, and merge types with intersections to write flexible, reusable TypeScript code.

TypeScript Advanced Types

TypeScript is a superset of JavaScript that adds static typing. One of its core features is **type annotations** — a way to explicitly define the types of variables, function parameters, return values, and more. Type annotations enhance code readability, catch errors at compile time, and provide better tooling support. 

Type annotations let you specify the type of a variable or function component. This helps TypeScript understand the expected structure of your code and flag any inconsistencies.

```ts
const username: string = "Alice";
const age: number = 30;
const isLoggedIn: boolean = true;
```
Here, \`username\` must always be a string, \`age\` a number, and \`isLoggedIn\` a boolean.

TypeScript doesn’t require you to annotate everything thanks to type inference. Its built-in ability to automatically determine a variable’s type based on the value it’s assigned.


```ts
const username = "Alice";       // inferred as string
const age = 30;                 // inferred as number
const isLoggedIn = true;        // inferred as boolean
```
Writing const username: string = "Alice" is correct, but unnecessary. And in larger codebases, this kind of repetition can actually clutter your code.

You can annotate both parameters and return types in functions.

```ts
function greet(name: string): string {
  return `Hello, ${name}!`;
}

```

Without proper types, this function could be misused or produce unexpected behavior. Type annotations also work with optional parameters using \`?\`, and default values.

```ts
function log(
  message: string,          // required
  userId?: number,          // optional parameter
  level: string = "info"    // parameter with default value
): void {
  console.log(`[${userId ?? "anonymous"}] (${level}): ${message}`);
}
```

Complex structures like arrays and objects can also be annotated:

```ts
const user: { id: number; name: string } = {
  id: 1,
  name: "Alice"
};

const scores: number[] = [85, 90, 92];

```

 Special Built-in Types: **void**, **never**,  **any**, and **unknown**



Use **void** to indicate a function does **not return a value**.

```ts
function logMessage(message: string): void {
  console.log(message);
}
```

This helps TypeScript understand that return values are irrelevant here.


Use **never** when a function **never returns** — either because it throws an error or runs infinitely.

```ts
function throwError(message: string): never {
  throw new Error(message);
}

function infiniteLoop(): never {
  while (true) {}
}
```

**never** tells TypeScript that this code path will not continue normally.



The **any** type disables type checking for a variable — it's like opting out of TypeScript's safety.

```ts
let randomValue: any = 42;
randomValue = "Now it's a string";
randomValue = true;
```

Use **any** **minimally**, as it removes the benefits of TypeScript’s type system.

Prefer using **unknown** if you want type safety with flexibility. The **unknown** type is safer than **any**. It represents a value that could be anything, but you must perform type checks before using it.

```ts
let uncertainValue: unknown = 10;
uncertainValue = "hello";

// TypeScript error if you try to use it directly:
// console.log(uncertainValue.toUpperCase()); // Error!

if (typeof uncertainValue === "string") {
  // Now TypeScript knows it's a string
  console.log(uncertainValue.toUpperCase());
}
```

## Benefits of Type Annotations

- **Improved readability**: Makes code self-documenting.
- **Better IDE support**: Autocompletion and inline documentation.
- **Early error detection**: Catch mistakes before runtime.
- **Easier refactoring**: Code changes are safer and more predictable.

Use **type annotations** where they **add clarity** or are **required**, but rely on **inference** to reduce repetition for basic assignments. 


Type Annotations and Inference in TypeScript

How type annotations improve code clarity, safety, and developer experience in TypeScript.

TypeScript Basics

A **tuple** is a typed array with a fixed length and known element types.

```ts
let user: [string, number];

user = ["Alice", 30]; //  OK
// user = [30, "Alice"]; //  Error: wrong order/types

```

**Enums** let you define a set of **named values**. These values can be numeric or string-based.

```ts
// numeric enums
enum OrderStatus {
  PENDING, // 0
  SHIPED,   // 1
  DELIVERED,  // 2
  RETURNED,  // 3
}

const status = OrderStatus.DELIVERED;

function isDelivered (status:OrderStatus ){
     return status === OrderStatus.DELIVERED
}

isDelivered(OrderStatus.RETURNED)

// string enums
enum Direction {
  Left = "LEFT",
  Right = "RIGHT",
  Up = "UP",
  Down = "DOWN"
}

const move = (dir: Direction) => {
  console.log("Moving:", dir);
};

move(Direction.Left);
```


Tuples and Enums in TypeScript

How to use tuples for fixed-length typed arrays and enums for named constants in TypeScript

typescript

Typescript Interfaces

Type Aliases, Union, Literal, and Intersection Types in TypeScript

Type Annotations and Inference in TypeScript

Tuples and Enums in TypeScript