Type Aliases

Basic Type Aliases

Type aliases create a new name for an existing type using the type keyword.

Simple Aliases

// Primitive aliases
type ID = string | number;
type Name = string;
type Age = number;

// Usage
let userId: ID = 123;
let userName: Name = "Alice";
let userAge: Age = 30;

Object Aliases

type User = {
  name: string;
  age: number;
  email: string;
};

const user: User = {
  name: "Alice",
  age: 30,
  email: "alice@example.com"
};

Function Aliases

type Callback = (data: string) => void;
type AsyncLoader = () => Promise<string>;

function processData(callback: Callback): void {
  callback("done");
}

Exporting Type Aliases

export type Point = {
  x: number;
  y: number;
};

import type { Point } from "./types";

Complex Types

Type aliases can create sophisticated type combinations.

Union Types in Aliases

type Status = "active" | "inactive" | "pending";
type Result = Success | Error;

type Success = {
  status: "success";
  data: unknown;
};

type Error = {
  status: "error";
  message: string;
};

Intersection Types in Aliases

type HasId = { id: number };
type HasTimestamp = { createdAt: Date };

type Entity = HasId & HasTimestamp & {
  name: string;
};

Utility Type Aliases

// Partial - all properties optional
type PartialUser = Partial<User>;

// Required - all properties required
type RequiredConfig = Required<Config>;

// Pick - select specific properties
type UserSummary = Pick<User, "name" | "email">;

// Omit - exclude specific properties
type UserWithoutId = Omit<User, "id">;

Generic Type Aliases

type ApiResponse<T> = {
  data: T;
  status: number;
  message: string;
};

// Usage
type UserResponse = ApiResponse<User>;
type ProductResponse = ApiResponse<Product>;

Type vs Interface

Key Differences

Feature	Type	Interface
Extension	& (intersection)	extends
Declaration Merging	No	Yes
Implements	Yes	Yes
Primitives	Yes	No
Tuples	Yes	No

When to Use Each

Use Type When:

• Creating unions or intersections
• Working with primitives or tuples
• Need complex type transformations

// Type is better for unions
type Shape = Circle | Square;

// Type is better for primitives
type ID = string | number;

// Type is better for tuples
type Pair = [string, number];

Use Interface When:

• Defining object shapes
• Need declaration merging
• Creating class contracts

// Interface is better for objects
interface User {
  name: string;
  age: number;
}

// Interface supports declaration merging
interface Window {
  myCustomProp: string;
}

Declaration Merging

// Only interfaces support this
interface User {
  name: string;
}

interface User {
  age: number;
}

// Result: User has both name and age
const user: User = { name: "Alice", age: 30 };