"""Create recovery_planner
Generated by Phi-Octopus Eden
2025-11-08 10:24:03.828088
"""

```python
from typing import List, Dict


class RecoveryPlanner:
    """
    A class for planning limited error recovery strategies.
    
    Attributes:
        total_errors: Total number of errors encountered.
        recovery_attempts: Number of recovery attempts made.
        max_recovery_attempts: Maximum allowed recovery attempts.
        recovery_strategies: A dictionary mapping error types to their recovery plans.
        
    Methods:
        add_recovery_strategy: Adds a new strategy for recovering from an error type.
        attempt_recovery: Attempts to recover from the last encountered error.
        is_recoverable: Determines if the last error can be recovered based on current strategies.
    """
    
    def __init__(self, max_recovery_attempts: int):
        self.total_errors = 0
        self.recovery_attempts = 0
        self.max_recovery_attempts = max_recovery_attempts
        self.recovery_strategies: Dict[str, List[str]] = {}
        
    def add_recovery_strategy(self, error_type: str, recovery_plan: List[str]) -> None:
        """
        Adds a new strategy for recovering from an error of the specified type.
        
        Args:
            error_type: The type of error to which this recovery plan applies.
            recovery_plan: A list of steps or actions to recover from the error.
            
        Raises:
            ValueError: If `error_type` is not a string or `recovery_plan` is not a list.
        """
        if not isinstance(error_type, str):
            raise ValueError("Error type must be a string.")
        if not isinstance(recovery_plan, List):
            raise ValueError("Recovery plan must be a list of strings.")
        
        self.recovery_strategies[error_type] = recovery_plan
        
    def attempt_recovery(self) -> bool:
        """
        Attempts to recover from the last encountered error.
        
        Returns:
            A boolean indicating whether recovery was successful or not.
            
        Raises:
            KeyError: If no strategy exists for the type of the last error.
        """
        if self.recovery_attempts >= self.max_recovery_attempts:
            raise Exception("Max recovery attempts reached.")
        
        last_error_type = f"Error_{self.total_errors}"
        recovery_plan = self.recovery_strategies.get(last_error_type)
        
        if not recovery_plan:
            raise KeyError(f"No recovery strategy for error type: {last_error_type}")
        
        # Simulate applying a recovery plan
        print(f"Applying recovery plan for {last_error_type}: {recovery_plan[0]}")
        self.total_errors += 1
        self.recovery_attempts += 1
        
        return True
    
    def is_recoverable(self, error_type: str) -> bool:
        """
        Determines if the last encountered error of a given type can be recovered.
        
        Args:
            error_type: The type of the error to check for recoverability.
            
        Returns:
            A boolean indicating whether recovery from this error type is possible or not.
        """
        return error_type in self.recovery_strategies


# Example Usage
recovery_planner = RecoveryPlanner(max_recovery_attempts=3)

# Adding strategies
recovery_planner.add_recovery_strategy("NetworkError", ["Check network connection", "Restart router"])
recovery_planner.add_recovery_strategy("SyntaxError", ["Review code for syntax issues", "Run linter"])

try:
    # Attempting recovery
    success = recovery_planner.attempt_recovery()
    print(f"Recovery successful: {success}")
    
except Exception as e:
    print(e)

# Check if a specific error type can be recovered
print(recovery_planner.is_recoverable("NetworkError"))
```