How to fix Interface declaration cannot declare a class field in TypeScript

// WRONG - interface with field initializer
interface User {
  name: string = "Guest";  // Error: Interface declaration cannot declare a class field
  age: number = 0;         // Error
}

// CORRECT - interface without initializers
interface User {
  name: string;  // Type only, no value
  age: number;   // Type only, no value
}

// Usage
const user: User = {
  name: "John",  // Value assigned when creating object
  age: 30,
};

// WRONG - trying to set defaults in interface
interface Config {
  timeout: number = 5000;
  retries: number = 3;
}

// CORRECT - use a class with default values
class Config {
  timeout: number = 5000;
  retries: number = 3;

  constructor(overrides?: Partial<Config>) {
    Object.assign(this, overrides);
  }
}

// Usage
const config = new Config();  // timeout=5000, retries=3
const customConfig = new Config({ timeout: 10000 });  // timeout=10000, retries=3

// WRONG
interface Settings {
  theme: "light" | "dark" = "light";
  notifications: boolean = true;
}

// CORRECT - make properties optional, handle defaults elsewhere
interface Settings {
  theme?: "light" | "dark";
  notifications?: boolean;
}

// Helper function to apply defaults
function createSettings(overrides?: Settings): Required<Settings> {
  return {
    theme: overrides?.theme ?? "light",
    notifications: overrides?.notifications ?? true,
  };
}

// Usage
const settings = createSettings();  // theme="light", notifications=true
const darkSettings = createSettings({ theme: "dark" });  // theme="dark", notifications=true

// Define base interface without defaults
interface UserBase {
  name: string;
  email: string;
}

// Define defaults as a separate type
type UserDefaults = {
  role: "user" | "admin";
  active: boolean;
};

// Create a type that combines them
type UserWithDefaults = UserBase & Partial<UserDefaults>;

// Helper to apply defaults
function createUser(base: UserBase, defaults?: Partial<UserDefaults>): UserBase & UserDefaults {
  return {
    ...base,
    role: defaults?.role ?? "user",
    active: defaults?.active ?? true,
  };
}

// Usage
const user = createUser(
  { name: "Alice", email: "alice@example.com" },
  { role: "admin" }
);
// Result: { name: "Alice", email: "alice@example.com", role: "admin", active: true }

// WRONG - trying to share implementation via interface
interface Logger {
  prefix: string = "[LOG]";
  log(message: string): void;
}

// CORRECT - use abstract class
abstract class Logger {
  protected prefix: string = "[LOG]";

  abstract log(message: string): void;

  protected formatMessage(message: string): string {
    return `${this.prefix} ${new Date().toISOString()}: ${message}`;
  }
}

// Concrete implementation
class ConsoleLogger extends Logger {
  log(message: string): void {
    console.log(this.formatMessage(message));
  }
}

// Another implementation
class FileLogger extends Logger {
  constructor() {
    super();
    this.prefix = "[FILE]";
  }

  log(message: string): void {
    // Write to file using formatted message
    const formatted = this.formatMessage(message);
    // ... file writing logic
  }
}

// Interface defines the shape
interface ApiClient {
  baseUrl: string;
  timeout: number;
  get<T>(path: string): Promise<T>;
  post<T>(path: string, data: unknown): Promise<T>;
}

// Factory function creates instances with defaults
function createApiClient(config?: Partial<Pick<ApiClient, 'baseUrl' | 'timeout'>>): ApiClient {
  const baseUrl = config?.baseUrl ?? "https://api.example.com";
  const timeout = config?.timeout ?? 30000;

  return {
    baseUrl,
    timeout,
    async get<T>(path: string): Promise<T> {
      const response = await fetch(`${baseUrl}${path}`, { timeout });
      return response.json();
    },
    async post<T>(path: string, data: unknown): Promise<T> {
      const response = await fetch(`${baseUrl}${path}`, {
        method: "POST",
        headers: { "Content-Type": "application/json" },
        body: JSON.stringify(data),
        timeout,
      });
      return response.json();
    },
  };
}

// Usage
const defaultClient = createApiClient();  // Uses all defaults
const customClient = createApiClient({
  baseUrl: "https://staging.example.com",
  timeout: 60000
});