How to fix Type 'X | Y' is not assignable to type 'Z' in TypeScript

// Using typeof for primitive types
function processValue(value: string | number) {
  if (typeof value === 'string') {
    // TypeScript knows value is string here
    const result: string = value; // ✓ Works
  } else {
    // TypeScript knows value is number here
    const result: number = value; // ✓ Works
  }
}

// Using 'in' operator for object properties
type Dog = { bark: () => void };
type Cat = { meow: () => void };

function handlePet(pet: Dog | Cat) {
  if ('bark' in pet) {
    const dog: Dog = pet; // ✓ Works
  } else {
    const cat: Cat = pet; // ✓ Works
  }
}

type Success = { status: 'success'; data: string };
type Error = { status: 'error'; message: string };
type Result = Success | Error;

function handleResult(result: Result) {
  // TypeScript narrows based on discriminant
  if (result.status === 'success') {
    const data: string = result.data; // ✓ Works
  } else {
    const message: string = result.message; // ✓ Works
  }
}

// Switch statements also work
function processResult(result: Result) {
  switch (result.status) {
    case 'success':
      return result.data; // TypeScript knows this is Success
    case 'error':
      return result.message; // TypeScript knows this is Error
  }
}

type Animal = Dog | Cat | Bird;

function getDog(animal: Animal): Dog {
  // Use 'as' type assertion
  return animal as Dog;
}

// Or angle bracket syntax (not in JSX)
function getCat(animal: Animal): Cat {
  return <Cat>animal;
}

// Better: combine with runtime check
function getSafeDog(animal: Animal): Dog {
  if ('bark' in animal) {
    return animal as Dog; // ✓ Safe assertion
  }
  throw new Error('Not a dog');
}

// Problem: TypeScript infers string | number
let value = Math.random() > 0.5 ? 'hello' : 42;
const str: string = value; // ✗ Error

// Solution 1: Explicit annotation
let value: string = Math.random() > 0.5 ? 'hello' : 'world';
const str: string = value; // ✓ Works

// Solution 2: as const for literal types
const config = {
  mode: 'development' // inferred as string
} as const; // now mode is 'development' literal

// Solution 3: Type assertion at initialization
let value = (Math.random() > 0.5 ? 'hello' : 42) as string;

interface User {
  id: number;
  name: string;
}

interface Guest {
  sessionId: string;
}

// Type predicate function
function isUser(account: User | Guest): account is User {
  return 'id' in account && 'name' in account;
}

function greet(account: User | Guest) {
  if (isUser(account)) {
    // TypeScript knows account is User
    console.log(`Hello ${account.name}`); // ✓ Works
  } else {
    // TypeScript knows account is Guest
    console.log(`Session: ${account.sessionId}`); // ✓ Works
  }
}

// Instead of forcing a specific type
function badProcess(value: string) {
  return value.toUpperCase();
}

// Accept the union and handle both cases
function goodProcess(value: string | number): string {
  if (typeof value === 'string') {
    return value.toUpperCase();
  }
  return value.toString();
}

// Or use generics to preserve the type
function identity<T>(value: T): T {
  return value;
}

const str = identity('hello'); // Type: string
const num = identity(42);      // Type: number