How to fix Property 'undefined' does not exist on type 'Y' in TypeScript

// BEFORE: Error - trying to access property named 'undefined'
const value = obj.undefined; // Error: Property 'undefined' does not exist on type

// AFTER: Use optional chaining to check if property exists
const value = obj?.someProperty; // Returns undefined if obj is null/undefined

// Or check if the object itself is undefined
if (obj === undefined) {
  // Handle undefined case
}

// BEFORE: Wrong - trying to access property named 'undefined'
if (obj.undefined) { // Error
  // ...
}

// AFTER: Correct - check if property value is undefined
if (obj.someProperty === undefined) {
  // Property exists but value is undefined
}

// Or check if property exists at all
if (!('someProperty' in obj)) {
  // Property doesn't exist on object
}

// Using type guard
if (obj.someProperty !== undefined) {
  // TypeScript knows someProperty is defined here
}

// BEFORE: Error-prone interface
interface User {
  name: string;
  email: string; // Required, but might be undefined in practice
}

const user: User = { name: "John" }; // Error: missing email

// AFTER: Make email optional
interface User {
  name: string;
  email?: string; // Optional - equivalent to email: string | undefined
}

const user: User = { name: "John" }; // OK - email is optional

// Access optional property safely
const email = user.email; // Type: string | undefined
if (user.email !== undefined) {
  console.log(user.email.toUpperCase()); // Type narrowed to string
}

// BEFORE: Unsafe access
function printEmail(user: { email?: string }) {
  console.log(user.email.toUpperCase()); // Error: Object is possibly 'undefined'
}

// AFTER: Use type guard
function printEmail(user: { email?: string }) {
  if (user.email !== undefined) {
    console.log(user.email.toUpperCase()); // Safe - TypeScript knows email is string
  }
}

// Alternative: Use optional chaining with nullish coalescing
function printEmail(user: { email?: string }) {
  const email = user.email?.toUpperCase() ?? "No email";
  console.log(email);
}

// Type guard function
function hasEmail(user: { email?: string }): user is { email: string } {
  return user.email !== undefined;
}

if (hasEmail(user)) {
  console.log(user.email.toUpperCase()); // Type narrowed to string
}

interface Config {
  apiUrl?: string;
  timeout?: number;
}

function setup(config: Config) {
  // Check if property exists (even if value is undefined)
  if ('apiUrl' in config) {
    // Property exists, but value might still be undefined
    console.log(config.apiUrl); // Type: string | undefined
  }

  // Check both existence and non-undefined value
  if ('apiUrl' in config && config.apiUrl !== undefined) {
    console.log(config.apiUrl.toUpperCase()); // Type narrowed to string
  }

  // Alternative: Check for undefined value directly
  if (config.apiUrl !== undefined) {
    console.log(config.apiUrl.toUpperCase()); // Also works
  }
}

{
  "compilerOptions": {
    "target": "ES2020",
    "lib": ["ES2020", "DOM"],
    "strictNullChecks": true,
    "strict": true,
    "noUncheckedIndexedAccess": true
  }
}