How to fix Type 'never' is not assignable to type 'string' in TypeScript

const items = [];
items.push("hello"); // Error: Argument of type 'string' is not assignable to parameter of type 'never'

const items: string[] = [];
items.push("hello"); // OK

const [items, setItems] = useState<string[]>([]);
setItems([...items, "hello"]); // OK

function processValue(value: string | number) {
  if (typeof value === "string") {
    return value.toUpperCase();
  } else if (typeof value === "number") {
    return value.toFixed(2);
  }
  // TypeScript infers 'value' is never here
  const result: string = value; // Error: Type 'never' is not assignable to type 'string'
  return result;
}

function processValue(value: string | number): string {
  if (typeof value === "string") {
    return value.toUpperCase();
  } else {
    return value.toFixed(2);
  }
  // No unreachable code
}

const result = [].reduce((acc, item) => {
  acc[item] = item; // Error: never type
  return acc;
}, {});

interface Result {
  [key: string]: string;
}

const result = [].reduce<Result>((acc, item: string) => {
  acc[item] = item;
  return acc;
}, {});

const items: string[] = [];
const result = items.reduce((acc, item) => {
  acc[item] = item;
  return acc;
}, {} as Record<string, string>);

function handleEvent(event: "click" | "hover") {
  if (event === "click") {
    // handle click
  } else if (event === "hover") {
    // handle hover
  } else {
    // TypeScript thinks this is unreachable (event is never)
    // But if you're adding new event types, this might execute
    const eventType: string = event as string; // Safe assertion
    console.warn(`Unknown event: ${eventType}`);
  }
}

type Response = 
  | { status: "success"; data: string }
  | { status: "error"; message: string };

function handleResponse(response: Response) {
  if (response.status === "success") {
    return response.data;
  }
  // Forgot to handle "error" case
  const msg: string = response.message; // Error: Property 'message' does not exist on type 'never'
}

function handleResponse(response: Response): string {
  if (response.status === "success") {
    return response.data;
  } else {
    return response.message; // Now TypeScript knows this is the error case
  }
}

{
  "compilerOptions": {
    "strict": true,
    "noImplicitAny": true,
    "strictNullChecks": true
  }
}

// Will error without type annotation when noImplicitAny is true
const items: string[] = []; // Must explicitly type