Rule of five when using polymorphism

Question

I'm trying to get my head around the rule of five when using interfaces(the concept anyway) and abstract classes and struggling to understand how the rules work.

Suppose I have a layout like this:

#include <memory>
#include <optional>
#include <string>

class IEventInterface {
    protected:
        IEventInterface() = default;
        
    public:
        virtual ~IEventInterface() = default;
        
        /* rule of 5 says i need these too (https://github.com/isocpp/CppCoreGuidelines/blob/master/CppCoreGuidelines.md#Rc-five) */
        IEventInterface(const IEventInterface&) = delete;               // copy constructor
        IEventInterface& operator=(const IEventInterface&) = delete;    // copy assignment
        IEventInterface(IEventInterface&&) = delete;                    // move constructor
        IEventInterface& operator=(IEventInterface&&) = delete;         // move assignment
        
        virtual std::optional<std::string> getEventText() noexcept = 0;
        virtual bool isEnabled() noexcept = 0;
};

class AbstractEvent : public IEventInterface {
    public:
        AbstractEvent() : m_enabled { true } {}
        virtual ~AbstractEvent() = default;
        
        /* Do i need to disable the other copy/move operators here too? */
        
        bool isEnabled() noexcept override {
            return m_enabled;
        }
    private:
        bool m_enabled;
};

class EventToday final : public AbstractEvent {
    public:
        EventToday() = default;
        virtual ~EventToday() {
            // some additional cleanup steps are required so no default here
        }
        
        std::optional<std::string> getEventText() noexcept override {
            // some code here to get the event text....
        }
        std::unique_ptr<Collector> m_collector;
        
        /* Do i need to disable the other copy/move operators here too? */
};

in some other code I have a vector full of IEventInterface e.g. std::vector<std::unique_ptr<IEventInterface>> m_events;

Where is the correct place to enforce the rule of five rules? Since the EventToday class needs a destructor defined for some cleanup they will need to kick in but I'm not sure where? In the example above I have them in the interface class but I suspect this is wrong because there is no define or delete required for any of the copy/move/destructor in the interface or abstract class.