Argument of type 'X' is not assignable to parameter of type 'Y'

// Example of TS2345 error
function greet(name: string): void {
    console.log(`Hello, ${name}!`);
}

greet(123); // Error: Argument of type 'number' is not assignable to parameter of type 'string'

function calculateAge(birthYear: number): number {
    return 2024 - birthYear;
}

// ❌ Wrong - passing string instead of number
calculateAge("1990"); // Error!

// ✅ Correct
calculateAge(1990);

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

function createUser(user: User): void {
    console.log(user);
}

// ❌ Missing 'email' property
createUser({ id: 1, name: "John" }); // Error!

// ✅ All properties included
createUser({ id: 1, name: "John", email: "john@example.com" });

function processName(name: string): string {
    return name.toUpperCase();
}

const userName: string | null = getUserName();

// ❌ userName might be null
processName(userName); // Error!

// ✅ Check for null first
if (userName !== null) {
    processName(userName);
}

// ✅ Or provide default
processName(userName ?? "Guest");

function sumNumbers(numbers: number[]): number {
    return numbers.reduce((a, b) => a + b, 0);
}

// ❌ Mixed array
sumNumbers([1, 2, "3", 4]); // Error!

// ✅ Correct
sumNumbers([1, 2, 3, 4]);

function getFirst<T>(arr: T[]): T {
    return arr[0];
}

const result: string = getFirst([1, 2, 3]); // Error!
// Type 'number' is not assignable to type 'string'

// ✅ Correct
const result: number = getFirst([1, 2, 3]);
// Or
const result: string = getFirst(["a", "b", "c"]);

// Convert or provide correct type
const yearStr = "1990";
calculateAge(parseInt(yearStr, 10)); // Convert to number

// Accept multiple types with union
function processId(id: string | number): void {
    console.log(id);
}

processId("abc"); // OK
processId(123);    // OK

interface User {
    id: number;
    name: string;
    email?: string; // Optional
}

function createUser(user: User): void { }

createUser({ id: 1, name: "John" }); // OK now

// Non-null assertion (use carefully)
processName(userName!); // Assert non-null

// Default value
processName(userName || "Default");

// Nullish coalescing
processName(userName ?? "Default");

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

// All properties become optional
function updateUser(updates: Partial<User>): void { }

updateUser({ name: "New Name" }); // OK

// ❌ Wrong event type
const handleClick = (e: MouseEvent) => { };
<button onClick={handleClick}>Click</button> // Error!

// ✅ Use React's event type
const handleClick = (e: React.MouseEvent<HTMLButtonElement>) => { };
<button onClick={handleClick}>Click</button> // OK

const numbers = [1, 2, 3, 4, 5];

// ❌ Callback returns wrong type
const doubled: number[] = numbers.map(n => n.toString()); // Error!

// ✅ Correct
const doubled: number[] = numbers.map(n => n * 2);
const strings: string[] = numbers.map(n => n.toString());

async function fetchUser(id: number): Promise<User> {
    // ...
}

// ❌ Passing string instead of number
fetchUser("123"); // Error!

// ✅ Correct
fetchUser(123);
fetchUser(parseInt(userId, 10));