TypeScript Type Aliases
📌 Type aliases allow you to give a descriptive name to a TypeScript type, such as a union type (`type StringOrNumber = string | number`).
📌 Type aliases can represent more complex types, including arrays of unions (e.g., `type StringOrNumberArray = (string | number)[]`).
📌 Interfaces are primarily for describing object shapes or classes, whereas type aliases can be used as an alias for any TypeScript type, including union types where interfaces cannot be used (e.g., setting `type PostID = string | number` is possible, but not with an interface).

Literal Types
📌 A literal type assigns a specific, fixed value to a variable, restricting its type to that single value (e.g., `let myName: "Dave"`).
📌 Literal types become highly useful when combined with union types to define a limited set of acceptable string or number values (e.g., `username` can only be "Dave", "John", or "Amy").
📌 Both type aliases and literal types help keep code DRY (Don't Repeat Yourself) by avoiding repetitive type definitions.

Function Type Signatures
📌 Explicitly define parameter and return types for functions (e.g., `(a: number, b: number): number => a + b`).
📌 Functions that have no explicit return (side effects only) should be assigned the `void` return type (e.g., `function logMessage(message: any): void`).
📌 Type aliases are often preferred over interfaces for defining function signatures, though interfaces can also be structured for this purpose (e.g., `type MathFunction = (c: number, d: number) => number`).

Advanced Function Parameters and Types
📌 Optional parameters must be the last in the parameter list and are denoted with a `?` (e.g., `C?: number`). This makes the parameter's type `number | undefined`.
📌 When a parameter is optional, a type guard (like `if (typeof C !== undefined)`) is often required to narrow the type within the function body.
📌 Default values are assigned using the equals sign (e.g., `C = 2`), which means the parameter will default to that value if omitted, and it does not inherently become optional in the same way as a parameter with just `?`.
📌 Rest parameters (using `...nums: number[]`) collect an indefinite number of arguments into an array and must always come last in the parameter list.

The `never` Type
📌 The `never` type is inferred for functions that explicitly throw errors (e.g., `createError`) or functions that contain an infinite loop (e.g., `while(true)`).
📌 Functions returning `never` signal that code execution will never reach the end of that function body.
📌 If an apparent infinite loop is broken by a condition (like a `break` statement), the return type reverts to `void` (if no explicit return exists).
📌 The `never` type is crucial when using type guards in union types; if all possible union members are handled by guards, TypeScript expects the remaining path to return the expected type or explicitly call a function that returns `never` to satisfy the compiler.

Key Points & Insights
➡️ Use type aliases for defining reusable, complex types, especially union types, and use interfaces primarily for object structures and extensibility.
➡️ When dealing with optional function parameters, ensure they are placed last and use type guards to safely handle the potential `undefined` value.
➡️ Leverage literal types to enforce precise sets of values for variables, improving code clarity and safety.
➡️ Recognize the `never` type returned by functions that throw errors or loop infinitely; this is a signal to ensure all execution paths are accounted for, often requiring an explicit error throw or loop termination condition.

📸 Video summarized with SummaryTube.com on Dec 22, 2025, 14:46 UTC