In TypeScript, a namespace is a mechanism for organizing code that modularizes related classes, interfaces, functions, and other elements to avoid naming conflicts. Namespaces can be nested within other namespaces, forming a hierarchical structure that enhances code maintainability. For example:

namespace MyNamespace {
  // Definitions of classes, interfaces, functions, etc.
}  

Application of Type Aliases

Type aliases allow developers to assign new names to types, improving code readability and flexibility. Within namespaces, type aliases can simplify complex type definitions, such as:

namespace MyNamespace {
  // Definition of a type alias
  type User = {
    id: number;
    name: string;
  };

  // Usage of the type alias
  const user: User = { id: 1, name: "Alice" };
}  

By using type aliases, developers can avoid repeatedly defining complex types while improving code extensibility.

Application of Union Types

Union types indicate that a variable may be one of several different types. In namespaces, union types are useful for describing optional return values or parameter types, such as:

namespace MyNamespace {
  // Using a union type to describe an optional argument
  function greet(name: string | number): void {
    console.log(name);
  }  
}  

Union types enable more flexible handling of different data sources, for instance by managing responses in various formats during API calls.

Practical Example

Combining namespaces, type aliases, and union types allows developers to build more sophisticated type systems. For example:

namespace MyNamespace {
  // Definition of a type alias
  type Animal = {
    name: string;
    type: 'dog' | 'cat';
  };

  // Using a union type to describe an optional argument
  function describe(animal: Animal | null): void {
    if (animal) {
      console.log(`Animal: ${animal.name} (${animal.type})`);
    }  
  }

  // Usage of the namespace
  const dog: Animal = { name: "Buddy", type: "dog" };
  const cat: Animal = { name: "Whiskers", type: "cat" };  
}  

The code above demonstrates how to combine namespaces, type aliases, and union types within a single namespace to abstract complex data structures and handle them flexibly.

Conclusion

By leveraging namespaces, type aliases, and union types, TypeScript developers can organize their code more efficiently while enhancing the flexibility and readability of their type systems. Properly utilizing these features significantly improves code maintainability and extensibility.