How to fix Property 'name' does not exist on type 'never' in TypeScript

type User = { type: 'admin'; name: string } | { type: 'guest' };

function getUserName(user: User): string {
  if (user.type === 'admin') {
    return user.name; // OK: user is narrowed to admin type
  }
  // ERROR: At this point, user is type 'never' if guest case isn't handled
  return user.name; // Property 'name' does not exist on type 'never'
}

type User = { type: 'admin'; name: string } | { type: 'guest' };

function getUserName(user: User): string {
  if (user.type === 'admin') {
    return user.name;
  } else {
    // Handle guest case explicitly
    return 'Guest User';
  }
}

type Status = 'pending' | 'success' | 'error';

function getStatusMessage(status: Status): string {
  switch (status) {
    case 'pending':
      return 'Processing...';
    case 'success':
      return 'Completed successfully';
    case 'error':
      return 'An error occurred';
    // No default needed - all cases covered
  }
}

function assertNever(value: never): never {
  throw new Error(`Unhandled value: ${JSON.stringify(value)}`);
}

type Shape =
  | { kind: 'circle'; radius: number }
  | { kind: 'square'; side: number }
  | { kind: 'triangle'; base: number; height: number };

function getArea(shape: Shape): number {
  switch (shape.kind) {
    case 'circle':
      return Math.PI * shape.radius ** 2;
    case 'square':
      return shape.side ** 2;
    case 'triangle':
      return 0.5 * shape.base * shape.height;
    default:
      // TypeScript ensures all cases are handled
      return assertNever(shape);
  }
}

interface Dog { type: 'dog'; name: string; bark(): void }
interface Cat { type: 'cat'; name: string; meow(): void }
interface Bird { type: 'bird'; name: string; chirp(): void }

type Animal = Dog | Cat | Bird;

function isMammal(animal: Animal): animal is Dog | Cat {
  return animal.type === 'dog' || animal.type === 'cat';
}

function handleAnimal(animal: Animal) {
  if (isMammal(animal)) {
    console.log(animal.name); // OK: Dog or Cat
    if (animal.type === 'dog') {
      animal.bark();
    } else {
      animal.meow();
    }
  } else {
    // animal is Bird
    console.log(animal.name); // OK: Bird
    animal.chirp();
  }
}

// ❌ DON'T: Type assertion that creates 'never'
type Impossible = string & number; // Type is 'never'

function badExample(value: string | number) {
  if (typeof value === 'string') {
    // value is string
  } else if (typeof value === 'number') {
    // value is number
  } else {
    // value is never here
    const impossible = value as Impossible; // Creates problems
  }
}

// ✅ DO: Let TypeScript infer types naturally
function goodExample(value: string | number) {
  if (typeof value === 'string') {
    return value.toUpperCase();
  } else {
    return value.toFixed(2);
  }
}

{
  "compilerOptions": {
    "strict": true,
    "noImplicitAny": true,
    "strictNullChecks": true,
    "strictFunctionTypes": true,
    "strictBindCallApply": true,
    "strictPropertyInitialization": true,
    "noImplicitThis": true,
    "alwaysStrict": true,
    "noUnusedLocals": true,
    "noUnusedParameters": true,
    "noImplicitReturns": true,
    "noFallthroughCasesInSwitch": true,
    "exactOptionalPropertyTypes": true,
    "noUncheckedIndexedAccess": true
  }
}