         let result: Bool
         
         if let minSecondsInterval = minSecondsSinceFirstEvent,
-            let firstEventDate = stats.currentFirstEventDate {
+            let firstEventDate = statsStorage.currentFirstEventDate {
             let secondsSinceFirstEvent = timeNow.timeIntervalSince1970 - firstEventDate.timeIntervalSince1970
             
             result = secondsSinceFirstEvent > minSecondsInterval


public extension ScenarioProtocol {
    static var customConditions: (() -> Bool)? {
        get { return config.customConditions }
        set { config.customConditions = newValue }
    }

    static var maxExecutionsPermitted: Int? {
        get { return config.maxExecutionsPermitted }
        set { config.maxExecutionsPermitted = newValue }
    }

    static var minEventsRequired: Int? {
        get { return config.minEventsRequired }
        set { config.minEventsRequired = newValue }
    }

    static var minSecondsBetweenExecutions: TimeInterval? {
        get { return config.minSecondsBetweenExecutions }
        set { config.minSecondsBetweenExecutions = newValue }
    }

    static var maxEventsPermitted: Int? {
        get { return config.maxEventsPermitted }
        set { config.maxEventsPermitted = newValue }
    }

    static var minSecondsSinceFirstEvent: TimeInterval? {
        get { return config.minSecondsSinceFirstEvent }
        set { config.minSecondsSinceFirstEvent = newValue }
    }

    static var minSecondsSinceLastEvent: TimeInterval? {
        get { return config.minSecondsSinceLastEvent }
        set { config.minSecondsSinceLastEvent = newValue }
    }

    static func triggerEvent() {

        let result: Bool
        
        if let minSecondsInterval = minSecondsBetweenExecutions,
            let lastExecutionDate = statsStorage.currentLastExecutionDate {
            let secondsSinceLastExecution = timeNow.timeIntervalSince1970 - lastExecutionDate.timeIntervalSince1970
            
            result = secondsSinceLastExecution > minSecondsInterval
