"""Create recovery_planner
Generated by Phi-Octopus Eden
2025-11-06 12:46:06.724135
"""

```python
from typing import List, Dict

class RecoveryPlanner:
    """
    A class for creating a limited error recovery planner that can handle specific errors during execution.
    """

    def __init__(self):
        self.recovery_strategies: Dict[str, callable] = {}

    def register_error(self, error_type: type, strategy: callable) -> None:
        """
        Register an error type with its corresponding recovery strategy.

        :param error_type: The type of the error to be registered.
        :param strategy: The function that will handle the recovery process when the error occurs.
        """
        self.recovery_strategies[str(error_type)] = strategy

    def plan_recovery(self, action: callable) -> callable:
        """
        Decorator to wrap an action and apply recovery strategies in case of errors.

        :param action: The action to be wrapped for error recovery.
        :return: A function that wraps the original action with error handling logic.
        """

        def wrapper(*args, **kwargs):
            try:
                return action(*args, **kwargs)
            except Exception as e:
                print(f"Error occurred: {e}")
                if str(type(e)) in self.recovery_strategies.keys():
                    recovery_strategy = self.recovery_strategies[str(type(e))]
                    recovery_strategy()
                else:
                    raise

        return wrapper

# Example usage
def perform_division(num1: int, num2: int) -> float:
    """
    Perform division of two numbers.
    
    :param num1: The numerator.
    :param num2: The denominator.
    :return: The result of the division.
    """
    return num1 / num2

def handle_division_by_zero() -> None:
    """
    Recovery strategy for ZeroDivisionError. Logs a message and returns infinity as the result.
    """
    print("Cannot divide by zero, returning infinity.")
    return float('inf')

if __name__ == "__main__":
    planner = RecoveryPlanner()
    planner.register_error(ZeroDivisionError, handle_division_by_zero)
    
    @planner.plan_recovery
    def main():
        result = perform_division(10, 2)  # This will succeed and print "5.0"
        result = perform_division(10, 0)  # This will trigger the recovery strategy

    main()
```

This Python script introduces a `RecoveryPlanner` class that can be used to register error types with their corresponding recovery strategies. The example usage demonstrates how to use this planner to handle division by zero errors during execution of a function.