diff --git a/CHANGES.txt b/CHANGES.txt
index 753ae5eee..afa7531da 100644
--- a/CHANGES.txt
+++ b/CHANGES.txt
@@ -306,7 +306,7 @@
  - Added client dependency to event background task
 
 0.2.0: (Apr 25, 2018)
- - Added events listener. Available events: SplitEvent.sdkReady and SplitEvent.sdkReadyTimedOut
+ - Added events listener. Available events: SplitEventCase.sdkReady and SplitEventCase.sdkReadyTimedOut
 
 0.1.5: (Mar 19, 2018)
  - Added first load from cache
diff --git a/README.md b/README.md
index c1a533bd4..e7b006628 100644
--- a/README.md
+++ b/README.md
@@ -34,7 +34,7 @@ let factory = factoryBuilder.build()
 let client = factory?.client
 
 // Subscribe to SDK READY event and evaluate your feature flag
-client?.on(event: SplitEvent.sdkReady) {
+client?.on(event: SplitEventCase.sdkReady) {
     if let client = client {
         let treatment = client.getTreatment("my_first_feature_flag")
         if treatment == "on" {
diff --git a/Split/Api/DefaultSplitClient.swift b/Split/Api/DefaultSplitClient.swift
index bbf3aa8a7..84a1bebb9 100644
--- a/Split/Api/DefaultSplitClient.swift
+++ b/Split/Api/DefaultSplitClient.swift
@@ -12,7 +12,7 @@ import Foundation
 typealias DestroyHandler = () -> Void
 
 public final class DefaultSplitClient: NSObject, SplitClient, TelemetrySplitClient {
-
+        
     private var storageContainer: SplitStorageContainer
     private var key: Key
     private let config: SplitClientConfig
@@ -55,52 +55,48 @@ public final class DefaultSplitClient: NSObject, SplitClient, TelemetrySplitClie
     }
 }
 
-// MARK: Events
+// MARK: Events Listeners
 extension DefaultSplitClient {
+    
+    private func onWithMetadata(event: SplitEvent, runInBackground: Bool, queue: DispatchQueue?, execute actionWithMetadata: @escaping SplitActionWithMetadata) {
+        guard let factory = clientManager?.splitFactory else { return }
+        let task = SplitEventActionTask(action: actionWithMetadata, event: event.type, runInBackground: runInBackground, factory: factory, queue: queue)
+        on(event: event.type, executeTask: task)
+    }
+    
+    public func on(event: SplitEventCase, executeWithMetadata action: SplitActionWithMetadata?) {
+        guard let action = action else { return }
+        onWithMetadata(event: SplitEvent(type: event, metadata: nil), runInBackground: true, queue: nil, execute: action)
+    }
+    
+    private func on(event: SplitEventCase, executeTask task: SplitEventActionTask) {
+        if  event != .sdkReadyFromCache, eventsManager.eventAlreadyTriggered(event: event) {
+            Logger.w("A handler was added for \(event.toString()) on the SDK, which has already fired and won’t be emitted again. The callback won’t be executed.")
+            return
+        }
+        eventsManager.register(event: SplitEvent(type: event, metadata: nil), task: task)
+    }
+    
+    private func on(event: SplitEventCase, runInBackground: Bool, queue: DispatchQueue?, execute action: @escaping SplitAction) {
+        guard let factory = clientManager?.splitFactory else { return }
+        let task = SplitEventActionTask(action: action, event: event, runInBackground: runInBackground, factory: factory, queue: queue)
+        on(event: event, executeTask: task)
+    }
 
-    public func on(event: SplitEvent, execute action: @escaping SplitAction) {
+    public func on(event: SplitEventCase, execute action: @escaping SplitAction) {
         on(event: event, runInBackground: false, queue: nil, execute: action)
     }
 
-    public func on(event: SplitEvent, runInBackground: Bool,
-                   execute action: @escaping SplitAction) {
+    public func on(event: SplitEventCase, runInBackground: Bool, execute action: @escaping SplitAction) {
         on(event: event, runInBackground: runInBackground, queue: nil, execute: action)
     }
 
-    public func on(event: SplitEvent,
-                   queue: DispatchQueue, execute action: @escaping SplitAction) {
+    public func on(event: SplitEventCase, queue: DispatchQueue, execute action: @escaping SplitAction) {
         on(event: event, runInBackground: true, queue: queue, execute: action)
     }
-
-    private func on(event: SplitEvent,
-                    runInBackground: Bool,
-                    queue: DispatchQueue?,
-                    execute action: @escaping SplitAction) {
-
-        guard let factory = clientManager?.splitFactory else {
-            return
-        }
-
-        let task = SplitEventActionTask(action: action, event: event,
-                                        runInBackground: runInBackground,
-                                        factory: factory,
-                                        queue: queue)
-        task.event = event
-        on(event: event, executeTask: task)
-    }
-
-    private func on(event: SplitEvent, executeTask task: SplitEventTask) {
-        if  event != .sdkReadyFromCache,
-            eventsManager.eventAlreadyTriggered(event: event) {
-            Logger.w("A handler was added for \(event.toString()) on the SDK, " +
-                     "which has already fired and won’t be emitted again. The callback won’t be executed.")
-            return
-        }
-        eventsManager.register(event: event, task: task)
-    }
 }
 
-// MARK: Treatment / Evaluation
+// MARK: Treatments
 extension DefaultSplitClient {
     public func getTreatmentWithConfig(_ split: String) -> SplitResult {
         return treatmentManager.getTreatmentWithConfig(split, attributes: nil, evaluationOptions: nil)
@@ -127,7 +123,7 @@ extension DefaultSplitClient {
     }
 }
 
-// MARK: Treatment / Evaluation with Properties
+// MARK: With Properties
 extension DefaultSplitClient {
     public func getTreatment(_ split: String, attributes: [String: Any]?, evaluationOptions: EvaluationOptions?) -> String {
         return treatmentManager.getTreatment(split, attributes: attributes, evaluationOptions: evaluationOptions)
@@ -164,7 +160,7 @@ extension DefaultSplitClient {
     }
 }
 
-// MARK: Track Events
+// MARK: Tracking
 extension DefaultSplitClient {
 
     public func track(trafficType: String, eventType: String) -> Bool {
@@ -214,7 +210,7 @@ extension DefaultSplitClient {
     }
 }
 
-// MARK: Persistent attributes feature
+// MARK: Persistence
 extension DefaultSplitClient {
 
     public func setAttribute(name: String, value: Any) -> Bool {
@@ -270,7 +266,7 @@ extension DefaultSplitClient {
     }
 }
 
-// MARK: By Sets evaluation
+// MARK: By FlagSets
 extension DefaultSplitClient {
     public func getTreatmentsByFlagSet(_ flagSet: String, attributes: [String: Any]?) -> [String: String] {
         return treatmentManager.getTreatmentsByFlagSet(flagSet: flagSet, attributes: attributes, evaluationOptions: nil)
@@ -290,7 +286,7 @@ extension DefaultSplitClient {
     }
 }
 
-// MARK: Flush / Destroy
+// MARK: Lifecycle
 extension DefaultSplitClient {
 
     private func syncFlush() {
diff --git a/Split/Api/FailHelpers.swift b/Split/Api/FailHelpers.swift
index 6f90ba7b7..bd91d69eb 100644
--- a/Split/Api/FailHelpers.swift
+++ b/Split/Api/FailHelpers.swift
@@ -10,9 +10,9 @@ import Foundation
 
 /// To avoid crashing host app this dummy components will be returned
 /// on Failed init
-///
 
 class FailedClient: SplitClient {
+    func on(event: SplitEventCase, executeWithMetadata: SplitActionWithMetadata) {}
 
     func getTreatment(_ split: String) -> String {
         return SplitConstants.control
@@ -53,15 +53,18 @@ class FailedClient: SplitClient {
     func getTreatmentsWithConfig(splits: [String], attributes: [String: Any]?, evaluationOptions: EvaluationOptions?) -> [String: SplitResult] {
         return [:]
     }
+    
+    public func on(event: SplitEventCase, perform: SplitAction?) {}
+    
+    func on(event: SplitEventCase, perform: @escaping ([String : Any]?) -> Void) {}
 
-    func on(event: SplitEvent, execute action: @escaping SplitAction) {
-    }
+    func on(event: SplitEventCase, execute action: @escaping SplitAction) {}
 
-    func on(event: SplitEvent, runInBackground: Bool,
+    func on(event: SplitEventCase, runInBackground: Bool,
             execute action: @escaping SplitAction) {
     }
 
-    func on(event: SplitEvent,
+    func on(event: SplitEventCase,
             queue: DispatchQueue, execute action: @escaping SplitAction) {
     }
 
@@ -137,14 +140,11 @@ class FailedClient: SplitClient {
         return [:]
     }
 
-    func setUserConsent(enabled: Bool) {
-    }
+    func setUserConsent(enabled: Bool) {}
 
-    func flush() {
-    }
+    func flush() {}
 
-    func destroy() {
-    }
+    func destroy() {}
 
     func destroy(completion: (() -> Void)?) {
         completion?()
diff --git a/Split/Api/LocalhostSplitClient.swift b/Split/Api/LocalhostSplitClient.swift
index 2aaacca6b..5a2efc05b 100644
--- a/Split/Api/LocalhostSplitClient.swift
+++ b/Split/Api/LocalhostSplitClient.swift
@@ -51,10 +51,7 @@ public final class LocalhostSplitClient: NSObject, SplitClient {
     private let key: Key
     weak var clientManger: SplitClientManager?
 
-    init(key: Key, splitsStorage: SplitsStorage,
-         clientManager: SplitClientManager?,
-         eventsManager: SplitEventsManager? = nil,
-         evaluator: Evaluator) {
+    init(key: Key, splitsStorage: SplitsStorage, clientManager: SplitClientManager?, eventsManager: SplitEventsManager? = nil, evaluator: Evaluator) {
         self.eventsManager = eventsManager
         self.key = key
         self.splitsStorage = splitsStorage
@@ -64,6 +61,7 @@ public final class LocalhostSplitClient: NSObject, SplitClient {
         super.init()
     }
 
+    // MARK: Treatments
     public func getTreatment(_ split: String, attributes: [String: Any]?) -> String {
         return getTreatmentWithConfig(split).treatment
     }
@@ -120,26 +118,53 @@ public final class LocalhostSplitClient: NSObject, SplitClient {
         }
         return results
     }
+    
+    // MARK: Events Listeners
+    public func on(event: SplitEventCase, perform: SplitAction?) {
+        guard let perform = perform else { return }
+        on(event: event, execute: perform)
+    }
+    
+    public func on(event: SplitEventCase, executeWithMetadata: @escaping SplitActionWithMetadata) {
+        on(eventWithMetadata: SplitEvent(type: event, metadata: nil), runInBackground: false, queue: nil, execute: executeWithMetadata)
+    }
 
-    public func on(event: SplitEvent, runInBackground: Bool,
+    public func on(event: SplitEventCase, runInBackground: Bool,
                    execute action: @escaping SplitAction) {
         on(event: event, runInBackground: runInBackground, queue: nil, execute: action)
     }
 
-    public func on(event: SplitEvent, queue: DispatchQueue, execute action: @escaping SplitAction) {
+    public func on(event: SplitEventCase, queue: DispatchQueue, execute action: @escaping SplitAction) {
         on(event: event, runInBackground: true, queue: queue, execute: action)
     }
 
-    public func on(event: SplitEvent, execute action: @escaping SplitAction) {
+    public func on(event: SplitEventCase, execute action: @escaping SplitAction) {
         on(event: event, runInBackground: false, queue: nil, execute: action)
     }
 
-    private func on(event: SplitEvent, runInBackground: Bool,
+    private func on(event: SplitEventCase, runInBackground: Bool, queue: DispatchQueue?, execute action: @escaping SplitAction) {
+        on(eventWithMetadata: SplitEvent(type: event, metadata: nil), runInBackground: runInBackground, queue: queue, execute: action)
+    }
+    
+    private func on(eventWithMetadata event: SplitEvent, runInBackground: Bool,
                     queue: DispatchQueue?, execute action: @escaping SplitAction) {
 
         guard let factory = clientManger?.splitFactory else { return }
         if let eventsManager = self.eventsManager {
-            let task = SplitEventActionTask(action: action, event: event,
+            let task = SplitEventActionTask(action: action, event: event.type,
+                                            runInBackground: runInBackground,
+                                            factory: factory,
+                                            queue: queue)
+            eventsManager.register(event: event, task: task)
+        }
+    }
+    
+    private func on(eventWithMetadata event: SplitEvent, runInBackground: Bool,
+                    queue: DispatchQueue?, execute action: @escaping SplitActionWithMetadata) {
+
+        guard let factory = clientManger?.splitFactory else { return }
+        if let eventsManager = self.eventsManager {
+            let task = SplitEventActionTask(action: action, event: event.type,
                                             runInBackground: runInBackground,
                                             factory: factory,
                                             queue: queue)
@@ -147,6 +172,7 @@ public final class LocalhostSplitClient: NSObject, SplitClient {
         }
     }
 
+    // MARK: Tracking
     public func track(trafficType: String, eventType: String) -> Bool {
         return true
     }
@@ -179,11 +205,10 @@ public final class LocalhostSplitClient: NSObject, SplitClient {
         return true
     }
 
-    public func setUserConsent(enabled: Bool) {
-    }
+    public func setUserConsent(enabled: Bool) {}
 
-    public func flush() {
-    }
+    // MARK: Lifecycle
+    public func flush() {}
 
     public func destroy() {
         splitsStorage.destroy()
@@ -195,7 +220,7 @@ public final class LocalhostSplitClient: NSObject, SplitClient {
     }
 }
 
-// MARK: Persistent attributes feature
+// MARK: Persistence
 extension LocalhostSplitClient {
 
     public func setAttribute(name: String, value: Any) -> Bool {
@@ -223,7 +248,7 @@ extension LocalhostSplitClient {
     }
 }
 
-// MARK: TreatmentBySets Feature
+// MARK: By Flagset
 extension LocalhostSplitClient {
     public func getTreatmentsByFlagSet(_ flagSet: String, attributes: [String: Any]?) -> [String: String] {
         return [String: String]()
diff --git a/Split/Api/SplitClient.swift b/Split/Api/SplitClient.swift
index ff4df2005..4d48eb7d1 100644
--- a/Split/Api/SplitClient.swift
+++ b/Split/Api/SplitClient.swift
@@ -8,91 +8,78 @@
 
 import Foundation
 
-public typealias SplitAction = () -> Void
-
 @objc public protocol SplitClient {
+    
+    // MARK: Listeners for customer
+    func on(event: SplitEventCase, execute action: @escaping SplitAction)
+    func on(event: SplitEventCase, executeWithMetadata: @escaping SplitActionWithMetadata) -> Void
+    func on(event: SplitEventCase, runInBackground: Bool, execute action: @escaping SplitAction)
+    func on(event: SplitEventCase, queue: DispatchQueue, execute action: @escaping SplitAction)
+    
 
-    // MARK: Evaluation feature
+    // MARK: Treatments
     func getTreatment(_ split: String, attributes: [String: Any]?) -> String
     func getTreatment(_ split: String) -> String
-    @objc(getTreatmentsForSplits:attributes:) func getTreatments(splits: [String],
-                                                                 attributes: [String: Any]?) -> [String: String]
-
+    @objc(getTreatmentsForSplits:attributes:)
+    func getTreatments(splits: [String], attributes: [String: Any]?) -> [String: String]
+    
+    // With config
     func getTreatmentWithConfig(_ split: String) -> SplitResult
     func getTreatmentWithConfig(_ split: String, attributes: [String: Any]?) -> SplitResult
-
     @objc(getTreatmentsWithConfigForSplits:attributes:)
     func getTreatmentsWithConfig(splits: [String], attributes: [String: Any]?) -> [String: SplitResult]
     
-    // MARK: Evaluation with Properties
+    // With Properties
     func getTreatment(_ split: String, attributes: [String: Any]?, evaluationOptions: EvaluationOptions?) -> String
-    @objc(getTreatmentsForSplits:attributes:evaluationOptions:) func getTreatments(splits: [String],
-                                                                 attributes: [String: Any]?,
-                                                                 evaluationOptions: EvaluationOptions?) -> [String: String]
+    @objc(getTreatmentsForSplits:attributes:evaluationOptions:)
+    func getTreatments(splits: [String], attributes: [String: Any]?, evaluationOptions: EvaluationOptions?) -> [String: String]
     func getTreatmentWithConfig(_ split: String, attributes: [String: Any]?, evaluationOptions: EvaluationOptions?) -> SplitResult
     @objc(getTreatmentsWithConfigForSplits:attributes:evaluationOptions:)
     func getTreatmentsWithConfig(splits: [String], attributes: [String: Any]?, evaluationOptions: EvaluationOptions?) -> [String: SplitResult]
-
-    func on(event: SplitEvent, execute action: @escaping SplitAction)
-    func on(event: SplitEvent, runInBackground: Bool, execute action: @escaping SplitAction)
-    func on(event: SplitEvent, queue: DispatchQueue, execute action: @escaping SplitAction)
-
-    // MARK: Track feature
+    
+    // By Flagset
+    func getTreatmentsByFlagSet(_ flagSet: String, attributes: [String: Any]?) -> [String: String]
+    func getTreatmentsByFlagSets(_ flagSets: [String], attributes: [String: Any]?) -> [String: String]
+    func getTreatmentsWithConfigByFlagSet(_ flagSet: String, attributes: [String: Any]?) -> [String: SplitResult]
+    func getTreatmentsWithConfigByFlagSets(_ flagSets: [String], attributes: [String: Any]?) -> [String: SplitResult]
+    func getTreatmentsByFlagSet(_ flagSet: String, attributes: [String: Any]?, evaluationOptions: EvaluationOptions?) -> [String: String]
+    func getTreatmentsByFlagSets(_ flagSets: [String], attributes: [String: Any]?, evaluationOptions: EvaluationOptions?) -> [String: String]
+    func getTreatmentsWithConfigByFlagSet(_ flagSet: String, attributes: [String: Any]?, evaluationOptions: EvaluationOptions?) -> [String: SplitResult]
+    func getTreatmentsWithConfigByFlagSets(_ flagSets: [String], attributes: [String: Any]?, evaluationOptions: EvaluationOptions?) -> [String: SplitResult]
+    
+    
+    // MARK: Tracking
     func track(trafficType: String, eventType: String) -> Bool
     func track(trafficType: String, eventType: String, value: Double) -> Bool
     func track(eventType: String) -> Bool
     func track(eventType: String, value: Double) -> Bool
+    @objc(trackWithTrafficType:eventType:properties:)
+    func track(trafficType: String, eventType: String, properties: [String: Any]?) -> Bool
+    @objc(trackWithTrafficType:eventType:value:properties:)
+    func track(trafficType: String, eventType: String, value: Double, properties: [String: Any]?) -> Bool
+    @objc(trackWithEventType:properties:)
+    func track(eventType: String, properties: [String: Any]?) -> Bool
+    @objc(trackWithEventType:value:properties:)
+    func track(eventType: String, value: Double, properties: [String: Any]?) -> Bool
 
-    // MARK: Persistent attributes feature
-
-    /// Creates or updates the value for the given attribute
+    
+    // MARK: Persistence
+    /// Creates or updates the value for the given attribute/
     func setAttribute(name: String, value: Any) -> Bool
-
-    /// Retrieves the value of a given attribute so it can be checked by the customer if needed
+    /// Retrieves the value of a given attribute so it can be checked by the customer if needed/
     func getAttribute(name: String) -> Any?
-
-    /// It will create or update all the given attributes
+    /// It will create or update all the given attributes/
     func setAttributes(_ values: [String: Any]) -> Bool
-
-    /// Retrieve the full attributes map
+    /// Retrieve the full attributes map/
     func getAttributes() -> [String: Any]?
-
-    /// Removes a given attribute from the map
+    /// Removes a given attribute from the map/
     func removeAttribute(name: String) -> Bool
-
-    /// Clears all attributes stored in the SDK.
+    /// Clears all attributes stored in the SDK./
     func clearAttributes() -> Bool
-
-    // MARK: Client lifecycle
+    
+    
+    // MARK: Lifecycle
     func flush()
     func destroy()
     func destroy(completion: (() -> Void)?)
-
-    @objc(trackWithTrafficType:eventType:properties:) func track(trafficType: String,
-                                                                 eventType: String,
-                                                                 properties: [String: Any]?) -> Bool
-
-    @objc(trackWithTrafficType:eventType:value:properties:) func track(trafficType: String,
-                                                                       eventType: String,
-                                                                       value: Double,
-                                                                       properties: [String: Any]?) -> Bool
-
-    @objc(trackWithEventType:properties:) func track(eventType: String,
-                                                     properties: [String: Any]?) -> Bool
-
-    @objc(trackWithEventType:value:properties:) func track(eventType: String,
-                                                           value: Double,
-                                                           properties: [String: Any]?) -> Bool
-
-    // MARK: Evaluation with flagsets
-    func getTreatmentsByFlagSet(_ flagSet: String, attributes: [String: Any]?) -> [String: String]
-    func getTreatmentsByFlagSets(_ flagSets: [String], attributes: [String: Any]?) -> [String: String]
-    func getTreatmentsWithConfigByFlagSet(_ flagSet: String, attributes: [String: Any]?) -> [String: SplitResult]
-    func getTreatmentsWithConfigByFlagSets(_ flagSets: [String], attributes: [String: Any]?) -> [String: SplitResult]
-    
-    // MARK: Evaluation with flagsets and properties
-    func getTreatmentsByFlagSet(_ flagSet: String, attributes: [String: Any]?, evaluationOptions: EvaluationOptions?) -> [String: String]
-    func getTreatmentsByFlagSets(_ flagSets: [String], attributes: [String: Any]?, evaluationOptions: EvaluationOptions?) -> [String: String]
-    func getTreatmentsWithConfigByFlagSet(_ flagSet: String, attributes: [String: Any]?, evaluationOptions: EvaluationOptions?) -> [String: SplitResult]
-    func getTreatmentsWithConfigByFlagSets(_ flagSets: [String], attributes: [String: Any]?, evaluationOptions: EvaluationOptions?) -> [String: SplitResult]
 }
diff --git a/Split/Api/SplitClientManager.swift b/Split/Api/SplitClientManager.swift
index 6cdbf743a..9777010ed 100644
--- a/Split/Api/SplitClientManager.swift
+++ b/Split/Api/SplitClientManager.swift
@@ -88,7 +88,7 @@ class DefaultClientManager: SplitClientManager {
                 }
             }
 
-            defaultClient?.on(event: .sdkReady) {
+            defaultClient?.on(event: .sdkReadyFromCache) {
                 DispatchQueue.general.async { [weak self] in
                     if let self = self {
                         producer.recordTimeUntilReady(self.telemetryStopwatch?.interval() ?? 0)
diff --git a/Split/Engine/DefaultTreatmentManager.swift b/Split/Engine/DefaultTreatmentManager.swift
index 73594b32e..8eeed9f46 100644
--- a/Split/Engine/DefaultTreatmentManager.swift
+++ b/Split/Engine/DefaultTreatmentManager.swift
@@ -337,8 +337,8 @@ extension DefaultTreatmentManager {
     }
 
     private func isSdkReady() -> Bool {
-        return eventsManager.eventAlreadyTriggered(event: SplitEvent.sdkReadyFromCache) ||
-            eventsManager.eventAlreadyTriggered(event: SplitEvent.sdkReady)
+        return eventsManager.eventAlreadyTriggered(event: SplitEventCase.sdkReadyFromCache) ||
+        eventsManager.eventAlreadyTriggered(event: .sdkReady)
     }
 
     private func checkAndLogIfDestroyed(logTag: String) -> Bool {
diff --git a/Split/Events/EventsManagerCoordinator.swift b/Split/Events/EventsManagerCoordinator.swift
index 3ddf4fe93..6cf5ff40a 100644
--- a/Split/Events/EventsManagerCoordinator.swift
+++ b/Split/Events/EventsManagerCoordinator.swift
@@ -14,17 +14,27 @@ protocol SplitEventsManagerCoordinator: SplitEventsManager {
 }
 
 class MainSplitEventsManager: SplitEventsManagerCoordinator {
+        
     private var defaultManager: SplitEventsManager?
     private var managers = [Key: SplitEventsManager]()
-    private var triggered = Set<SplitInternalEvent>()
+    private var triggered = Set<SplitInternalEventCase>()
     private let queue = DispatchQueue(label: "split-event-manager-coordinator")
-    private let eventsToHandle: Set<SplitInternalEvent> = Set(
+    private let eventsToHandle: Set<SplitInternalEventCase> = Set(
         [.splitsLoadedFromCache,
         .splitsUpdated,
         .splitKilledNotification]
     )
-
+    
+    // MARK: Notifications
+    func notifyInternalEvent(_ event: SplitInternalEventCase) {
+        notifyInternalEvent(event, metadata: SplitMetadata(type: "", value: ""))
+    }
+    
     func notifyInternalEvent(_ event: SplitInternalEvent) {
+        notifyInternalEvent(event.type, metadata: event.metadata ?? SplitMetadata(type: "", value: ""))
+    }
+
+    func notifyInternalEvent(_ event: SplitInternalEventCase, metadata: SplitMetadata) {
         if !eventsToHandle.contains(event) {
             return
         }
@@ -33,7 +43,7 @@ class MainSplitEventsManager: SplitEventsManagerCoordinator {
 
             self.triggered.insert(event)
             self.managers.forEach { _, manager in
-                manager.notifyInternalEvent(event)
+                manager.notifyInternalEvent(event, metadata: metadata)
             }
         }
     }
@@ -50,7 +60,7 @@ class MainSplitEventsManager: SplitEventsManagerCoordinator {
         }
     }
 
-    func eventAlreadyTriggered(event: SplitEvent) -> Bool {
+    func eventAlreadyTriggered(event: SplitEventCase) -> Bool {
         return defaultManager?.eventAlreadyTriggered(event: event) ?? false
     }
 
@@ -76,5 +86,5 @@ class MainSplitEventsManager: SplitEventsManagerCoordinator {
         }
     }
 
-    func register(event: SplitEvent, task: SplitEventTask) {}
+    func register(event: SplitEvent, task: SplitEventActionTask) {}
 }
diff --git a/Split/Events/SplitEvent.swift b/Split/Events/SplitEvent.swift
index d2561e2d9..77bf30445 100644
--- a/Split/Events/SplitEvent.swift
+++ b/Split/Events/SplitEvent.swift
@@ -1,5 +1,5 @@
 //
-//  SplitEvent.swift
+//  SplitEventCase.swift
 //  Split
 //
 //  Created by Sebastian Arrubia on 4/17/18.
@@ -7,7 +7,22 @@
 
 import Foundation
 
-@objc public enum SplitEvent: Int {
+@objcMembers public class SplitEvent: NSObject {
+    let type: SplitEventCase
+    let metadata: SplitMetadata?
+    
+    @objc public init(type: SplitEventCase, metadata: SplitMetadata? = nil) {
+        self.type = type
+        self.metadata = metadata
+    }
+    
+    public override func isEqual(_ object: Any?) -> Bool {
+        guard let other = object as? SplitEvent else { return false }
+        return self.type == other.type
+    }
+}
+
+@objc public enum SplitEventCase: Int {
     case sdkReady
     case sdkReadyTimedOut
     case sdkReadyFromCache
@@ -15,14 +30,26 @@ import Foundation
 
     public func toString() -> String {
         switch self {
-        case .sdkReady:
-            return "SDK_READY"
-        case .sdkUpdated:
-            return "SDK_UPDATE"
-        case .sdkReadyTimedOut:
-            return "SDK_READY_TIMED_OUT"
-        case .sdkReadyFromCache:
-            return "SDK_READY_FROM_CACHE"
+            case .sdkReady:
+                return "SDK_READY"
+            case .sdkUpdated:
+                return "SDK_UPDATE"
+            case .sdkReadyTimedOut:
+                return "SDK_READY_TIMED_OUT"
+            case .sdkReadyFromCache:
+                return "SDK_READY_FROM_CACHE"
         }
     }
 }
+
+// Just a key-value wrapper for extensibility.
+// (Also used by SplitInternalEvent)
+@objc public class SplitMetadata: NSObject {
+    var type: String = ""
+    var value: String = ""
+    
+    init(type: String, value: String) {
+        self.type = type
+        self.value = value
+    }
+}
diff --git a/Split/Events/SplitEventActionTask.swift b/Split/Events/SplitEventActionTask.swift
index be1368d04..3236af6a0 100644
--- a/Split/Events/SplitEventActionTask.swift
+++ b/Split/Events/SplitEventActionTask.swift
@@ -7,20 +7,27 @@
 
 import Foundation
 
-class SplitEventActionTask: SplitEventTask {
+public typealias SplitAction = () -> Void
+public typealias SplitActionWithMetadata = (_ metadata: SplitMetadata?) -> Void
 
+class SplitEventActionTask: SplitEventTask {
+    
     private var eventHandler: SplitAction?
+    private var eventHandlerWithMetadata: SplitActionWithMetadata?
     private var queue: DispatchQueue?
-    var event: SplitEvent
+    var event: SplitEventCase
     var runInBackground: Bool = false
     var factory: SplitFactory
 
-    init(action: @escaping SplitAction,
-         event: SplitEvent,
-         runInBackground: Bool = false,
-         factory: SplitFactory,
-         queue: DispatchQueue? = nil) {
-
+    init(action: @escaping SplitActionWithMetadata, event: SplitEventCase, runInBackground: Bool = false, factory: SplitFactory, queue: DispatchQueue? = nil) {
+        self.eventHandlerWithMetadata = action
+        self.event = event
+        self.runInBackground = runInBackground
+        self.queue = queue
+        self.factory = factory
+    }
+    
+    init(action: @escaping SplitAction, event: SplitEventCase, runInBackground: Bool = false, factory: SplitFactory, queue: DispatchQueue? = nil) {
         self.eventHandler = action
         self.event = event
         self.runInBackground = runInBackground
@@ -33,7 +40,8 @@ class SplitEventActionTask: SplitEventTask {
         return queue
     }
 
-    func run() {
+    func run(_ metadata: SplitMetadata?) {
         eventHandler?()
+        eventHandlerWithMetadata?(metadata)
     }
 }
diff --git a/Split/Events/SplitEventTask.swift b/Split/Events/SplitEventTask.swift
index 1655e2b25..aa398347c 100644
--- a/Split/Events/SplitEventTask.swift
+++ b/Split/Events/SplitEventTask.swift
@@ -8,8 +8,8 @@
 import Foundation
 
 protocol SplitEventTask {
-    var event: SplitEvent { get }
+    var event: SplitEventCase { get }
     var runInBackground: Bool { get }
     func takeQueue() -> DispatchQueue?
-    func run()
+    func run(_ metadata: SplitMetadata?)
 }
diff --git a/Split/Events/SplitEventsManager.swift b/Split/Events/SplitEventsManager.swift
index 56774453b..5886cf61d 100644
--- a/Split/Events/SplitEventsManager.swift
+++ b/Split/Events/SplitEventsManager.swift
@@ -9,25 +9,30 @@
 import Foundation
 
 protocol SplitEventsManager: AnyObject {
-    func register(event: SplitEvent, task: SplitEventTask)
+    func register(event: SplitEvent, task: SplitEventActionTask)
+    func notifyInternalEvent(_ event: SplitInternalEventCase)
+    func notifyInternalEvent(_ event: SplitInternalEventCase, metadata: SplitMetadata)
     func notifyInternalEvent(_ event: SplitInternalEvent)
     func start()
     func stop()
-    func eventAlreadyTriggered(event: SplitEvent) -> Bool
+    func eventAlreadyTriggered(event: SplitEventCase) -> Bool
 }
 
 class DefaultSplitEventsManager: SplitEventsManager {
+    
     private let readingRefreshTime: Int
 
     private var sdkReadyTimeStart: Int64
 
-    private var subscriptions = [SplitEvent: [SplitEventTask]]()
+    private var subscriptions = [SplitEventCase: [SplitEventTask]]()
     private var executionTimes: [String: Int]
     private var triggered: [SplitInternalEvent]
     private let processQueue: DispatchQueue
     private let dataAccessQueue: DispatchQueue
     private var isStarted: Bool
     private var eventsQueue: InternalEventBlockingQueue
+    
+    private let lock = NSLock()
 
     init(config: SplitClientConfig) {
         self.processQueue = DispatchQueue(label: "split-evt-mngr-process", attributes: .concurrent)
@@ -44,48 +49,58 @@ class DefaultSplitEventsManager: SplitEventsManager {
             let readyTimedoutQueue = DispatchQueue(label: "split-event-timedout")
             readyTimedoutQueue.asyncAfter(deadline: .now() + .milliseconds(config.sdkReadyTimeOut)) {  [weak self] in
                 guard let self = self else { return }
-                self.notifyInternalEvent(SplitInternalEvent.sdkReadyTimeoutReached)
+                self.notifyInternalEvent(.sdkReadyTimeoutReached)
             }
         }
     }
-
+    
+    // MARK: Notifications
+    /* Overload kept for backwards compatibility.
+       It allows calling `notifyInternalEvent(.event)` without needing to pass `nil` as metadata.
+       Do not remove unless all usages have migrated to the new signature. */
+    func notifyInternalEvent(_ event: SplitInternalEventCase) {
+        notifyInternalEvent(SplitInternalEvent(event, metadata: nil))
+    }
+    
+    func notifyInternalEvent(_ event: SplitInternalEventCase, metadata: SplitMetadata) {
+        notifyInternalEvent(SplitInternalEvent(event, metadata: metadata))
+    }
+    
     func notifyInternalEvent(_ event: SplitInternalEvent) {
         processQueue.async { [weak self] in
             if let self = self {
-                Logger.v("Event \(event) notified")
                 self.eventsQueue.add(event)
             }
         }
     }
 
-    func register(event: SplitEvent, task: SplitEventTask) {
-        let eventName = event.toString()
+    // MARK: Register
+    func register (event: SplitEvent, task: SplitEventActionTask) {
+        let eventName = event.type.toString()
         processQueue.async { [weak self] in
             guard let self = self else { return }
             // If event is already triggered, execute the task
             if let times = self.executionTimes(for: eventName), times == 0 {
-                self.executeTask(event: event, task: task)
+                self.executeTask(eventWithMetadata: event, task: task)
                 return
             }
-            self.subscribe(task: task, to: event)
+            self.subscribe(task: task, to: event.type)
         }
     }
 
     func start() {
-        dataAccessQueue.sync {
-            if self.isStarted {
-                return
+        lock.lock()
+            if !isStarted {
+                isStarted = true
             }
-            self.isStarted = true
-        }
+        lock.unlock()
+            
         processQueue.async { [weak self] in
-            if let self = self {
-                self.processEvents()
-            }
+            self?.processEvents()
         }
     }
 
-    func eventAlreadyTriggered(event: SplitEvent) -> Bool {
+    func eventAlreadyTriggered(event: SplitEventCase) -> Bool {
         var isTriggered = false
         processQueue.sync {
             isTriggered = self.isTriggered(external: event)
@@ -114,10 +129,10 @@ class DefaultSplitEventsManager: SplitEventsManager {
      */
     private func registerMaxAllowedExecutionTimesPerEvent() {
 
-        executionTimes = [ SplitEvent.sdkReady.toString(): 1,
-                           SplitEvent.sdkUpdated.toString(): -1,
-                           SplitEvent.sdkReadyFromCache.toString(): 1,
-                           SplitEvent.sdkReadyTimedOut.toString(): 1]
+        executionTimes = [ SplitEventCase.sdkReady.toString(): 1,
+                           SplitEventCase.sdkUpdated.toString(): -1,
+                           SplitEventCase.sdkReadyFromCache.toString(): 1,
+                           SplitEventCase.sdkReadyTimedOut.toString(): 1]
     }
 
     private func isRunning() -> Bool {
@@ -145,38 +160,37 @@ class DefaultSplitEventsManager: SplitEventsManager {
                 return
             }
             self.triggered.append(event)
-            switch event {
-            case .splitsUpdated, .mySegmentsUpdated, .myLargeSegmentsUpdated:
-                if isTriggered(external: .sdkReady) {
-                    trigger(event: .sdkUpdated)
-                    continue
-                }
-                self.triggerSdkReadyIfNeeded()
-
-            case .mySegmentsLoadedFromCache, .myLargeSegmentsLoadedFromCache,
-                    .splitsLoadedFromCache, .attributesLoadedFromCache:
-                Logger.v("Event \(event) triggered")
-                if isTriggered(internal: .splitsLoadedFromCache),
-                   isTriggered(internal: .mySegmentsLoadedFromCache),
-                   isTriggered(internal: .myLargeSegmentsLoadedFromCache),
-                   isTriggered(internal: .attributesLoadedFromCache) {
-                    trigger(event: SplitEvent.sdkReadyFromCache)
+            switch event.type {
+                case .splitsUpdated, .mySegmentsUpdated, .myLargeSegmentsUpdated:
+                    if isTriggered(external: .sdkReady) {
+                        trigger(event: SplitEvent(type: .sdkUpdated, metadata: event.metadata))
+                        continue
+                    }
+                    self.triggerSdkReadyIfNeeded()
+
+                case .mySegmentsLoadedFromCache, .myLargeSegmentsLoadedFromCache, .splitsLoadedFromCache, .attributesLoadedFromCache:
+                    Logger.v("Event \(event.type) triggered")
+                    if isTriggered(internal: .splitsLoadedFromCache),
+                       isTriggered(internal: .mySegmentsLoadedFromCache),
+                       isTriggered(internal: .myLargeSegmentsLoadedFromCache),
+                       isTriggered(internal: .attributesLoadedFromCache) {
+                        trigger(event: SplitEventCase.sdkReadyFromCache)
+                    }
+                case .splitKilledNotification:
+                    if isTriggered(external: .sdkReady) {
+                        trigger(event: .sdkUpdated)
+                        continue
+                    }
+                case .sdkReadyTimeoutReached:
+                    if !isTriggered(external: .sdkReady) {
+                        trigger(event: SplitEventCase.sdkReadyTimedOut)
+                    }
                 }
-            case .splitKilledNotification:
-                if isTriggered(external: .sdkReady) {
-                    trigger(event: .sdkUpdated)
-                    continue
-                }
-            case .sdkReadyTimeoutReached:
-                if !isTriggered(external: .sdkReady) {
-                    trigger(event: SplitEvent.sdkReadyTimedOut)
-                }
-            }
         }
     }
 
     // MARK: Helper functions.
-    func isTriggered(external event: SplitEvent) -> Bool {
+    func isTriggered(external event: SplitEventCase) -> Bool {
         var triggered = false
         dataAccessQueue.sync {
             if let times = executionTimes[event.toString()] {
@@ -193,12 +207,16 @@ class DefaultSplitEventsManager: SplitEventsManager {
            isTriggered(internal: .splitsUpdated),
            isTriggered(internal: .myLargeSegmentsUpdated),
            !isTriggered(external: .sdkReady) {
-            self.trigger(event: SplitEvent.sdkReady)
+            self.trigger(event: .sdkReady)
         }
     }
+    
+    private func trigger(event: SplitEventCase) {
+        trigger(event: SplitEvent(type: event, metadata: nil))
+    }
 
     private func trigger(event: SplitEvent) {
-        let eventName = event.toString()
+        let eventName = event.type.toString()
 
         // If executionTimes is zero, maximum executions has been reached
         if executionTimes(for: eventName) == 0 {
@@ -212,14 +230,14 @@ class DefaultSplitEventsManager: SplitEventsManager {
 
         Logger.d("Triggering SDK event \(eventName)")
         // If executionTimes is lower than zero, execute it without limitation
-        if let subscriptions = getSubscriptions(for: event) {
+        if let subscriptions = getSubscriptions(for: event.type) {
             for task in subscriptions {
-                executeTask(event: event, task: task)
+                executeTask(eventWithMetadata: event, task: task)
             }
         }
     }
 
-    private func executeTask(event: SplitEvent, task: SplitEventTask) {
+    private func executeTask(eventWithMetadata event: SplitEvent, task: SplitEventTask) {
 
         let eventName = task.event.toString()
 
@@ -229,21 +247,24 @@ class DefaultSplitEventsManager: SplitEventsManager {
             let queue = task.takeQueue() ?? DispatchQueue.general
             queue.async {
                 TimeChecker.logInterval("Running \(eventName) in Background queue \(queue)")
-                task.run()
+                task.run(event.metadata)
+            }
+        } else {
+            DispatchQueue.main.async {
+                TimeChecker.logInterval("Running event on main: \(eventName)")
+                // UI Updates
+                task.run(event.metadata)
             }
-            return
-        }
-
-        DispatchQueue.main.async {
-            TimeChecker.logInterval("Running event on main: \(eventName)")
-            // UI Updates
-            task.run()
         }
     }
 
     private func isTriggered(internal event: SplitInternalEvent) -> Bool {
         return triggered.filter { $0 == event }.count > 0
     }
+    
+    private func isTriggered(internal event: SplitInternalEventCase) -> Bool {
+        return isTriggered(internal: SplitInternalEvent(event, metadata: nil))
+    }
 
     // MARK: Safe Data Access
     func executionTimes(for eventName: String) -> Int? {
@@ -254,7 +275,7 @@ class DefaultSplitEventsManager: SplitEventsManager {
         return times
     }
 
-    func subscribe(task: SplitEventTask, to event: SplitEvent) {
+    func subscribe(task: SplitEventTask, to event: SplitEventCase) {
         dataAccessQueue.async { [weak self] in
             guard let self = self else { return }
             var subscriptions = self.subscriptions[event] ?? [SplitEventTask]()
@@ -263,7 +284,7 @@ class DefaultSplitEventsManager: SplitEventsManager {
         }
     }
 
-    private func getSubscriptions(for event: SplitEvent) -> [SplitEventTask]? {
+    private func getSubscriptions(for event: SplitEventCase) -> [SplitEventTask]? {
         var subscriptions: [SplitEventTask]?
         dataAccessQueue.sync {
             subscriptions = self.subscriptions[event]
diff --git a/Split/Events/SplitInternalEvent.swift b/Split/Events/SplitInternalEvent.swift
index 4c9521204..a089adfc3 100644
--- a/Split/Events/SplitInternalEvent.swift
+++ b/Split/Events/SplitInternalEvent.swift
@@ -3,11 +3,24 @@
 //  Split
 //
 //  Created by Sebastian Arrubia on 4/16/18.
-//
 
 import Foundation
 
-enum SplitInternalEvent {
+struct SplitInternalEvent: Equatable {
+    let type: SplitInternalEventCase
+    let metadata: SplitMetadata?
+    
+    init(_ type: SplitInternalEventCase, metadata: SplitMetadata? = nil) {
+        self.type = type
+        self.metadata = metadata
+    }
+    
+    static func == (lhs: SplitInternalEvent, rhs: SplitInternalEvent) -> Bool {
+        return lhs.type == rhs.type 
+    }
+}
+
+enum SplitInternalEventCase {
     case mySegmentsUpdated
     case myLargeSegmentsUpdated
     case splitsUpdated
diff --git a/Split/FetcherEngine/Refresh/PeriodicSyncWorker.swift b/Split/FetcherEngine/Refresh/PeriodicSyncWorker.swift
index 66065d934..a5273a898 100644
--- a/Split/FetcherEngine/Refresh/PeriodicSyncWorker.swift
+++ b/Split/FetcherEngine/Refresh/PeriodicSyncWorker.swift
@@ -171,8 +171,16 @@ class PeriodicSplitsSyncWorker: BasePeriodicSyncWorker {
         guard let result = try? syncHelper.sync(since: splitsStorage.changeNumber) else {
             return
         }
-        if result.success, result.featureFlagsUpdated {
-            notifyUpdate([.splitsUpdated])
+        if result.success, result.featureFlagsUpdated.count > 0 {
+            
+            var updatedFlags = result.featureFlagsUpdated
+            for flag in updatedFlags {
+                updatedFlags.append(flag)
+            }
+            
+            let metadata = SplitMetadata(type: "Updated Flags", value: updatedFlags.description)
+            notifyUpdate([SplitInternalEvent(.splitsUpdated, metadata: metadata)])
+            
         }
     }
 }
@@ -211,9 +219,10 @@ class PeriodicMySegmentsSyncWorker: BasePeriodicSyncWorker {
                                              mlsTill: myLargeSegmentsStorage.changeNumber,
                                              headers: nil)
             if result.success {
-                if  result.msUpdated || result.mlsUpdated {
-                    // For now is not necessary specify which entity was updated
-                    notifyUpdate([.mySegmentsUpdated])
+                if  !result.msUpdated.isEmpty || !result.mlsUpdated.isEmpty {
+                    
+                    let metadata = SplitMetadata(type: "Updated segments", value: (result.msUpdated + result.mlsUpdated).description)
+                    notifyUpdate([SplitInternalEvent(.mySegmentsUpdated, metadata: metadata)])
                 }
             }
         } catch {
diff --git a/Split/FetcherEngine/Refresh/RetryableSegmentsSyncWorker.swift b/Split/FetcherEngine/Refresh/RetryableSegmentsSyncWorker.swift
index 36973b66b..c57466ea3 100644
--- a/Split/FetcherEngine/Refresh/RetryableSegmentsSyncWorker.swift
+++ b/Split/FetcherEngine/Refresh/RetryableSegmentsSyncWorker.swift
@@ -44,13 +44,16 @@ class RetryableMySegmentsSyncWorker: BaseRetryableSyncWorker {
                                              mlsTill: changeNumbers.mlsChangeNumber,
                                              headers: getHeaders())
             if result.success {
+                let msMetadata = SplitMetadata(type: "Segments updated", value: result.msUpdated.description)
+                
                 if !isSdkReadyTriggered() {
                     // Notifying both to trigger SDK Ready
-                    notifyUpdate([.mySegmentsUpdated])
-                    notifyUpdate([.myLargeSegmentsUpdated])
-                } else if  result.msUpdated || result.mlsUpdated {
-                    // For now is not necessary specify which entity was updated
-                    notifyUpdate([.mySegmentsUpdated])
+                    notifyUpdate([SplitInternalEvent(.mySegmentsUpdated, metadata: msMetadata)])
+                    let mlsMetadata = SplitMetadata(type: "Large segments updated", value: result.mlsUpdated.description)
+                    notifyUpdate([SplitInternalEvent(.myLargeSegmentsUpdated, metadata: mlsMetadata)])
+                } else if !result.msUpdated.isEmpty || !result.mlsUpdated.isEmpty {
+                    
+                    notifyUpdate([SplitInternalEvent(.mySegmentsUpdated, metadata: msMetadata)])
                 }
                 return true
             }
@@ -71,8 +74,8 @@ struct SegmentsSyncResult {
     let success: Bool
     let msChangeNumber: Int64
     let mlsChangeNumber: Int64
-    let msUpdated: Bool
-    let mlsUpdated: Bool
+    let msUpdated: [String]
+    let mlsUpdated: [String]
 }
 
 protocol SegmentsSyncHelper {
@@ -86,8 +89,8 @@ class DefaultSegmentsSyncHelper: SegmentsSyncHelper {
     struct FetchResult {
         let msTill: Int64
         let mlsTill: Int64
-        let msUpdated: Bool
-        let mlsUdated: Bool
+        let msUpdated: [String]
+        let mlsUpdated: [String]
     }
 
     private let segmentsFetcher: HttpMySegmentsFetcher
@@ -165,7 +168,7 @@ class DefaultSegmentsSyncHelper: SegmentsSyncHelper {
                                           msChangeNumber: result.msTill,
                                           mlsChangeNumber: result.mlsTill,
                                           msUpdated: result.msUpdated,
-                                          mlsUpdated: result.mlsUdated)
+                                          mlsUpdated: result.mlsUpdated)
             }
             attemptCount+=1
             if attemptCount < maxAttempts {
@@ -175,25 +178,20 @@ class DefaultSegmentsSyncHelper: SegmentsSyncHelper {
         return SegmentsSyncResult(success: false,
                                   msChangeNumber: -1,
                                   mlsChangeNumber: -1,
-                                  msUpdated: false,
-                                  mlsUpdated: false)
+                                  msUpdated: [],
+                                  mlsUpdated: [])
     }
 
-    private func fetchUntil(till: Int64?,
-                            headers: HttpHeaders? = nil) throws -> FetchResult {
+    private func fetchUntil(till: Int64?, headers: HttpHeaders? = nil) throws -> FetchResult {
 
-        let oldChange = SegmentChange(segments: mySegmentsStorage.getAll().asArray(),
-                                      changeNumber: mySegmentsStorage.changeNumber)
+        let oldChange = SegmentChange(segments: mySegmentsStorage.getAll().asArray(), changeNumber: mySegmentsStorage.changeNumber)
 
-        let oldLargeChange = SegmentChange(segments: myLargeSegmentsStorage.getAll().asArray(),
-                                           changeNumber: myLargeSegmentsStorage.changeNumber)
+        let oldLargeChange = SegmentChange(segments: myLargeSegmentsStorage.getAll().asArray(), changeNumber: myLargeSegmentsStorage.changeNumber)
 
-        var prevChange = AllSegmentsChange(mySegmentsChange: oldChange,
-                                           myLargeSegmentsChange: oldLargeChange)
+        var prevChange = AllSegmentsChange(mySegmentsChange: oldChange, myLargeSegmentsChange: oldLargeChange)
+        
         while true {
-            guard let change = try segmentsFetcher.execute(userKey: userKey,
-                                                           till: till,
-                                                           headers: headers) else {
+            guard let change = try segmentsFetcher.execute(userKey: userKey, till: till, headers: headers) else {
                 throw HttpError.unknown(code: -1, message: "Segment result is null")
             }
 
@@ -201,10 +199,8 @@ class DefaultSegmentsSyncHelper: SegmentsSyncHelper {
             let myLargeSegmentsChange = change.myLargeSegmentsChange
 
             if !isOutdated(change, prevChange) {
-                let msChanged =  changeChecker.mySegmentsHaveChanged(old: oldChange,
-                                                                     new: mySegmentsChange)
-                let mlsChanged = changeChecker.mySegmentsHaveChanged(old: oldLargeChange,
-                                                                     new: myLargeSegmentsChange)
+                let msChanged =  changeChecker.mySegmentsHaveChanged(old: oldChange, new: mySegmentsChange)
+                let mlsChanged = changeChecker.mySegmentsHaveChanged(old: oldLargeChange, new: myLargeSegmentsChange)
                 Logger.d("Checking my segments update")
                 checkAndUpdate(isChanged: msChanged, change: mySegmentsChange, storage: mySegmentsStorage)
                 Logger.d("Checking my large segments update")
@@ -212,8 +208,8 @@ class DefaultSegmentsSyncHelper: SegmentsSyncHelper {
 
                 return FetchResult(msTill: mySegmentsChange.unwrappedChangeNumber,
                                    mlsTill: myLargeSegmentsChange.unwrappedChangeNumber,
-                                   msUpdated: msChanged,
-                                   mlsUdated: mlsChanged)
+                                   msUpdated: mySegmentsChange.segments.compactMap {$0.name},
+                                   mlsUpdated: myLargeSegmentsChange.segments.compactMap {$0.name})
             }
             prevChange = change
         }
diff --git a/Split/FetcherEngine/Refresh/RetryableSyncWorker.swift b/Split/FetcherEngine/Refresh/RetryableSyncWorker.swift
index 17d91c78b..003b195fe 100644
--- a/Split/FetcherEngine/Refresh/RetryableSyncWorker.swift
+++ b/Split/FetcherEngine/Refresh/RetryableSyncWorker.swift
@@ -81,7 +81,7 @@ class BaseRetryableSyncWorker: RetryableSyncWorker {
 
     func notifyUpdate(_ events: [SplitInternalEvent]) {
         events.forEach {
-            eventsManager.notifyInternalEvent($0)
+            eventsManager.notifyInternalEvent($0.type, metadata: $0.metadata ?? SplitMetadata(type: "", value: ""))
         }
     }
 
@@ -162,9 +162,9 @@ class RetryableSplitsSyncWorker: BaseRetryableSyncWorker {
         do {
             let result = try syncHelper.sync(since: changeNumber, clearBeforeUpdate: clearCache)
             if result.success {
-                if !isSdkReadyTriggered() ||
-                    result.featureFlagsUpdated {
-                    notifyUpdate([.splitsUpdated])
+                if !isSdkReadyTriggered() || result.featureFlagsUpdated.count > 0 {
+                    let metadata = SplitMetadata(type: "Flags", value: result.featureFlagsUpdated.description)
+                    notifyUpdate([SplitInternalEvent(.splitsUpdated, metadata: metadata)])
                 }
                 resetBackoffCounter()
                 return true
@@ -220,8 +220,9 @@ class RetryableSplitsUpdateWorker: BaseRetryableSyncWorker {
                                              clearBeforeUpdate: false,
                                              headers: ServiceConstants.controlNoCacheHeader)
             if result.success {
-                if result.featureFlagsUpdated {
-                    notifyUpdate([.splitsUpdated])
+                if result.featureFlagsUpdated.count > 0 {
+                    let metadata = SplitMetadata(type: "Data", value: result.featureFlagsUpdated.description)
+                    notifyUpdate([SplitInternalEvent(.splitsUpdated, metadata: metadata)])
                 }
                 resetBackoffCounter()
                 return true
diff --git a/Split/FetcherEngine/Refresh/SplitsSyncHelper.swift b/Split/FetcherEngine/Refresh/SplitsSyncHelper.swift
index 83bcfd4c0..d5c992731 100644
--- a/Split/FetcherEngine/Refresh/SplitsSyncHelper.swift
+++ b/Split/FetcherEngine/Refresh/SplitsSyncHelper.swift
@@ -11,14 +11,14 @@ import Foundation
 struct SyncResult {
     let success: Bool
     let changeNumber: Int64
-    let featureFlagsUpdated: Bool
+    let featureFlagsUpdated: [String]
 }
 
 class SplitsSyncHelper {
 
     struct FetchResult {
         let till: Int64
-        let featureFlagsUpdated: Bool
+        let splitNames: [String]
     }
 
     private let splitFetcher: HttpSplitFetcher
@@ -85,8 +85,9 @@ class SplitsSyncHelper {
         var nextSince = since
         var attemptCount = 0
         let goalTill = till ?? -10
+        var result = FetchResult(till: 0, splitNames: [])
         while attemptCount < maxAttempts {
-            let result = try fetchUntil(since: nextSince,
+            result = try fetchUntil(since: nextSince,
                                        till: useTillParam ? till : nil,
                                        clearBeforeUpdate: clearBeforeUpdate,
                                        headers: headers)
@@ -95,13 +96,13 @@ class SplitsSyncHelper {
             if nextSince >= goalTill {
                 return SyncResult(success: true,
                                   changeNumber: nextSince,
-                                  featureFlagsUpdated: result.featureFlagsUpdated)
+                                  featureFlagsUpdated: result.splitNames)
             }
 
             Thread.sleep(forTimeInterval: backoffCounter.getNextRetryTime())
             attemptCount+=1
         }
-        return SyncResult(success: false, changeNumber: nextSince, featureFlagsUpdated: false)
+        return SyncResult(success: false, changeNumber: nextSince, featureFlagsUpdated: result.splitNames)
     }
 
     func fetchUntil(since: Int64,
@@ -112,7 +113,8 @@ class SplitsSyncHelper {
         var clearCache = clearBeforeUpdate
         var firstFetch = true
         var nextSince = since
-        var featureFlagsUpdated = false
+        var splitNames: [String] = []
+        
         while true {
             clearCache = clearCache && firstFetch
             let splitChange = try self.splitFetcher.execute(since: nextSince,
@@ -124,14 +126,15 @@ class SplitsSyncHelper {
                 splitsStorage.clear()
             }
             firstFetch = false
-            if splitsStorage.update(splitChange: splitChangeProcessor.process(splitChange)) {
-                featureFlagsUpdated = true
+            let processedSplits = splitChangeProcessor.process(splitChange)
+            if splitsStorage.update(splitChange: processedSplits) {
+                splitNames += processedSplits.archivedSplits.compactMap(\.name)
+                splitNames += processedSplits.activeSplits.compactMap(\.name)
             }
             Logger.i("Feature flag definitions have been updated")
             // Line below commented temporary for debug purposes
-            // Logger.v(splitChange.description)
             if newSince == newTill, newTill >= since {
-                return FetchResult(till: newTill, featureFlagsUpdated: featureFlagsUpdated)
+                return FetchResult(till: newTill, splitNames: splitNames)
             }
             nextSince = newTill
         }
diff --git a/Split/Localhost/LocalhostClientManager.swift b/Split/Localhost/LocalhostClientManager.swift
index 6679e6859..cf2b28917 100644
--- a/Split/Localhost/LocalhostClientManager.swift
+++ b/Split/Localhost/LocalhostClientManager.swift
@@ -92,8 +92,8 @@ class LocalhostClientManager: SplitClientManager {
         let newGroup = LocalhostComponentsGroup(client: newClient, eventsManager: newEventsManager)
         clients.setValue(newGroup, forKey: key.matchingKey)
         eventsManagerCoordinator.add(newEventsManager, forKey: key)
-        newEventsManager.notifyInternalEvent(.mySegmentsUpdated)
-        newEventsManager.notifyInternalEvent(.myLargeSegmentsUpdated)
+        newEventsManager.notifyInternalEvent(.mySegmentsUpdated, metadata: SplitMetadata(type: "Metadata forKey segments", value: ""))
+        newEventsManager.notifyInternalEvent(.myLargeSegmentsUpdated, metadata: SplitMetadata(type: "Metadata forKey largeSegments", value: ""))
 
         return newClient
     }
diff --git a/Split/Localhost/LocalhostSynchronizer.swift b/Split/Localhost/LocalhostSynchronizer.swift
index 7bc59ea28..2b57f58e9 100644
--- a/Split/Localhost/LocalhostSynchronizer.swift
+++ b/Split/Localhost/LocalhostSynchronizer.swift
@@ -24,34 +24,27 @@ class LocalhostSynchronizer: FeatureFlagsSynchronizer {
         setup()
     }
 
-    func load() {
-    }
+    func load() {}
 
     func synchronize() {
         featureFlagsDataSource.start()
     }
 
-    func synchronize(changeNumber: Int64) {
-    }
+    func synchronize(changeNumber: Int64) {}
 
     func startPeriodicSync() {
         featureFlagsDataSource.start()
     }
 
-    func stopPeriodicSync() {
-    }
+    func stopPeriodicSync() {}
 
-    func notifyKilled() {
-    }
+    func notifyKilled() {}
 
-    func notifyUpdated() {
-    }
+    func notifyUpdated(flagList: [String]) {}
 
-    func pause() {
-    }
+    func pause() {}
 
-    func resume() {
-    }
+    func resume() {}
 
     func destroy() {
         featureFlagsDataSource.stop()
@@ -74,7 +67,8 @@ class LocalhostSynchronizer: FeatureFlagsSynchronizer {
             // Update will remove all records before insert new ones
             _ = self.featureFlagsStorage.update(splitChange: change)
 
-            self.eventsManager.notifyInternalEvent(.splitsUpdated)
+            let metadata = SplitMetadata(type: "Splits Updated", value: featureFlags.values.description)
+            self.eventsManager.notifyInternalEvent(SplitInternalEvent(.splitsUpdated, metadata: metadata))
         }
     }
 }
diff --git a/Split/Network/Streaming/PushNotificationManager.swift b/Split/Network/Streaming/PushNotificationManager.swift
index 38aa4f28f..59e46de8e 100644
--- a/Split/Network/Streaming/PushNotificationManager.swift
+++ b/Split/Network/Streaming/PushNotificationManager.swift
@@ -134,7 +134,14 @@ class DefaultPushNotificationManager: PushNotificationManager {
         }
         Logger.d("Streaming authentication success")
 
-        let connectionDelay = result.sseConnectionDelay
+        var connectionDelay: Int64 = 0
+        
+        #if DEBUG
+            connectionDelay = 1
+        #else
+            connectionDelay = result.sseConnectionDelay
+        #endif
+        
         self.broadcasterChannel.push(event: .pushDelayReceived(delaySeconds: connectionDelay))
         let lastId = lastConnId.value
         if connectionDelay > 0 {
diff --git a/Split/Network/Streaming/SyncUpdateWorker.swift b/Split/Network/Streaming/SyncUpdateWorker.swift
index 0a87fbd68..80cd6a02e 100644
--- a/Split/Network/Streaming/SyncUpdateWorker.swift
+++ b/Split/Network/Streaming/SyncUpdateWorker.swift
@@ -66,8 +66,14 @@ class SplitsUpdateWorker: UpdateWorker<SplitsUpdateNotification> {
                                                  since: previousChangeNumber,
                                                  till: notification.changeNumber)
                         Logger.v("Split update received: \(change)")
-                        if self.splitsStorage.update(splitChange: self.splitChangeProcessor.process(change)) {
-                            self.synchronizer.notifyFeatureFlagsUpdated()
+                        
+                        let processedFlags = self.splitChangeProcessor.process(change)
+                        
+                        if self.splitsStorage.update(splitChange: processedFlags) {
+                            var updatedFlags: [String] = processedFlags.activeSplits.compactMap(\.name)
+                            updatedFlags += processedFlags.archivedSplits.compactMap(\.name)
+                            self.synchronizer.notifyFeatureFlagsUpdated(flagList: updatedFlags)
+                            
                         }
                         self.telemetryProducer?.recordUpdatesFromSse(type: .splits)
                         return
diff --git a/Split/Network/Sync/ByKeyFacade.swift b/Split/Network/Sync/ByKeyFacade.swift
index 5f7212bdf..777382fa1 100644
--- a/Split/Network/Sync/ByKeyFacade.swift
+++ b/Split/Network/Sync/ByKeyFacade.swift
@@ -77,7 +77,8 @@ class DefaultByKeyFacade: ByKeyFacade {
     func loadAttributesFromCache(forKey key: String) {
         doInAll(forMatchingKey: key) { group in
             group.attributesStorage.loadLocal()
-            group.eventsManager.notifyInternalEvent(.attributesLoadedFromCache)
+            let metadata = SplitMetadata(type: "Metadata", value: "Attributes from cache ready")
+            group.eventsManager.notifyInternalEvent(.attributesLoadedFromCache, metadata: metadata)
         }
         TimeChecker.logInterval("Time until attributes loaded from cache")
     }
@@ -122,13 +123,15 @@ class DefaultByKeyFacade: ByKeyFacade {
 
     func notifyMySegmentsUpdated(forKey key: String) {
         doInAll(forMatchingKey: key) { group in
-            group.eventsManager.notifyInternalEvent(.mySegmentsUpdated)
+            let metadata = SplitMetadata(type: "Metadata", value: "Segments updated  for key \(key)")
+            group.eventsManager.notifyInternalEvent(.mySegmentsUpdated, metadata: metadata)
         }
     }
 
     func notifyMyLargeSegmentsUpdated(forKey key: String) {
         doInAll(forMatchingKey: key) { group in
-            group.eventsManager.notifyInternalEvent(.myLargeSegmentsUpdated)
+            let metadata = SplitMetadata(type: "Metadata", value: "Large segments updated  for key \(key)")
+            group.eventsManager.notifyInternalEvent(.myLargeSegmentsUpdated, metadata: metadata)
         }
     }
 
diff --git a/Split/Network/Sync/FeatureFlagsSynchronizer.swift b/Split/Network/Sync/FeatureFlagsSynchronizer.swift
index b733627c2..2d9c4e7e0 100644
--- a/Split/Network/Sync/FeatureFlagsSynchronizer.swift
+++ b/Split/Network/Sync/FeatureFlagsSynchronizer.swift
@@ -15,7 +15,7 @@ protocol FeatureFlagsSynchronizer {
     func startPeriodicSync()
     func stopPeriodicSync()
     func notifyKilled()
-    func notifyUpdated()
+    func notifyUpdated(flagList: [String])
     func pause()
     func resume()
     func destroy()
@@ -40,7 +40,7 @@ class DefaultFeatureFlagsSynchronizer: FeatureFlagsSynchronizer {
          syncWorkerFactory: SyncWorkerFactory,
          broadcasterChannel: SyncEventBroadcaster,
          syncTaskByChangeNumberCatalog: ConcurrentDictionary<Int64, RetryableSyncWorker>
-        = ConcurrentDictionary<Int64, RetryableSyncWorker>(),
+= ConcurrentDictionary<Int64, RetryableSyncWorker>(),
          splitsFilterQueryString: String,
          flagsSpec: String,
          splitEventsManager: SplitEventsManager) {
@@ -85,6 +85,11 @@ class DefaultFeatureFlagsSynchronizer: FeatureFlagsSynchronizer {
             splitsStorage.loadLocal()
             if splitsStorage.getAll().count > 0 {
                 self.splitEventsManager.notifyInternalEvent(.splitsLoadedFromCache)
+                
+                // Trigger event
+                let metadata = SplitMetadata(type: "Metadata", value: "Splits from cache ready")
+                let event = SplitInternalEvent(.attributesLoadedFromCache, metadata: metadata)
+                self.splitEventsManager.notifyInternalEvent(event)
             }
             self.broadcasterChannel.push(event: .splitLoadedFromCache)
             Logger.v("Notifying Splits loaded from cache")
@@ -142,8 +147,9 @@ class DefaultFeatureFlagsSynchronizer: FeatureFlagsSynchronizer {
         splitEventsManager.notifyInternalEvent(.splitKilledNotification)
     }
 
-    func notifyUpdated() {
-        splitEventsManager.notifyInternalEvent(.splitsUpdated)
+    func notifyUpdated(flagList: [String]) {
+        let metadata = SplitMetadata(type: "Updated Flags", value: flagList.description)
+        splitEventsManager.notifyInternalEvent(.splitsUpdated, metadata: metadata)
     }
 
     func pause() {
diff --git a/Split/Network/Sync/Synchronizer.swift b/Split/Network/Sync/Synchronizer.swift
index 4a8320fc7..9e3e796eb 100644
--- a/Split/Network/Sync/Synchronizer.swift
+++ b/Split/Network/Sync/Synchronizer.swift
@@ -29,7 +29,7 @@ protocol Synchronizer: ImpressionLogger {
     func startRecordingTelemetry()
     func stopRecordingTelemetry()
     func pushEvent(event: EventDTO)
-    func notifyFeatureFlagsUpdated()
+    func notifyFeatureFlagsUpdated(flagList: [String])
     func notifySegmentsUpdated(forKey key: String)
     func notifyLargeSegmentsUpdated(forKey key: String)
     func notifySplitKilled()
@@ -200,8 +200,8 @@ class DefaultSynchronizer: Synchronizer {
         }
     }
 
-    func notifyFeatureFlagsUpdated() {
-        featureFlagsSynchronizer.notifyUpdated()
+    func notifyFeatureFlagsUpdated(flagList: [String]) {
+        featureFlagsSynchronizer.notifyUpdated(flagList: flagList)
     }
 
     func notifySegmentsUpdated(forKey key: String) {
diff --git a/SplitTests/Collections/BlockingQueueTest.swift b/SplitTests/Collections/BlockingQueueTest.swift
index 04c4b5df3..1ae1a17db 100644
--- a/SplitTests/Collections/BlockingQueueTest.swift
+++ b/SplitTests/Collections/BlockingQueueTest.swift
@@ -34,19 +34,19 @@ class BlockingQueueTest: XCTestCase {
             }
         }
         globalQ.asyncAfter(deadline: .now() + 1) {
-            queue.add(SplitInternalEvent.mySegmentsLoadedFromCache)
+            queue.add(SplitInternalEvent(.mySegmentsLoadedFromCache))
             globalQ.asyncAfter(deadline: .now() + 1) {
-                queue.add(SplitInternalEvent.splitsLoadedFromCache)
+                queue.add(SplitInternalEvent(.splitsLoadedFromCache))
             }
         }
 
-        queue.add(SplitInternalEvent.splitsUpdated)
-        queue.add(SplitInternalEvent.mySegmentsUpdated)
+        queue.add(SplitInternalEvent(.splitsUpdated))
+        queue.add(SplitInternalEvent(.mySegmentsUpdated))
         wait(for: [endExp], timeout: 10)
-        XCTAssertEqual(SplitInternalEvent.splitsUpdated, local[0])
-        XCTAssertEqual(SplitInternalEvent.mySegmentsUpdated, local[1])
-        XCTAssertEqual(SplitInternalEvent.mySegmentsLoadedFromCache, local[2])
-        XCTAssertEqual(SplitInternalEvent.splitsLoadedFromCache, local[3])
+        XCTAssertEqual(SplitInternalEvent(.splitsUpdated), local[0])
+        XCTAssertEqual(SplitInternalEvent(.mySegmentsUpdated), local[1])
+        XCTAssertEqual(SplitInternalEvent(.mySegmentsLoadedFromCache), local[2])
+        XCTAssertEqual(SplitInternalEvent(.splitsLoadedFromCache), local[3])
     }
 
     func testInterrupt() {
@@ -68,19 +68,19 @@ class BlockingQueueTest: XCTestCase {
             }
         }
         globalQ.asyncAfter(deadline: .now() + 1) {
-            queue.add(SplitInternalEvent.mySegmentsLoadedFromCache)
+            queue.add(SplitInternalEvent(.mySegmentsLoadedFromCache))
             globalQ.asyncAfter(deadline: .now() + 1) {
                 queue.stop()
             }
         }
 
-        queue.add(SplitInternalEvent.splitsUpdated)
-        queue.add(SplitInternalEvent.mySegmentsUpdated)
+        queue.add(SplitInternalEvent(.splitsUpdated))
+        queue.add(SplitInternalEvent(.mySegmentsUpdated))
 
         wait(for: [endExp], timeout: 10)
-        XCTAssertEqual(SplitInternalEvent.splitsUpdated, local[0])
-        XCTAssertEqual(SplitInternalEvent.mySegmentsUpdated, local[1])
-        XCTAssertEqual(SplitInternalEvent.mySegmentsLoadedFromCache, local[2])
+        XCTAssertEqual(SplitInternalEvent(.splitsUpdated), local[0])
+        XCTAssertEqual(SplitInternalEvent(.mySegmentsUpdated), local[1])
+        XCTAssertEqual(SplitInternalEvent(.mySegmentsLoadedFromCache), local[2])
         XCTAssertTrue(interrupted)
     }
 
@@ -151,7 +151,7 @@ class BlockingQueueTest: XCTestCase {
 
         qu1.async {
             for _ in 1..<100000 {
-                queue.add(SplitInternalEvent.splitsUpdated)
+                queue.add(SplitInternalEvent(.splitsUpdated))
                 print("qu1 add")
                 Thread.sleep(forTimeInterval: 0.2)
             }
@@ -160,7 +160,7 @@ class BlockingQueueTest: XCTestCase {
         qu2.async {
             for _ in 1..<10000 {
                 print("qu2 add")
-                queue.add(SplitInternalEvent.sdkReadyTimeoutReached)
+                queue.add(SplitInternalEvent(.sdkReadyTimeoutReached))
                 Thread.sleep(forTimeInterval: 0.5)
             }
         }
@@ -168,7 +168,7 @@ class BlockingQueueTest: XCTestCase {
         qu3.async {
             for _ in 1..<10000 {
                 print("qu3 add")
-                queue.add(SplitInternalEvent.splitsUpdated)
+                queue.add(SplitInternalEvent(.splitsUpdated))
                 Thread.sleep(forTimeInterval: 0.8)
             }
         }
@@ -176,7 +176,7 @@ class BlockingQueueTest: XCTestCase {
         qu4.async {
             for _ in 1..<10000 {
                 print("qu4 add")
-                queue.add(SplitInternalEvent.mySegmentsUpdated)
+                queue.add(SplitInternalEvent(.mySegmentsUpdated))
                 sleep(1)
             }
         }
diff --git a/SplitTests/Fake/InternalSplitClientStub.swift b/SplitTests/Fake/InternalSplitClientStub.swift
index 5b792fb3e..9e88916d4 100644
--- a/SplitTests/Fake/InternalSplitClientStub.swift
+++ b/SplitTests/Fake/InternalSplitClientStub.swift
@@ -10,7 +10,7 @@ import Foundation
 @testable import Split
 
 class InternalSplitClientStub: InternalSplitClient {
-
+    
     var splitsStorage: SplitsStorage?
     var mySegmentsStorage: MySegmentsStorage?
     var myLargeSegmentsStorage: MySegmentsStorage?
@@ -95,14 +95,19 @@ class InternalSplitClientStub: InternalSplitClient {
         return ["": SplitResult(treatment: SplitConstants.control)]
     }
 
-    func on(event: SplitEvent, queue: DispatchQueue, execute action: @escaping SplitAction) {
-    }
+    func on(event: SplitEvent, queue: DispatchQueue, execute action: @escaping SplitAction) {}
 
-    func on(event: SplitEvent, runInBackground: Bool, execute action: @escaping SplitAction) {
-    }
+    func on(event: SplitEvent, runInBackground: Bool, execute action: @escaping SplitAction) {}
 
-    func on(event: SplitEvent, execute action: @escaping SplitAction) {
-    }
+    func on(event: SplitEvent, execute action: @escaping SplitAction) {}
+    
+    func on(event: SplitEventCase, queue: DispatchQueue, execute action: @escaping SplitAction) {}
+    
+    func on(event: SplitEventCase, runInBackground: Bool, execute action: @escaping SplitAction) {}
+    
+    func on(event: SplitEventCase, execute action: @escaping SplitAction) {}
+    
+    func on(event: SplitEventCase, executeWithMetadata: @escaping SplitActionWithMetadata) {}
 
     func track(trafficType: String, eventType: String) -> Bool {
         return true
@@ -160,18 +165,13 @@ class InternalSplitClientStub: InternalSplitClient {
         return true
     }
     
-    func flush() {
-    }
+    func flush() {}
 
-    func destroy() {
-    }
+    func destroy() {}
 
-    func destroy(completion: (() -> Void)?) {
-    }
-
-    func on(event: SplitEvent, executeTask: SplitEventTask) {
+    func destroy(completion: (() -> Void)?) {}
 
-    }
+    func on(event: SplitEvent, executeTask: SplitEventTask) {}
 
     private func createControlTreatmentsDictionary<T>(splits: [String]) -> [String: T] where T: Any {
         var result = [String: T]()
diff --git a/SplitTests/Fake/Service/SplitEventsManagerCoordinatorStub.swift b/SplitTests/Fake/Service/SplitEventsManagerCoordinatorStub.swift
index 94cbb8991..1d53c9df6 100644
--- a/SplitTests/Fake/Service/SplitEventsManagerCoordinatorStub.swift
+++ b/SplitTests/Fake/Service/SplitEventsManagerCoordinatorStub.swift
@@ -22,14 +22,18 @@ class SplitEventsManagerCoordinatorStub: SplitEventsManagerCoordinator {
         managers[key] = nil
     }
 
-    func register(event: SplitEvent, task: SplitEventTask) {
-
-    }
+    func register(event: SplitEvent, task: SplitEventActionTask) {}
+    
+    func notifyInternalEvent(_ event: SplitInternalEventCase, metadata: SplitMetadata) {}
 
     var notifiedEvents = Set<String>()
-    func notifyInternalEvent(_ event: SplitInternalEvent) {
+    func notifyInternalEvent(_ event: SplitInternalEventCase) {
         notifiedEvents.insert(IntegrationHelper.describeEvent(event))
     }
+    
+    func notifyInternalEvent(_ event: SplitInternalEvent) {
+        notifiedEvents.insert(IntegrationHelper.describeEvent(event.type))
+    }
 
     var startCalled = false
     func start() {
@@ -41,7 +45,7 @@ class SplitEventsManagerCoordinatorStub: SplitEventsManagerCoordinator {
         stopCalled = true
     }
 
-    func eventAlreadyTriggered(event: SplitEvent) -> Bool {
+    func eventAlreadyTriggered(event: SplitEventCase) -> Bool {
         return false
     }
 }
diff --git a/SplitTests/Fake/SplitClientStub.swift b/SplitTests/Fake/SplitClientStub.swift
index a19acdcb7..6993f9f6e 100644
--- a/SplitTests/Fake/SplitClientStub.swift
+++ b/SplitTests/Fake/SplitClientStub.swift
@@ -10,7 +10,7 @@ import Foundation
 @testable import Split
 
 class SplitClientStub: SplitClient {
-
+    
     func getTreatment(_ split: String, attributes: [String : Any]?) -> String {
         return SplitConstants.control
     }
@@ -83,17 +83,13 @@ class SplitClientStub: SplitClient {
         return ["feature": SplitResult(treatment: SplitConstants.control)]
     }
 
-    func on(event: SplitEvent, queue: DispatchQueue, execute action: @escaping SplitAction) {
-    }
-
-    func on(event: SplitEvent, execute action: @escaping SplitAction) {
-    }
-
-    func on(event: SplitEvent, runInBackground: Bool, execute action: @escaping SplitAction) {
-    }
-
-    func on(event: SplitEvent, runInBackground: Bool, queue: DispatchQueue?, execute action: @escaping SplitAction) {
-    }
+    func on(event: SplitEventCase, queue: DispatchQueue, execute action: @escaping SplitAction) {}
+    
+    func on(event: SplitEventCase, execute action: @escaping SplitAction) {}
+    
+    func on(event: SplitEventCase, runInBackground: Bool, execute action: @escaping SplitAction) {}
+    
+    func on(event: SplitEventCase, executeWithMetadata: @escaping SplitActionWithMetadata) {}    
 
     func track(trafficType: String, eventType: String) -> Bool {
         return true
@@ -151,12 +147,9 @@ class SplitClientStub: SplitClient {
         return true
     }
 
-    func flush() {
-    }
+    func flush() {}
 
-    func destroy() {
-    }
+    func destroy() {}
 
-    func destroy(completion: (() -> Void)?) {
-    }
+    func destroy(completion: (() -> Void)?) {}
 }
diff --git a/SplitTests/Fake/SplitEventsManagerMock.swift b/SplitTests/Fake/SplitEventsManagerMock.swift
index 1132148df..033c06766 100644
--- a/SplitTests/Fake/SplitEventsManagerMock.swift
+++ b/SplitTests/Fake/SplitEventsManagerMock.swift
@@ -32,51 +32,55 @@ class SplitEventsManagerMock: SplitEventsManager {
 
     var isSdkReadyChecked = false
 
-    func notifyInternalEvent(_ event:SplitInternalEvent) {
+    func notifyInternalEvent(_ event: SplitInternalEventCase) {
         switch event {
-        case .mySegmentsUpdated:
-            isSegmentsReadyFired = true
-        case .splitsUpdated:
-            isSplitsReadyFired = true
-            isSplitUpdatedTriggered = true
-            if let exp = readyExp {
-                exp.fulfill()
-            }
-        case .sdkReadyTimeoutReached:
-            isSdkTimeoutFired = true
-            if let exp = timeoutExp {
-                exp.fulfill()
-            }
-        default:
-            print("\(event)")
+            case .mySegmentsUpdated:
+                isSegmentsReadyFired = true
+            case .splitsUpdated:
+                isSplitsReadyFired = true
+                isSplitUpdatedTriggered = true
+                if let exp = readyExp {
+                    exp.fulfill()
+                }
+            case .sdkReadyTimeoutReached:
+                isSdkTimeoutFired = true
+                if let exp = timeoutExp {
+                    exp.fulfill()
+                }
+            default:
+                print("\(event)")
         }
     }
+    
+    func notifyInternalEvent(_ event: SplitInternalEventCase, metadata: SplitMetadata) {}
+    
+    func register(event: SplitEvent, task: SplitEventActionTask) {}
+    
+    func notifyInternalEvent(_ event: SplitInternalEvent) {}
 
-    var registeredEvents = [SplitEvent: SplitEventTask]()
-    func register(event: SplitEvent, task: SplitEventTask) {
+    var registeredEvents = [SplitEventCase: SplitEventTask]()
+    func register(event: SplitEventCase, task: SplitEventTask) {
         registeredEvents[event] = task
     }
     
-    func start() {
-    }
+    func start() {}
 
-    func stop() {
-    }
+    func stop() {}
     
-    func eventAlreadyTriggered(event: SplitEvent) -> Bool {
+    func eventAlreadyTriggered(event: SplitEventCase) -> Bool {
         switch event {
-        case.sdkReady:
-            isSdkReadyChecked = true
-            return isSdkReadyFired
-        case.sdkReadyFromCache:
-            return isSdkReadyFromCacheFired
-        case .sdkReadyTimedOut:
-            return isSdkTimeoutFired
-        case .sdkUpdated:
-            return isSdkUpdatedFired
+            case.sdkReady:
+                isSdkReadyChecked = true
+                return isSdkReadyFired
+            case.sdkReadyFromCache:
+                return isSdkReadyFromCacheFired
+            case .sdkReadyTimedOut:
+                return isSdkTimeoutFired
+            case .sdkUpdated:
+                return isSdkUpdatedFired
 
-        default:
-            return true
+            default:
+                return true
         }
     }
 }
diff --git a/SplitTests/Fake/SplitEventsManagerStub.swift b/SplitTests/Fake/SplitEventsManagerStub.swift
index 1d7685dc3..82e89ad4a 100644
--- a/SplitTests/Fake/SplitEventsManagerStub.swift
+++ b/SplitTests/Fake/SplitEventsManagerStub.swift
@@ -19,7 +19,7 @@ class SplitEventsManagerStub: SplitEventsManager {
     var startCalled = false
     var stopCalled = false
 
-    func notifyInternalEvent(_ event: SplitInternalEvent) {
+    func notifyInternalEvent(_ event: SplitInternalEventCase) {
         switch event {
         case .mySegmentsLoadedFromCache:
             mySegmentsLoadedEventFiredCount+=1
@@ -39,8 +39,8 @@ class SplitEventsManagerStub: SplitEventsManager {
         }
     }
 
-    var registeredEvents = [SplitEvent: SplitEventTask]()
-    func register(event: SplitEvent, task: SplitEventTask) {
+    var registeredEvents = [SplitEventCase: SplitEventTask]()
+    func register(event: SplitEventCase, task: SplitEventTask) {
         registeredEvents[event] = task
     }
 
@@ -52,7 +52,13 @@ class SplitEventsManagerStub: SplitEventsManager {
         stopCalled = true
     }
 
-    func eventAlreadyTriggered(event: SplitEvent) -> Bool {
+    func eventAlreadyTriggered(event: SplitEventCase) -> Bool {
         return false
     }
+    
+    func register(event: SplitEvent, task: SplitEventActionTask) {}
+    
+    func notifyInternalEvent(_ event: SplitInternalEventCase, metadata: SplitMetadata) {}
+    
+    func notifyInternalEvent(_ event: SplitInternalEvent) {}
 }
diff --git a/SplitTests/Fake/Streaming/FeatureFlagsSynchronizerStub.swift b/SplitTests/Fake/Streaming/FeatureFlagsSynchronizerStub.swift
index 6695c3cfd..d157ce347 100644
--- a/SplitTests/Fake/Streaming/FeatureFlagsSynchronizerStub.swift
+++ b/SplitTests/Fake/Streaming/FeatureFlagsSynchronizerStub.swift
@@ -40,7 +40,7 @@ class FeatureFlagsSynchronizerStub: FeatureFlagsSynchronizer {
     }
 
     var notifyUpdatedCalled = false
-    func notifyUpdated() {
+    func notifyUpdated(flagList: [String]) {
         notifyUpdatedCalled = true
     }
 
diff --git a/SplitTests/Fake/Streaming/SynchronizerSpy.swift b/SplitTests/Fake/Streaming/SynchronizerSpy.swift
index da1b1011b..16361a8e0 100644
--- a/SplitTests/Fake/Streaming/SynchronizerSpy.swift
+++ b/SplitTests/Fake/Streaming/SynchronizerSpy.swift
@@ -196,7 +196,7 @@ class SynchronizerSpy: Synchronizer {
     }
 
     var notifyFeatureFlagsUpdatedCalled = false
-    func notifyFeatureFlagsUpdated() {
+    func notifyFeatureFlagsUpdated(flagList: [String]) {
         notifyFeatureFlagsUpdatedCalled = true
     }
 
diff --git a/SplitTests/Fake/Streaming/SynchronizerStub.swift b/SplitTests/Fake/Streaming/SynchronizerStub.swift
index f5bfb64ab..24e3b7057 100644
--- a/SplitTests/Fake/Streaming/SynchronizerStub.swift
+++ b/SplitTests/Fake/Streaming/SynchronizerStub.swift
@@ -16,6 +16,7 @@ struct ForceMySegmentsParams {
 }
 
 class SynchronizerStub: Synchronizer {
+    
     var disableSdkCalled = false
     var disableEventsCalled = false
     var disableTelemetryCalled = false
@@ -228,7 +229,7 @@ class SynchronizerStub: Synchronizer {
     }
 
     var notifyFeatureFlagsUpdatedCalled = true
-    func notifyFeatureFlagsUpdated() {
+    func notifyFeatureFlagsUpdated(flagList: [String]) {
         notifyFeatureFlagsUpdatedCalled = true
     }
 
diff --git a/SplitTests/Helpers/IntegrationHelper.swift b/SplitTests/Helpers/IntegrationHelper.swift
index 081bf270e..dc5c17d07 100644
--- a/SplitTests/Helpers/IntegrationHelper.swift
+++ b/SplitTests/Helpers/IntegrationHelper.swift
@@ -207,26 +207,26 @@ class IntegrationHelper {
             """
     }
 
-    static func describeEvent(_ event: SplitInternalEvent) -> String {
+    static func describeEvent(_ event: SplitInternalEventCase) -> String {
         switch event {
-        case .mySegmentsUpdated:
-            return "mySegmentsUpdated"
-        case .splitsUpdated:
-            return "splitsUpdated"
-        case .mySegmentsLoadedFromCache:
-            return "mySegmentsLoadedFromCache"
-        case .splitsLoadedFromCache:
-            return "splitsLoadedFromCache"
-        case .attributesLoadedFromCache:
-            return "attributesLoadedFromCache"
-        case .sdkReadyTimeoutReached:
-            return "sdkReadyTimeoutReached"
-        case .splitKilledNotification:
-            return "splitKilledNotification"
-        case .myLargeSegmentsUpdated:
-            return "myLargeSegmentsUpdated"
-        case .myLargeSegmentsLoadedFromCache:
-            return "myLargeSegmentsLoadedFromCache"
+            case .mySegmentsUpdated:
+                return "mySegmentsUpdated"
+            case .splitsUpdated:
+                return "splitsUpdated"
+            case .mySegmentsLoadedFromCache:
+                return "mySegmentsLoadedFromCache"
+            case .splitsLoadedFromCache:
+                return "splitsLoadedFromCache"
+            case .attributesLoadedFromCache:
+                return "attributesLoadedFromCache"
+            case .sdkReadyTimeoutReached:
+                return "sdkReadyTimeoutReached"
+            case .splitKilledNotification:
+                return "splitKilledNotification"
+            case .myLargeSegmentsUpdated:
+                return "myLargeSegmentsUpdated"
+            case .myLargeSegmentsLoadedFromCache:
+                return "myLargeSegmentsLoadedFromCache"
         }
     }
 
diff --git a/SplitTests/Helpers/StreamingTestingHelper.swift b/SplitTests/Helpers/StreamingTestingHelper.swift
index 684d6d21c..de3a37df1 100644
--- a/SplitTests/Helpers/StreamingTestingHelper.swift
+++ b/SplitTests/Helpers/StreamingTestingHelper.swift
@@ -1,3 +1,4 @@
+
 //
 //  StreamingTestingHelper.swift
 //  SplitTests
diff --git a/SplitTests/Helpers/TestingHelper.swift b/SplitTests/Helpers/TestingHelper.swift
index 68169e894..eb4a385ff 100644
--- a/SplitTests/Helpers/TestingHelper.swift
+++ b/SplitTests/Helpers/TestingHelper.swift
@@ -258,7 +258,7 @@ struct TestingHelper {
 
     static func segmentsSyncResult(_ result: Bool = true,
                                    msCn: Int64 = 300, mlsCn: Int64 = 400,
-                                   msUpd: Bool = true, mlsUpd: Bool = true) -> SegmentsSyncResult {
+                                   msUpd: [String] = ["Segment1","Segment2"], mlsUpd: [String] = ["LargeSegment1","LargeSegment2"]) -> SegmentsSyncResult {
         return SegmentsSyncResult(success: result,
                                   msChangeNumber: msCn, mlsChangeNumber: mlsCn,
                                   msUpdated: msUpd, mlsUpdated: mlsUpd)
diff --git a/SplitTests/Impressions/ImpressionsDedupTest.swift b/SplitTests/Impressions/ImpressionsDedupTest.swift
index 2d3c7fb52..06bf83b00 100644
--- a/SplitTests/Impressions/ImpressionsDedupTest.swift
+++ b/SplitTests/Impressions/ImpressionsDedupTest.swift
@@ -79,11 +79,11 @@ class ImpressionsDedupTest: XCTestCase {
 
         let sdkReadyExpectation = XCTestExpectation(description: "SDK READY Expectation")
 
-        client.on(event: SplitEvent.sdkReady) {
+        client.on(event: .sdkReady) {
             sdkReadyExpectation.fulfill()
         }
 
-        client.on(event: SplitEvent.sdkReadyTimedOut) {
+        client.on(event: .sdkReadyTimedOut) {
             sdkReadyExpectation.fulfill()
         }
 
diff --git a/SplitTests/Impressions/ImpressionsNoneTest.swift b/SplitTests/Impressions/ImpressionsNoneTest.swift
index 55c05b197..bd1ae114a 100644
--- a/SplitTests/Impressions/ImpressionsNoneTest.swift
+++ b/SplitTests/Impressions/ImpressionsNoneTest.swift
@@ -105,11 +105,11 @@ class ImpressionsNoneTest: XCTestCase {
             clients.append(client)
             exps.append(sdkReadyExpectation)
 
-            client.on(event: SplitEvent.sdkReady) {
+            client.on(event: .sdkReady) {
                 sdkReadyExpectation.fulfill()
             }
 
-            client.on(event: SplitEvent.sdkReadyTimedOut) {
+            client.on(event: .sdkReadyTimedOut) {
                 sdkReadyExpectation.fulfill()
             }
         }
@@ -252,11 +252,11 @@ class ImpressionsNoneTest: XCTestCase {
 
         exps.append(sdkReadyExpectation)
 
-        client.on(event: SplitEvent.sdkReady) {
+        client.on(event: .sdkReady) {
             sdkReadyExpectation.fulfill()
         }
 
-        client.on(event: SplitEvent.sdkReadyTimedOut) {
+        client.on(event: .sdkReadyTimedOut) {
             sdkReadyExpectation.fulfill()
         }
 
diff --git a/SplitTests/Impressions/ImpressionsPropertiesE2ETest.swift b/SplitTests/Impressions/ImpressionsPropertiesE2ETest.swift
index eab03bb7e..ca4fe664f 100644
--- a/SplitTests/Impressions/ImpressionsPropertiesE2ETest.swift
+++ b/SplitTests/Impressions/ImpressionsPropertiesE2ETest.swift
@@ -223,11 +223,11 @@ class ImpressionsPropertiesE2ETest: XCTestCase {
 
         let sdkReadyExpectation = XCTestExpectation(description: "SDK READY Expectation")
 
-        client.on(event: SplitEvent.sdkReady) {
+        client.on(event: .sdkReady) {
             sdkReadyExpectation.fulfill()
         }
 
-        client.on(event: SplitEvent.sdkReadyTimedOut) {
+        client.on(event: .sdkReadyTimedOut) {
             sdkReadyExpectation.fulfill()
         }
 
@@ -257,11 +257,11 @@ class ImpressionsPropertiesE2ETest: XCTestCase {
 
         let sdkReadyExpectation = XCTestExpectation(description: "SDK READY Expectation")
 
-        client.on(event: SplitEvent.sdkReady) {
+        client.on(event: .sdkReady) {
             sdkReadyExpectation.fulfill()
         }
 
-        client.on(event: SplitEvent.sdkReadyTimedOut) {
+        client.on(event: .sdkReadyTimedOut) {
             sdkReadyExpectation.fulfill()
         }
 
diff --git a/SplitTests/Impressions/ImpressionsToggleTest.swift b/SplitTests/Impressions/ImpressionsToggleTest.swift
index ddd60e757..bf75e6441 100644
--- a/SplitTests/Impressions/ImpressionsToggleTest.swift
+++ b/SplitTests/Impressions/ImpressionsToggleTest.swift
@@ -154,11 +154,11 @@ class ImpressionsToggleTest: XCTestCase {
 
         exps.append(sdkReadyExpectation)
 
-        client.on(event: SplitEvent.sdkReady) {
+        client.on(event: .sdkReady) {
             sdkReadyExpectation.fulfill()
         }
 
-        client.on(event: SplitEvent.sdkReadyTimedOut) {
+        client.on(event: .sdkReadyTimedOut) {
             sdkReadyExpectation.fulfill()
         }
 
diff --git a/SplitTests/Init/SplitClientTests.swift b/SplitTests/Init/SplitClientTests.swift
index 25c6b3260..e129489ea 100644
--- a/SplitTests/Init/SplitClientTests.swift
+++ b/SplitTests/Init/SplitClientTests.swift
@@ -20,7 +20,7 @@ class SplitClientTests: XCTestCase {
     var eventsManager: SplitEventsManagerMock!
     var eventsTracker: EventsTrackerStub!
     var clientManager: ClientManagerMock!
-    let events: [SplitEvent] = [.sdkReadyFromCache, .sdkReady, .sdkUpdated, .sdkReadyTimedOut]
+    let events: [SplitEventCase] = [.sdkReadyFromCache, .sdkReady, .sdkUpdated, .sdkReadyTimedOut]
 
     override func setUp() {
         storageContainer = TestingHelper.createStorageContainer()
diff --git a/SplitTests/Integration/Api/AttributesEvaluationTest.swift b/SplitTests/Integration/Api/AttributesEvaluationTest.swift
index 9199b3a2f..48e18f25d 100644
--- a/SplitTests/Integration/Api/AttributesEvaluationTest.swift
+++ b/SplitTests/Integration/Api/AttributesEvaluationTest.swift
@@ -68,7 +68,7 @@ class AttributesEvaluationTest: XCTestCase {
 
         splitClient = factory.client
 
-        splitClient.on(event: SplitEvent.sdkReadyFromCache) {
+        splitClient.on(event: .sdkReadyFromCache) {
             cacheReadyExp.fulfill()
             print("Ready from cache")
         }
@@ -137,7 +137,7 @@ class AttributesEvaluationTest: XCTestCase {
 
         splitClient = factory.client
 
-        splitClient.on(event: SplitEvent.sdkReadyFromCache) {
+        splitClient.on(event: .sdkReadyFromCache) {
             cacheReadyExp.fulfill()
             print("Ready from cache")
         }
@@ -224,7 +224,7 @@ class AttributesEvaluationTest: XCTestCase {
 
         splitClient = factory.client
 
-        splitClient.on(event: SplitEvent.sdkReadyFromCache) {
+        splitClient.on(event: .sdkReadyFromCache) {
             cacheReadyExp.fulfill()
             print("Ready from cache")
         }
@@ -297,7 +297,7 @@ class AttributesEvaluationTest: XCTestCase {
 
         splitClient = factory.client
 
-        splitClient.on(event: SplitEvent.sdkReadyFromCache) {
+        splitClient.on(event: .sdkReadyFromCache) {
             cacheReadyExp.fulfill()
             print("Ready from cache")
         }
diff --git a/SplitTests/Integration/Api/DestroyTest.swift b/SplitTests/Integration/Api/DestroyTest.swift
index cc83c7144..1193a0bdb 100644
--- a/SplitTests/Integration/Api/DestroyTest.swift
+++ b/SplitTests/Integration/Api/DestroyTest.swift
@@ -173,12 +173,12 @@ class DestroyTests: XCTestCase {
         var timeOutFired = false
         var sdkReadyFired = false
         
-        client?.on(event: SplitEvent.sdkReady) {
+        client?.on(event: .sdkReady) {
             sdkReadyFired = true
             sdkReadyExpectation.fulfill()
         }
         
-        client?.on(event: SplitEvent.sdkReadyTimedOut) {
+        client?.on(event: .sdkReadyTimedOut) {
             timeOutFired = true
             sdkReadyExpectation.fulfill()
         }
diff --git a/SplitTests/Integration/Api/FlagSetsIntegrationTest.swift b/SplitTests/Integration/Api/FlagSetsIntegrationTest.swift
index 4b5561382..bbbac9e1e 100644
--- a/SplitTests/Integration/Api/FlagSetsIntegrationTest.swift
+++ b/SplitTests/Integration/Api/FlagSetsIntegrationTest.swift
@@ -799,11 +799,11 @@ class FlagSetsIntegrationTests: XCTestCase {
         let client = factory?.client
 
         let sdkReadyExpectation = XCTestExpectation(description: "SDK READY Expectation")
-        client?.on(event: SplitEvent.sdkReady) {
+        client?.on(event: SplitEventCase.sdkReady) {
             sdkReadyExpectation.fulfill()
         }
 
-        client?.on(event: SplitEvent.sdkReadyTimedOut) {
+        client?.on(event: SplitEventCase.sdkReadyTimedOut) {
             sdkReadyExpectation.fulfill()
         }
 
diff --git a/SplitTests/Integration/Api/SemverIntegrationTest.swift b/SplitTests/Integration/Api/SemverIntegrationTest.swift
index 8e9fee736..51701f551 100644
--- a/SplitTests/Integration/Api/SemverIntegrationTest.swift
+++ b/SplitTests/Integration/Api/SemverIntegrationTest.swift
@@ -124,11 +124,11 @@ class SemverIntegrationTest: XCTestCase {
         let client = factory?.client
 
         let sdkReadyExpectation = XCTestExpectation(description: "SDK READY Expectation")
-        client?.on(event: SplitEvent.sdkReady) {
+        client?.on(event: .sdkReady) {
             sdkReadyExpectation.fulfill()
         }
 
-        client?.on(event: SplitEvent.sdkReadyTimedOut) {
+        client?.on(event: .sdkReadyTimedOut) {
             sdkReadyExpectation.fulfill()
         }
 
diff --git a/SplitTests/Integration/Api/SplitIntegrationTest.swift b/SplitTests/Integration/Api/SplitIntegrationTest.swift
index 3fc765e44..aaf55fb40 100644
--- a/SplitTests/Integration/Api/SplitIntegrationTest.swift
+++ b/SplitTests/Integration/Api/SplitIntegrationTest.swift
@@ -127,12 +127,12 @@ class SplitIntegrationTests: XCTestCase {
         var timeOutFired = false
         var sdkReadyFired = false
 
-        client?.on(event: SplitEvent.sdkReady) {
+        client?.on(event: .sdkReady) {
             sdkReadyFired = true
             sdkReadyExpectation.fulfill()
         }
 
-        client?.on(event: SplitEvent.sdkReadyTimedOut) {
+        client?.on(event: .sdkReadyTimedOut) {
             timeOutFired = true
             sdkReadyExpectation.fulfill()
         }
@@ -217,7 +217,7 @@ class SplitIntegrationTests: XCTestCase {
 
         let sdkReadyExpectation = XCTestExpectation(description: "SDK READY Expectation")
 
-        client?.on(event: SplitEvent.sdkReady) {
+        client?.on(event: .sdkReady) {
             sdkReadyExpectation.fulfill()
         }
 
@@ -262,12 +262,12 @@ class SplitIntegrationTests: XCTestCase {
 
         let sdkReadyExpectation = XCTestExpectation(description: "SDK READY Expectation")
 
-        client?.on(event: SplitEvent.sdkReady) {
+        client?.on(event: .sdkReady) {
             readyFired = true
             sdkReadyExpectation.fulfill()
         }
 
-        client?.on(event: SplitEvent.sdkReadyTimedOut) {
+        client?.on(event: .sdkReadyTimedOut) {
             sdkReadyExpectation.fulfill()
         }
 
@@ -310,12 +310,12 @@ class SplitIntegrationTests: XCTestCase {
 
         let sdkReadyExpectation = XCTestExpectation(description: "SDK READY Expectation")
 
-        client?.on(event: SplitEvent.sdkReady) {
+        client?.on(event: .sdkReady) {
             readyFired = true
             sdkReadyExpectation.fulfill()
         }
 
-        client?.on(event: SplitEvent.sdkReadyTimedOut) {
+        client?.on(event: .sdkReadyTimedOut) {
             timeOutFired = true
             sdkReadyExpectation.fulfill()
         }
diff --git a/SplitTests/Integration/Api/SplitSdkTimeoutTest.swift b/SplitTests/Integration/Api/SplitSdkTimeoutTest.swift
index bfb0b59dd..ece5798f8 100644
--- a/SplitTests/Integration/Api/SplitSdkTimeoutTest.swift
+++ b/SplitTests/Integration/Api/SplitSdkTimeoutTest.swift
@@ -42,12 +42,12 @@ class SplitSdkTimeoutTests: XCTestCase {
         var timeOutFired = false
         var sdkReadyFired = false
         
-        client?.on(event: SplitEvent.sdkReady) {
+        client?.on(event: .sdkReady) {
             sdkReadyFired = true
             sdkReadyExpectation.fulfill()
         }
         
-        client?.on(event: SplitEvent.sdkReadyTimedOut) {
+        client?.on(event: .sdkReadyTimedOut) {
             timeOutFired = true
             sdkReadyExpectation.fulfill()
         }
diff --git a/SplitTests/Integration/Api/UnsupportedMatcherIntegrationTest.swift b/SplitTests/Integration/Api/UnsupportedMatcherIntegrationTest.swift
index 9f99d6598..abd28beef 100644
--- a/SplitTests/Integration/Api/UnsupportedMatcherIntegrationTest.swift
+++ b/SplitTests/Integration/Api/UnsupportedMatcherIntegrationTest.swift
@@ -113,11 +113,11 @@ class UnsupportedMatcherIntegrationTest: XCTestCase {
         let client = factory?.client
 
         let sdkReadyExpectation = XCTestExpectation(description: "SDK READY Expectation")
-        client?.on(event: SplitEvent.sdkReady) {
+        client?.on(event: .sdkReady) {
             sdkReadyExpectation.fulfill()
         }
 
-        client?.on(event: SplitEvent.sdkReadyTimedOut) {
+        client?.on(event: .sdkReadyTimedOut) {
             sdkReadyExpectation.fulfill()
         }
 
diff --git a/SplitTests/Integration/Api/UserKeyEncondingTest.swift b/SplitTests/Integration/Api/UserKeyEncondingTest.swift
index 202d00a55..499c622e7 100644
--- a/SplitTests/Integration/Api/UserKeyEncondingTest.swift
+++ b/SplitTests/Integration/Api/UserKeyEncondingTest.swift
@@ -51,11 +51,11 @@ class UserKeyEncondingTest: XCTestCase {
 
         let sdkReadyExpectation = XCTestExpectation(description: "SDK READY Expectation")
 
-        client.on(event: SplitEvent.sdkReady) {
+        client.on(event: .sdkReady) {
             sdkReadyExpectation.fulfill()
         }
 
-        client.on(event: SplitEvent.sdkReadyTimedOut) {
+        client.on(event: .sdkReadyTimedOut) {
             sdkReadyExpectation.fulfill()
         }
 
diff --git a/SplitTests/Integration/Cache/InitialCacheTest.swift b/SplitTests/Integration/Cache/InitialCacheTest.swift
index 8572bfb6a..ef8f8c2ae 100644
--- a/SplitTests/Integration/Cache/InitialCacheTest.swift
+++ b/SplitTests/Integration/Cache/InitialCacheTest.swift
@@ -73,17 +73,17 @@ class InitialCacheTest: XCTestCase {
         var treatmentCache = ""
         var treatmentReady = ""
 
-        client.on(event: SplitEvent.sdkReadyFromCache) {
+        client.on(event: .sdkReadyFromCache) {
             treatmentCache = client.getTreatment(self.splitName)
             cacheReadyExp.fulfill()
         }
 
-        client.on(event: SplitEvent.sdkReady) {
+        client.on(event: .sdkReady) {
             treatmentReady = client.getTreatment(self.splitName)
             readyExp.fulfill()
         }
 
-        client.on(event: SplitEvent.sdkReadyTimedOut) {
+        client.on(event: .sdkReadyTimedOut) {
             readyExp.fulfill()
         }
 
@@ -134,21 +134,21 @@ class InitialCacheTest: XCTestCase {
         var treatmentCache = ""
         var treatmentReady = ""
 
-        client.on(event: SplitEvent.sdkReadyFromCache) { [weak self] in
+        client.on(event: .sdkReadyFromCache) { [weak self] in
             guard let self = self else { return }
 
             treatmentCache = client.getTreatment(self.splitName)
             cacheReadyExp.fulfill()
         }
 
-        client.on(event: SplitEvent.sdkReady) { [weak self] in
+        client.on(event: .sdkReady) { [weak self] in
             guard let self = self else { return }
 
             treatmentReady = client.getTreatment(self.splitName)
             readyExp.fulfill()
         }
 
-        client.on(event: SplitEvent.sdkReadyTimedOut) {
+        client.on(event: .sdkReadyTimedOut) {
             readyExp.fulfill()
         }
 
@@ -203,17 +203,17 @@ class InitialCacheTest: XCTestCase {
         var treatmentCache = ""
         var treatmentReady = ""
 
-        client.on(event: SplitEvent.sdkReadyFromCache) {
+        client.on(event: .sdkReadyFromCache) {
             treatmentCache = client.getTreatment(self.splitName)
             cacheReadyExp.fulfill()
         }
 
-        client.on(event: SplitEvent.sdkReady) {
+        client.on(event: .sdkReady) {
             treatmentReady = client.getTreatment(self.splitName)
             readyExp.fulfill()
         }
 
-        client.on(event: SplitEvent.sdkReadyTimedOut) {
+        client.on(event: .sdkReadyTimedOut) {
             readyExp.fulfill()
         }
 
@@ -284,19 +284,19 @@ class InitialCacheTest: XCTestCase {
         var treatmentReady1 = ""
         var treatmentReady2 = ""
 
-        client.on(event: SplitEvent.sdkReadyFromCache) {
+        client.on(event: .sdkReadyFromCache) {
             treatmentCache1 = client.getTreatment(self.splitName)
             treatmentCache2 = client.getTreatment(splitInFilter)
             cacheReadyExp.fulfill()
         }
 
-        client.on(event: SplitEvent.sdkReady) {
+        client.on(event: .sdkReady) {
             treatmentReady1 = client.getTreatment(self.splitName)
             treatmentReady2 = client.getTreatment(splitInFilter)
             readyExp.fulfill()
         }
 
-        client.on(event: SplitEvent.sdkReadyTimedOut) {
+        client.on(event: .sdkReadyTimedOut) {
             readyExp.fulfill()
         }
 
@@ -354,17 +354,17 @@ class InitialCacheTest: XCTestCase {
         var treatmentReady = ""
 
         var readyCacheNotFired = false
-        client.on(event: SplitEvent.sdkReadyFromCache) {
+        client.on(event: .sdkReadyFromCache) {
             treatmentCache = client.getTreatment(self.splitName)
             readyCacheNotFired = true
         }
 
-        client.on(event: SplitEvent.sdkReady) {
+        client.on(event: .sdkReady) {
             treatmentReady = client.getTreatment(self.splitName)
             readyExp.fulfill()
         }
 
-        client.on(event: SplitEvent.sdkReadyTimedOut) {
+        client.on(event: .sdkReadyTimedOut) {
             readyExp.fulfill()
         }
 
diff --git a/SplitTests/Integration/Cache/ReadyFromCacheTest.swift b/SplitTests/Integration/Cache/ReadyFromCacheTest.swift
index ec1bad122..d69d70b23 100644
--- a/SplitTests/Integration/Cache/ReadyFromCacheTest.swift
+++ b/SplitTests/Integration/Cache/ReadyFromCacheTest.swift
@@ -62,17 +62,17 @@ class ReadyFromCacheTest: XCTestCase {
 
         let client = factory.client
 
-        client.on(event: SplitEvent.sdkReadyFromCache) {
+        client.on(event: .sdkReadyFromCache) {
             cacheReadyExp.fulfill()
             cacheReadyFired = true
         }
 
-        client.on(event: SplitEvent.sdkReady) {
+        client.on(event: .sdkReady) {
             readyExp.fulfill()
             readyFired = true
         }
 
-        client.on(event: SplitEvent.sdkReadyTimedOut) {
+        client.on(event: .sdkReadyTimedOut) {
             readyExp.fulfill()
         }
 
@@ -122,17 +122,17 @@ class ReadyFromCacheTest: XCTestCase {
 
         let client = factory.client
 
-        client.on(event: SplitEvent.sdkReadyFromCache) {
+        client.on(event: .sdkReadyFromCache) {
             cacheReadyExp.fulfill()
             cacheReadyFired = true
         }
 
-        client.on(event: SplitEvent.sdkReady) {
+        client.on(event: .sdkReady) {
             readyExp.fulfill()
             readyFired = true
         }
 
-        client.on(event: SplitEvent.sdkReadyTimedOut) {
+        client.on(event: .sdkReadyTimedOut) {
             readyExp.fulfill()
             timeoutFired = true
         }
@@ -178,16 +178,16 @@ class ReadyFromCacheTest: XCTestCase {
 
         let client = factory.client
 
-        client.on(event: SplitEvent.sdkReadyFromCache) {
+        client.on(event: .sdkReadyFromCache) {
             cacheReadyFired = true
         }
 
-        client.on(event: SplitEvent.sdkReady) {
+        client.on(event: .sdkReady) {
             readyExp.fulfill()
             readyFired = true
         }
 
-        client.on(event: SplitEvent.sdkReadyTimedOut) {
+        client.on(event: .sdkReadyTimedOut) {
             readyExp.fulfill()
             timeoutFired = true
         }
@@ -251,15 +251,15 @@ class ReadyFromCacheTest: XCTestCase {
 
             let client = factory.client
 
-            client.on(event: SplitEvent.sdkReadyFromCache) {
+            client.on(event: .sdkReadyFromCache) {
                 cacheReadyExp.fulfill()
             }
 
-            client.on(event: SplitEvent.sdkReady) {
+            client.on(event: .sdkReady) {
                 readyExp.fulfill()
             }
 
-            client.on(event: SplitEvent.sdkReadyTimedOut) {
+            client.on(event: .sdkReadyTimedOut) {
                 readyExp.fulfill()
             }
 
@@ -337,15 +337,15 @@ class ReadyFromCacheTest: XCTestCase {
 
             let client = factory.client
 
-            client.on(event: SplitEvent.sdkReadyFromCache) {
+            client.on(event: .sdkReadyFromCache) {
                 cacheReadyExp.fulfill()
             }
 
-            client.on(event: SplitEvent.sdkReady) {
+            client.on(event: .sdkReady) {
                 readyExp.fulfill()
             }
 
-            client.on(event: SplitEvent.sdkReadyTimedOut) {
+            client.on(event: .sdkReadyTimedOut) {
                 readyExp.fulfill()
             }
 
@@ -426,17 +426,17 @@ class ReadyFromCacheTest: XCTestCase {
 
         let client = factory.client
 
-        client.on(event: SplitEvent.sdkReadyFromCache) {
+        client.on(event: .sdkReadyFromCache) {
             cacheReadyExp.fulfill()
             cacheReadyFired = true
         }
 
-        client.on(event: SplitEvent.sdkReady) {
+        client.on(event: .sdkReady) {
             readyExp.fulfill()
             readyFired = true
         }
 
-        client.on(event: SplitEvent.sdkReadyTimedOut) {
+        client.on(event: .sdkReadyTimedOut) {
             readyExp.fulfill()
         }
 
diff --git a/SplitTests/Integration/MultiClient/BucketSplitTest.swift b/SplitTests/Integration/MultiClient/BucketSplitTest.swift
index 32c0ca388..40e56b320 100644
--- a/SplitTests/Integration/MultiClient/BucketSplitTest.swift
+++ b/SplitTests/Integration/MultiClient/BucketSplitTest.swift
@@ -47,7 +47,7 @@ class BucketSplitTest: XCTestCase {
             let key = Key(matchingKey: userKey, bucketingKey: bkey)
             readyExps[key] = XCTestExpectation(description: "key: \(bkey)")
             clients[key] = factory.client(key: key)
-            clients[key]?.on(event: SplitEvent.sdkReady) {
+            clients[key]?.on(event: .sdkReady) {
                 print("READY FOR: \(key.bucketingKey!)")
                 self.readyExps[key]?.fulfill()
             }
diff --git a/SplitTests/Integration/MultiClient/MultiClientEvaluationTest.swift b/SplitTests/Integration/MultiClient/MultiClientEvaluationTest.swift
index 1411ca4ef..3e3f93156 100644
--- a/SplitTests/Integration/MultiClient/MultiClientEvaluationTest.swift
+++ b/SplitTests/Integration/MultiClient/MultiClientEvaluationTest.swift
@@ -69,7 +69,7 @@ class MultiClientEvaluationTest: XCTestCase {
             readyExps[key] = XCTestExpectation(description: "Ready \(key)")
 
             print("Handler for: \(key)")
-            clients[key]?.on(event: SplitEvent.sdkReady) {
+            clients[key]?.on(event: .sdkReady) {
                 self.readyExps[key]?.fulfill()
             }
         }
@@ -117,7 +117,7 @@ class MultiClientEvaluationTest: XCTestCase {
 
         doInAllClients { key, client in
             readyExps[key] = XCTestExpectation(description: "Ready \(key)")
-            clients[key]?.on(event: SplitEvent.sdkReadyFromCache) {
+            clients[key]?.on(event: .sdkReadyFromCache) {
                 self.readyExps[key]?.fulfill()
                 cache[key] = true
             }
@@ -152,7 +152,7 @@ class MultiClientEvaluationTest: XCTestCase {
             let key = "key_\(i)"
             readyExps[key] = XCTestExpectation(description: "Ready \(key)")
             let client = factory.client(key: Key(matchingKey: key))
-            client.on(event: SplitEvent.sdkReady) {
+            client.on(event: .sdkReady) {
                 self.readyExps[key]?.fulfill()
             }
             clients[key] = client
@@ -196,7 +196,7 @@ class MultiClientEvaluationTest: XCTestCase {
         doInAllClients { key, client in
             readyExps[key] = XCTestExpectation(description: "Ready \(key)")
 
-            clients[key]?.on(event: SplitEvent.sdkReady) {
+            clients[key]?.on(event: .sdkReady) {
                 self.readyExps[key]?.fulfill()
             }
         }
@@ -236,7 +236,7 @@ class MultiClientEvaluationTest: XCTestCase {
         doInAllClients { key, client in
             readyExps[key] = XCTestExpectation(description: "Ready \(key)")
 
-            clients[key]?.on(event: SplitEvent.sdkReady) {
+            clients[key]?.on(event: .sdkReady) {
                 self.readyExps[key]?.fulfill()
             }
         }
diff --git a/SplitTests/Integration/MultiClient/MultiClientStreamingResetTest.swift b/SplitTests/Integration/MultiClient/MultiClientStreamingResetTest.swift
index c3eb43655..ae7b20212 100644
--- a/SplitTests/Integration/MultiClient/MultiClientStreamingResetTest.swift
+++ b/SplitTests/Integration/MultiClient/MultiClientStreamingResetTest.swift
@@ -75,7 +75,7 @@ class MultiClientStreamingResetTest: XCTestCase {
         let defaultClient = factory.client
         clients[Key(matchingKey: defaultKey)] = defaultClient
 
-        defaultClient.on(event: SplitEvent.sdkReady) {
+        defaultClient.on(event: .sdkReady) {
             expReady.fulfill()
             results[self.defaultKey] = defaultClient.getTreatment(self.splitName)
         }
@@ -99,7 +99,7 @@ class MultiClientStreamingResetTest: XCTestCase {
                 exps.append(expSse!)
             }
 
-            client.on(event: SplitEvent.sdkReady) {
+            client.on(event: .sdkReady) {
                 expReady.fulfill()
                 results[key.matchingKey] = client.getTreatment(self.splitName)
             }
diff --git a/SplitTests/Integration/Recorder/FlushTest.swift b/SplitTests/Integration/Recorder/FlushTest.swift
index e7f8f3e52..17702c9b6 100644
--- a/SplitTests/Integration/Recorder/FlushTest.swift
+++ b/SplitTests/Integration/Recorder/FlushTest.swift
@@ -65,12 +65,12 @@ class FlushTests: XCTestCase {
         var timeOutFired = false
         var sdkReadyFired = false
         
-        client?.on(event: SplitEvent.sdkReady) {
+        client?.on(event: .sdkReady) {
             sdkReadyFired = true
             sdkReadyExpectation.fulfill()
         }
         
-        client?.on(event: SplitEvent.sdkReadyTimedOut) {
+        client?.on(event: .sdkReadyTimedOut) {
             timeOutFired = true
             sdkReadyExpectation.fulfill()
         }
diff --git a/SplitTests/Integration/Recorder/TelemetryTest.swift b/SplitTests/Integration/Recorder/TelemetryTest.swift
index a766a21f6..fa07f8fe8 100644
--- a/SplitTests/Integration/Recorder/TelemetryTest.swift
+++ b/SplitTests/Integration/Recorder/TelemetryTest.swift
@@ -60,11 +60,11 @@ class TelemetryTest: XCTestCase {
         let sdkReadyExp = XCTestExpectation()
         let sdkReadyFromCacheExp = XCTestExpectation()
 
-        client.on(event: SplitEvent.sdkReadyFromCache) {
+        client.on(event: .sdkReadyFromCache) {
             sdkReadyFromCacheExp.fulfill()
         }
 
-        client.on(event: SplitEvent.sdkReady) {
+        client.on(event: .sdkReady) {
             sdkReadyExp.fulfill()
         }
 
@@ -97,11 +97,11 @@ class TelemetryTest: XCTestCase {
         let sdkReadyExp = XCTestExpectation()
         var readyFromCacheFired = false
 
-        client.on(event: SplitEvent.sdkReadyFromCache) {
+        client.on(event: .sdkReadyFromCache) {
             readyFromCacheFired = true
         }
 
-        client.on(event: SplitEvent.sdkReady) {
+        client.on(event: .sdkReady) {
             sdkReadyExp.fulfill()
         }
 
@@ -132,7 +132,7 @@ class TelemetryTest: XCTestCase {
 
         let sdkReadyExp = XCTestExpectation()
 
-        client.on(event: SplitEvent.sdkReady) {
+        client.on(event: .sdkReady) {
             sdkReadyExp.fulfill()
         }
 
diff --git a/SplitTests/Integration/Recorder/TrackTest.swift b/SplitTests/Integration/Recorder/TrackTest.swift
index d5b4e7fe6..9dd55a988 100644
--- a/SplitTests/Integration/Recorder/TrackTest.swift
+++ b/SplitTests/Integration/Recorder/TrackTest.swift
@@ -128,7 +128,7 @@ class TrackTest: XCTestCase {
 
         var sdkReadyFired = false
         
-        client.on(event: SplitEvent.sdkReady) {
+        client.on(event: SplitEventCase.sdkReady) {
             sdkReadyFired = true
             sdkReady.fulfill()
         }
diff --git a/SplitTests/Integration/Sync/CdnByPassTest.swift b/SplitTests/Integration/Sync/CdnByPassTest.swift
index 196a5ba5f..33aed3e96 100644
--- a/SplitTests/Integration/Sync/CdnByPassTest.swift
+++ b/SplitTests/Integration/Sync/CdnByPassTest.swift
@@ -73,7 +73,7 @@ class CdnByPassTest: XCTestCase {
 
         let sdkReadyExpectation = XCTestExpectation(description: "SDK READY Expectation")
 
-        client.on(event: SplitEvent.sdkReady) {
+        client.on(event: .sdkReady) {
             sdkReadyExpectation.fulfill()
         }
 
diff --git a/SplitTests/Integration/Sync/FetchSpecificSplitsTest.swift b/SplitTests/Integration/Sync/FetchSpecificSplitsTest.swift
index 33ad1b2e3..6cf055ea7 100644
--- a/SplitTests/Integration/Sync/FetchSpecificSplitsTest.swift
+++ b/SplitTests/Integration/Sync/FetchSpecificSplitsTest.swift
@@ -83,7 +83,7 @@ class FetchSpecificSplitsTest: XCTestCase {
         let sdkReadyExpectation = XCTestExpectation(description: "SDK READY Expectation")
         var sdkReadyFired = false
         
-        client?.on(event: SplitEvent.sdkReady) {
+        client?.on(event: .sdkReady) {
             sdkReadyFired = true
             sdkReadyExpectation.fulfill()
         }
diff --git a/SplitTests/Integration/Sync/MySegmentServerErrorTest.swift b/SplitTests/Integration/Sync/MySegmentServerErrorTest.swift
index f152e7e2f..630d9df85 100644
--- a/SplitTests/Integration/Sync/MySegmentServerErrorTest.swift
+++ b/SplitTests/Integration/Sync/MySegmentServerErrorTest.swift
@@ -121,7 +121,7 @@ class MySegmentServerErrorTest: XCTestCase {
 
         var sdkReadyFired = false
         
-        client.on(event: SplitEvent.sdkReady) {
+        client.on(event: .sdkReady) {
             sdkReadyFired = true
             sdkReady.fulfill()
         }
diff --git a/SplitTests/Integration/Sync/MySegmentUpadatedTest.swift b/SplitTests/Integration/Sync/MySegmentUpadatedTest.swift
index 5cf65c186..b124e9d63 100644
--- a/SplitTests/Integration/Sync/MySegmentUpadatedTest.swift
+++ b/SplitTests/Integration/Sync/MySegmentUpadatedTest.swift
@@ -137,7 +137,7 @@ class MySegmentUpdatedTest: XCTestCase {
 
         var sdkReadyFired = false
         
-        client.on(event: SplitEvent.sdkReady) {
+        client.on(event: .sdkReady) {
             sdkReadyFired = true
             sdkReady.fulfill()
         }
diff --git a/SplitTests/Integration/Sync/SingleSyncTest.swift b/SplitTests/Integration/Sync/SingleSyncTest.swift
index f67c0ba10..ce9614053 100644
--- a/SplitTests/Integration/Sync/SingleSyncTest.swift
+++ b/SplitTests/Integration/Sync/SingleSyncTest.swift
@@ -53,11 +53,11 @@ class SingleSyncTest: XCTestCase {
         let client = factory.client
         let sdkReadyExpectation = XCTestExpectation(description: "SDK READY Expectation")
 
-        client.on(event: SplitEvent.sdkReady) {
+        client.on(event: .sdkReady) {
             sdkReadyExpectation.fulfill()
         }
 
-        client.on(event: SplitEvent.sdkReadyTimedOut) {
+        client.on(event: .sdkReadyTimedOut) {
             sdkReadyExpectation.fulfill()
         }
 
@@ -97,11 +97,11 @@ class SingleSyncTest: XCTestCase {
         let client = factory.client
         let sdkReadyExpectation = XCTestExpectation(description: "SDK READY Expectation")
 
-        client.on(event: SplitEvent.sdkReady) {
+        client.on(event: .sdkReady) {
             sdkReadyExpectation.fulfill()
         }
 
-        client.on(event: SplitEvent.sdkReadyTimedOut) {
+        client.on(event: .sdkReadyTimedOut) {
             sdkReadyExpectation.fulfill()
         }
 
@@ -137,11 +137,11 @@ class SingleSyncTest: XCTestCase {
         let client = factory.client
         let sdkReadyExpectation = XCTestExpectation(description: "SDK READY Expectation")
 
-        client.on(event: SplitEvent.sdkReady) {
+        client.on(event: .sdkReady) {
             sdkReadyExpectation.fulfill()
         }
 
-        client.on(event: SplitEvent.sdkReadyTimedOut) {
+        client.on(event: .sdkReadyTimedOut) {
             sdkReadyExpectation.fulfill()
         }
 
diff --git a/SplitTests/Integration/Sync/SplitChangesServerErrorTest.swift b/SplitTests/Integration/Sync/SplitChangesServerErrorTest.swift
index 79812a77a..5a2f7aa95 100644
--- a/SplitTests/Integration/Sync/SplitChangesServerErrorTest.swift
+++ b/SplitTests/Integration/Sync/SplitChangesServerErrorTest.swift
@@ -121,7 +121,7 @@ class SplitChangesServerErrorTest: XCTestCase {
 
         var sdkReadyFired = false
         
-        client.on(event: SplitEvent.sdkReady) {
+        client.on(event: .sdkReady) {
             sdkReadyFired = true
             sdkReady.fulfill()
         }
diff --git a/SplitTests/Integration/Sync/SplitChangesTest.swift b/SplitTests/Integration/Sync/SplitChangesTest.swift
index 3b418b092..da9b4f8f2 100644
--- a/SplitTests/Integration/Sync/SplitChangesTest.swift
+++ b/SplitTests/Integration/Sync/SplitChangesTest.swift
@@ -72,7 +72,7 @@ class SplitChangesTest: XCTestCase {
 
         var sdkReadyFired = false
         
-        client.on(event: SplitEvent.sdkReady) {
+        client.on(event: .sdkReady) {
             sdkReadyFired = true
             sdkReady.fulfill()
         }
diff --git a/SplitTests/Integration/Sync/SplitSdkUpdatePollingTest.swift b/SplitTests/Integration/Sync/SplitSdkUpdatePollingTest.swift
index 5bc4c8e0d..9da869e05 100644
--- a/SplitTests/Integration/Sync/SplitSdkUpdatePollingTest.swift
+++ b/SplitTests/Integration/Sync/SplitSdkUpdatePollingTest.swift
@@ -131,12 +131,12 @@ class SplitSdkUpdatePollingTest: XCTestCase {
         var sdkReadyFired = false
         var sdkUpdatedFired = false
         
-        client.on(event: SplitEvent.sdkReady) {
+        client.on(event: .sdkReady) {
             sdkReadyFired = true
             sdkReady.fulfill()
         }
 
-        client.on(event: SplitEvent.sdkUpdated) {
+        client.on(event: .sdkUpdated) {
             sdkUpdatedFired = true
         }
         
@@ -184,12 +184,12 @@ class SplitSdkUpdatePollingTest: XCTestCase {
         var sdkReadyFired = false
         var sdkUpdatedFired = false
 
-        client.on(event: SplitEvent.sdkReady) {
+        client.on(event: .sdkReady) {
             sdkReadyFired = true
             sdkReady.fulfill()
         }
 
-        client.on(event: SplitEvent.sdkUpdated) {
+        client.on(event: .sdkUpdated) {
             sdkUpdatedFired = true
             sdkUpdate.fulfill()
         }
@@ -236,12 +236,12 @@ class SplitSdkUpdatePollingTest: XCTestCase {
         var sdkReadyFired = false
         var sdkUpdatedFired = false
 
-        client.on(event: SplitEvent.sdkReady) {
+        client.on(event: .sdkReady) {
             sdkReadyFired = true
             sdkReady.fulfill()
         }
 
-        client.on(event: SplitEvent.sdkUpdated) {
+        client.on(event: .sdkUpdated) {
             sdkUpdatedFired = true
             sdkUpdate.fulfill()
         }
diff --git a/SplitTests/Integration/Sync/SyncPostBgTest.swift b/SplitTests/Integration/Sync/SyncPostBgTest.swift
index b942ffec6..6a159701c 100644
--- a/SplitTests/Integration/Sync/SyncPostBgTest.swift
+++ b/SplitTests/Integration/Sync/SyncPostBgTest.swift
@@ -48,11 +48,11 @@ class SyncPostBgTest: XCTestCase {
         let factory = buildFactory()
         let client = factory.client
         let sdkReadyExpectation = XCTestExpectation(description: "SDK READY Expectation")
-        client.on(event: SplitEvent.sdkReady) {
+        client.on(event: .sdkReady) {
             sdkReadyExpectation.fulfill()
         }
 
-        client.on(event: SplitEvent.sdkReadyTimedOut) {
+        client.on(event: .sdkReadyTimedOut) {
             sdkReadyExpectation.fulfill()
         }
 
diff --git a/SplitTests/Integration/streaming/InstantFeatureFlagsUpdateTest.swift b/SplitTests/Integration/streaming/InstantFeatureFlagsUpdateTest.swift
index efd45f001..71ff3cffb 100644
--- a/SplitTests/Integration/streaming/InstantFeatureFlagsUpdateTest.swift
+++ b/SplitTests/Integration/streaming/InstantFeatureFlagsUpdateTest.swift
@@ -47,11 +47,11 @@ class InstantFeatureFlagsUpdateTest: XCTestCase {
         let sdkReadyExp = XCTestExpectation(description: "SDK READY Expectation")
         var sdkUpdExp = XCTestExpectation(description: "SDK UPDATE Expectation")
 
-        client.on(event: SplitEvent.sdkReady) {
+        client.on(event: .sdkReady) {
             sdkReadyExp.fulfill()
         }
 
-        client.on(event: SplitEvent.sdkUpdated) {
+        client.on(event: .sdkUpdated) {
             sdkUpdExp.fulfill()
         }
 
@@ -94,11 +94,11 @@ class InstantFeatureFlagsUpdateTest: XCTestCase {
         let sdkReadyExp = XCTestExpectation(description: "SDK READY Expectation")
         var sdkUpdExp = XCTestExpectation(description: "SDK UPDATE Expectation")
 
-        client.on(event: SplitEvent.sdkReady) {
+        client.on(event: .sdkReady) {
             sdkReadyExp.fulfill()
         }
 
-        client.on(event: SplitEvent.sdkUpdated) {
+        client.on(event: .sdkUpdated) {
             sdkUpdExp.fulfill()
         }
 
@@ -141,11 +141,11 @@ class InstantFeatureFlagsUpdateTest: XCTestCase {
         let sdkReadyExp = XCTestExpectation(description: "SDK READY Expectation")
         var sdkUpdExp = XCTestExpectation(description: "SDK UPDATE Expectation")
 
-        client.on(event: SplitEvent.sdkReady) {
+        client.on(event: .sdkReady) {
             sdkReadyExp.fulfill()
         }
 
-        client.on(event: SplitEvent.sdkUpdated) {
+        client.on(event: .sdkUpdated) {
             sdkUpdExp.fulfill()
         }
 
diff --git a/SplitTests/Integration/streaming/MySegmentUpdateTest.swift b/SplitTests/Integration/streaming/MySegmentUpdateTest.swift
index 90d12b5fb..46c9ab7be 100644
--- a/SplitTests/Integration/streaming/MySegmentUpdateTest.swift
+++ b/SplitTests/Integration/streaming/MySegmentUpdateTest.swift
@@ -55,11 +55,11 @@ class MySegmentUpdateTest: XCTestCase {
         let sdkReadyExp = XCTestExpectation(description: "SDK READY Expectation")
         var sdkUpdExp = XCTestExpectation(description: "SDK UPDATE Expectation")
 
-        client.on(event: SplitEvent.sdkReady) {
+        client.on(event: .sdkReady) {
             sdkReadyExp.fulfill()
         }
 
-        client.on(event: SplitEvent.sdkUpdated) {
+        client.on(event: .sdkUpdated) {
             sdkUpdExp.fulfill()
         }
 
@@ -136,11 +136,11 @@ class MySegmentUpdateTest: XCTestCase {
         let sdkReadyExp = XCTestExpectation(description: "SDK READY Expectation")
         var sdkUpdExp = XCTestExpectation(description: "SDK UPDATE Expectation")
 
-        client.on(event: SplitEvent.sdkReady) {
+        client.on(event: .sdkReady) {
             sdkReadyExp.fulfill()
         }
 
-        client.on(event: SplitEvent.sdkUpdated) {
+        client.on(event: .sdkUpdated) {
             sdkUpdExp.fulfill()
         }
 
@@ -150,11 +150,11 @@ class MySegmentUpdateTest: XCTestCase {
         let userKeyM = "09025e90-d396-433a-9292-acef23cf0ad1"
         let mClient = testFactory!.client(matchingKey: userKeyM)
 
-        mClient.on(event: SplitEvent.sdkReady) {
+        mClient.on(event: .sdkReady) {
             sdkReadyMExp.fulfill()
         }
 
-        mClient.on(event: SplitEvent.sdkUpdated) {
+        mClient.on(event: .sdkUpdated) {
             sdkUpdMExp.fulfill()
         }
 
@@ -218,11 +218,11 @@ class MySegmentUpdateTest: XCTestCase {
         let sdkReadyExp = XCTestExpectation(description: "SDK READY Expectation")
         var sdkUpdExp = XCTestExpectation(description: "SDK UPDATE Expectation")
 
-        client.on(event: SplitEvent.sdkReady) {
+        client.on(event: .sdkReady) {
             sdkReadyExp.fulfill()
         }
 
-        client.on(event: SplitEvent.sdkUpdated) {
+        client.on(event: .sdkUpdated) {
             sdkUpdExp.fulfill()
         }
 
diff --git a/SplitTests/Integration/streaming/SdkUpdateStreamingTest.swift b/SplitTests/Integration/streaming/SdkUpdateStreamingTest.swift
index 81451b493..b548f1dc4 100644
--- a/SplitTests/Integration/streaming/SdkUpdateStreamingTest.swift
+++ b/SplitTests/Integration/streaming/SdkUpdateStreamingTest.swift
@@ -77,16 +77,16 @@ class SdkUpdateStreamingTest: XCTestCase {
         var sdkReadyTriggered = false
         var sdkUpdatedTriggered = false
 
-        client.on(event: SplitEvent.sdkReady) {
+        client.on(event: .sdkReady) {
             sdkReadyTriggered = true
             sdkReadyExpectation.fulfill()
         }
 
-        client.on(event: SplitEvent.sdkUpdated) {
+        client.on(event: .sdkUpdated) {
             sdkUpdatedTriggered = true
         }
 
-        client.on(event: SplitEvent.sdkReadyTimedOut) {
+        client.on(event: .sdkReadyTimedOut) {
             sdkReadyExpectation.fulfill()
         }
 
@@ -137,17 +137,17 @@ class SdkUpdateStreamingTest: XCTestCase {
         var sdkReadyTriggered = false
         var sdkUpdatedTriggered = false
 
-        client.on(event: SplitEvent.sdkReady) {
+        client.on(event: .sdkReady) {
             sdkReadyTriggered = true
             sdkReadyExpectation.fulfill()
         }
 
-        client.on(event: SplitEvent.sdkUpdated) {
+        client.on(event: .sdkUpdated) {
             sdkUpdatedTriggered = true
             sdkUpdateExpectation.fulfill()
         }
 
-        client.on(event: SplitEvent.sdkReadyTimedOut) {
+        client.on(event: .sdkReadyTimedOut) {
             sdkReadyExpectation.fulfill()
         }
 
@@ -200,17 +200,17 @@ class SdkUpdateStreamingTest: XCTestCase {
         var sdkReadyTriggered = false
         var sdkUpdatedTriggered = false
 
-        client.on(event: SplitEvent.sdkReady) {
+        client.on(event: .sdkReady) {
             sdkReadyTriggered = true
             sdkReadyExpectation.fulfill()
         }
 
-        client.on(event: SplitEvent.sdkUpdated) {
+        client.on(event: .sdkUpdated) {
             sdkUpdatedTriggered = true
             sdkUpdateExpectation.fulfill()
         }
 
-        client.on(event: SplitEvent.sdkReadyTimedOut) {
+        client.on(event: .sdkReadyTimedOut) {
             sdkReadyExpectation.fulfill()
         }
 
diff --git a/SplitTests/Integration/streaming/StreamingAuthFail4xxTest.swift b/SplitTests/Integration/streaming/StreamingAuthFail4xxTest.swift
index 0cd46bee5..397f64795 100644
--- a/SplitTests/Integration/streaming/StreamingAuthFail4xxTest.swift
+++ b/SplitTests/Integration/streaming/StreamingAuthFail4xxTest.swift
@@ -53,12 +53,12 @@ class StreamingAuthFail4xxTest: XCTestCase {
         var timeOutFired = false
         var sdkReadyFired = false
 
-        client.on(event: SplitEvent.sdkReady) {
+        client.on(event: .sdkReady) {
             sdkReadyFired = true
             sdkReadyExpectation.fulfill()
         }
 
-        client.on(event: SplitEvent.sdkReadyTimedOut) {
+        client.on(event: .sdkReadyTimedOut) {
             timeOutFired = true
             sdkReadyExpectation.fulfill()
         }
diff --git a/SplitTests/Integration/streaming/StreamingAuthFail5xxTest.swift b/SplitTests/Integration/streaming/StreamingAuthFail5xxTest.swift
index 9bd01e977..874af06e5 100644
--- a/SplitTests/Integration/streaming/StreamingAuthFail5xxTest.swift
+++ b/SplitTests/Integration/streaming/StreamingAuthFail5xxTest.swift
@@ -58,12 +58,12 @@ class StreamingAuthFail5xxTest: XCTestCase {
         var timeOutFired = false
         var sdkReadyFired = false
 
-        client.on(event: SplitEvent.sdkReady) {
+        client.on(event: .sdkReady) {
             sdkReadyFired = true
             sdkReadyExpectation.fulfill()
         }
 
-        client.on(event: SplitEvent.sdkReadyTimedOut) {
+        client.on(event: .sdkReadyTimedOut) {
             timeOutFired = true
             sdkReadyExpectation.fulfill()
         }
diff --git a/SplitTests/Integration/streaming/StreamingBgReconnectTest.swift b/SplitTests/Integration/streaming/StreamingBgReconnectTest.swift
index 2a4865bb4..856dae44c 100644
--- a/SplitTests/Integration/streaming/StreamingBgReconnectTest.swift
+++ b/SplitTests/Integration/streaming/StreamingBgReconnectTest.swift
@@ -44,11 +44,11 @@ class StreamingBgReconnectTest: XCTestCase {
 
         let sdkReadyExpectation = XCTestExpectation(description: "SDK READY Expectation")
 
-        client.on(event: SplitEvent.sdkReady) {
+        client.on(event: .sdkReady) {
             sdkReadyExpectation.fulfill()
         }
 
-        client.on(event: SplitEvent.sdkReadyTimedOut) {
+        client.on(event: .sdkReadyTimedOut) {
             sdkReadyExpectation.fulfill()
         }
 
diff --git a/SplitTests/Integration/streaming/StreamingConnFail5xxTest.swift b/SplitTests/Integration/streaming/StreamingConnFail5xxTest.swift
index d8a6a8852..061697f01 100644
--- a/SplitTests/Integration/streaming/StreamingConnFail5xxTest.swift
+++ b/SplitTests/Integration/streaming/StreamingConnFail5xxTest.swift
@@ -48,12 +48,12 @@ class StreamingConnFail5xxTest: XCTestCase {
         var timeOutFired = false
         var sdkReadyFired = false
 
-        client.on(event: SplitEvent.sdkReady) {
+        client.on(event: .sdkReady) {
             sdkReadyFired = true
             sdkReadyExpectation.fulfill()
         }
 
-        client.on(event: SplitEvent.sdkReadyTimedOut) {
+        client.on(event: .sdkReadyTimedOut) {
             timeOutFired = true
             sdkReadyExpectation.fulfill()
         }
diff --git a/SplitTests/Integration/streaming/StreamingControlResetTest.swift b/SplitTests/Integration/streaming/StreamingControlResetTest.swift
index 5c2739f95..b67b7e985 100644
--- a/SplitTests/Integration/streaming/StreamingControlResetTest.swift
+++ b/SplitTests/Integration/streaming/StreamingControlResetTest.swift
@@ -49,7 +49,7 @@ class StreamingControlResetTest: XCTestCase {
 
         let sdkReadyExpectation = XCTestExpectation(description: "SDK READY Expectation")
 
-        client.on(event: SplitEvent.sdkReady) {
+        client.on(event: .sdkReady) {
             sdkReadyExpectation.fulfill()
         }
 
diff --git a/SplitTests/Integration/streaming/StreamingControlTest.swift b/SplitTests/Integration/streaming/StreamingControlTest.swift
index 12d8d054b..33e404575 100644
--- a/SplitTests/Integration/streaming/StreamingControlTest.swift
+++ b/SplitTests/Integration/streaming/StreamingControlTest.swift
@@ -50,7 +50,7 @@ class StreamingControlTest: XCTestCase {
 
         let sdkReadyExpectation = XCTestExpectation(description: "SDK READY Expectation")
 
-        client.on(event: SplitEvent.sdkReady) {
+        client.on(event: .sdkReady) {
             sdkReadyExpectation.fulfill()
         }
 
diff --git a/SplitTests/Integration/streaming/StreamingDelayTest.swift b/SplitTests/Integration/streaming/StreamingDelayTest.swift
index 81bdbcc44..f4a179c56 100644
--- a/SplitTests/Integration/streaming/StreamingDelayTest.swift
+++ b/SplitTests/Integration/streaming/StreamingDelayTest.swift
@@ -50,7 +50,7 @@ class StreamingDelaytTest: XCTestCase {
 
         let sdkReadyExpectation = XCTestExpectation(description: "SDK READY Expectation")
 
-        client.on(event: SplitEvent.sdkReady) {
+        client.on(event: .sdkReady) {
             sdkReadyExpectation.fulfill()
         }
 
@@ -87,7 +87,7 @@ class StreamingDelaytTest: XCTestCase {
 
         let sdkReadyExpectation = XCTestExpectation(description: "SDK READY Expectation")
 
-        client.on(event: SplitEvent.sdkReady) {
+        client.on(event: .sdkReady) {
             sdkReadyExpectation.fulfill()
         }
 
@@ -126,7 +126,7 @@ class StreamingDelaytTest: XCTestCase {
 
         let sdkReadyExpectation = XCTestExpectation(description: "SDK READY Expectation")
 
-        client.on(event: SplitEvent.sdkReady) {
+        client.on(event: .sdkReady) {
             sdkReadyExpectation.fulfill()
         }
 
@@ -177,7 +177,7 @@ class StreamingDelaytTest: XCTestCase {
 
         let sdkReadyExpectation = XCTestExpectation(description: "SDK READY Expectation")
 
-        client.on(event: SplitEvent.sdkReady) {
+        client.on(event: .sdkReady) {
             sdkReadyExpectation.fulfill()
         }
 
diff --git a/SplitTests/Integration/streaming/StreamingDisabledTest.swift b/SplitTests/Integration/streaming/StreamingDisabledTest.swift
index 5c955a10f..241573585 100644
--- a/SplitTests/Integration/streaming/StreamingDisabledTest.swift
+++ b/SplitTests/Integration/streaming/StreamingDisabledTest.swift
@@ -45,12 +45,12 @@ class StreamingDisabledTest: XCTestCase {
         var sdkReadyFired = false
         syncSpy.startPeriodicFetchingExp = pollingExp
 
-        client.on(event: SplitEvent.sdkReady) {
+        client.on(event: .sdkReady) {
             sdkReadyFired = true
             sdkReadyExpectation.fulfill()
         }
 
-        client.on(event: SplitEvent.sdkReadyTimedOut) {
+        client.on(event: .sdkReadyTimedOut) {
             timeOutFired = true
             sdkReadyExpectation.fulfill()
         }
diff --git a/SplitTests/Integration/streaming/StreamingInitTest.swift b/SplitTests/Integration/streaming/StreamingInitTest.swift
index 1740a85fc..ead68f559 100644
--- a/SplitTests/Integration/streaming/StreamingInitTest.swift
+++ b/SplitTests/Integration/streaming/StreamingInitTest.swift
@@ -63,12 +63,12 @@ class StreamingInitTest: XCTestCase {
         var timeOutFired = false
         var sdkReadyFired = false
 
-        client.on(event: SplitEvent.sdkReady) {
+        client.on(event: .sdkReady) {
             sdkReadyFired = true
             sdkReadyExpectation.fulfill()
         }
 
-        client.on(event: SplitEvent.sdkReadyTimedOut) {
+        client.on(event: .sdkReadyTimedOut) {
             timeOutFired = true
             sdkReadyExpectation.fulfill()
         }
diff --git a/SplitTests/Integration/streaming/StreamingMySegmentsSyncTest.swift b/SplitTests/Integration/streaming/StreamingMySegmentsSyncTest.swift
index 766f1b564..d5a071483 100644
--- a/SplitTests/Integration/streaming/StreamingMySegmentsSyncTest.swift
+++ b/SplitTests/Integration/streaming/StreamingMySegmentsSyncTest.swift
@@ -85,12 +85,12 @@ class StreamingMySegmentsSyncTest: XCTestCase {
 
         let sdkReadyExpectation = XCTestExpectation(description: "SDK READY Expectation")
 
-        client.on(event: SplitEvent.sdkReady) {
+        client.on(event: .sdkReady) {
             print("Ready triggered")
             sdkReadyExpectation.fulfill()
         }
 
-        client.on(event: SplitEvent.sdkReadyTimedOut) {
+        client.on(event: .sdkReadyTimedOut) {
             sdkReadyExpectation.fulfill()
         }
 
diff --git a/SplitTests/Integration/streaming/StreamingNoReconectWhenPollingTest.swift b/SplitTests/Integration/streaming/StreamingNoReconectWhenPollingTest.swift
index da5df3726..08514ee38 100644
--- a/SplitTests/Integration/streaming/StreamingNoReconectWhenPollingTest.swift
+++ b/SplitTests/Integration/streaming/StreamingNoReconectWhenPollingTest.swift
@@ -62,7 +62,7 @@ class StreamingNoReconectWhenPollingTest: XCTestCase {
 
         let sdkReadyExpectation = XCTestExpectation(description: "SDK READY Expectation")
 
-        client.on(event: SplitEvent.sdkReady) {
+        client.on(event: .sdkReady) {
             sdkReadyExpectation.fulfill()
         }
 
diff --git a/SplitTests/Integration/streaming/StreamingOccupancyTest.swift b/SplitTests/Integration/streaming/StreamingOccupancyTest.swift
index b971a6c4d..7e7e8d428 100644
--- a/SplitTests/Integration/streaming/StreamingOccupancyTest.swift
+++ b/SplitTests/Integration/streaming/StreamingOccupancyTest.swift
@@ -45,11 +45,11 @@ class StreamingOccupancyTest: XCTestCase {
 
         let sdkReadyExpectation = XCTestExpectation(description: "SDK READY Expectation")
 
-        client.on(event: SplitEvent.sdkReady) {
+        client.on(event: SplitEventCase.sdkReady) {
             sdkReadyExpectation.fulfill()
         }
 
-        client.on(event: SplitEvent.sdkReadyTimedOut) {
+        client.on(event: SplitEventCase.sdkReadyTimedOut) {
             sdkReadyExpectation.fulfill()
         }
 
diff --git a/SplitTests/Integration/streaming/StreamingSplitKillTest.swift b/SplitTests/Integration/streaming/StreamingSplitKillTest.swift
index 4df9e5b26..097b17451 100644
--- a/SplitTests/Integration/streaming/StreamingSplitKillTest.swift
+++ b/SplitTests/Integration/streaming/StreamingSplitKillTest.swift
@@ -63,11 +63,11 @@ class StreamingSplitKillTest: XCTestCase {
         exp3 = XCTestExpectation(description: "Exp3")
         exp4 = XCTestExpectation(description: "Exp4")
 
-        client.on(event: SplitEvent.sdkReady) {
+        client.on(event: .sdkReady) {
             sdkReadyExpectation.fulfill()
         }
 
-        client.on(event: SplitEvent.sdkReadyTimedOut) {
+        client.on(event: .sdkReadyTimedOut) {
             IntegrationHelper.tlog("TIMEOUT")
         }
 
diff --git a/SplitTests/Integration/streaming/StreamingSplitsSyncTest.swift b/SplitTests/Integration/streaming/StreamingSplitsSyncTest.swift
index 54763695a..58df1be36 100644
--- a/SplitTests/Integration/streaming/StreamingSplitsSyncTest.swift
+++ b/SplitTests/Integration/streaming/StreamingSplitsSyncTest.swift
@@ -76,11 +76,11 @@ class StreamingSplitsSyncTest: XCTestCase {
         let sdkReadyExpectation = XCTestExpectation(description: "SDK READY Expectation")
         
 
-        client.on(event: SplitEvent.sdkReady) {
+        client.on(event: .sdkReady) {
             sdkReadyExpectation.fulfill()
         }
 
-        client.on(event: SplitEvent.sdkReadyTimedOut) {
+        client.on(event: .sdkReadyTimedOut) {
             IntegrationHelper.tlog("sssc TIMEOUT")
         }
 
diff --git a/SplitTests/Integration/streaming/TelemetryIntegrationTest.swift b/SplitTests/Integration/streaming/TelemetryIntegrationTest.swift
index 29900b878..a4d1417a1 100644
--- a/SplitTests/Integration/streaming/TelemetryIntegrationTest.swift
+++ b/SplitTests/Integration/streaming/TelemetryIntegrationTest.swift
@@ -62,11 +62,11 @@ class TelemetryIntegrationTest: XCTestCase {
 
         let sdkReadyExpectation = XCTestExpectation(description: "SDK READY Expectation")
 
-        client.on(event: SplitEvent.sdkReady) {
+        client.on(event: .sdkReady) {
             sdkReadyExpectation.fulfill()
         }
 
-        client.on(event: SplitEvent.sdkReadyTimedOut) {
+        client.on(event: .sdkReadyTimedOut) {
             IntegrationHelper.tlog("TIMEOUT")
         }
 
@@ -127,11 +127,11 @@ class TelemetryIntegrationTest: XCTestCase {
 
         let sdkReadyExpectation = XCTestExpectation(description: "SDK READY Expectation")
 
-        client.on(event: SplitEvent.sdkReady) {
+        client.on(event: .sdkReady) {
             sdkReadyExpectation.fulfill()
         }
 
-        client.on(event: SplitEvent.sdkReadyTimedOut) {
+        client.on(event: .sdkReadyTimedOut) {
             IntegrationHelper.tlog("TIMEOUT")
         }
 
@@ -210,11 +210,11 @@ class TelemetryIntegrationTest: XCTestCase {
 
         let sdkReadyExpectation = XCTestExpectation(description: "SDK READY Expectation")
 
-        client.on(event: SplitEvent.sdkReady) {
+        client.on(event: .sdkReady) {
             sdkReadyExpectation.fulfill()
         }
 
-        client.on(event: SplitEvent.sdkReadyTimedOut) {
+        client.on(event: .sdkReadyTimedOut) {
             IntegrationHelper.tlog("TIMEOUT")
         }
 
@@ -297,11 +297,11 @@ class TelemetryIntegrationTest: XCTestCase {
 
         let sdkReadyExpectation = XCTestExpectation(description: "SDK READY Expectation")
 
-        client.on(event: SplitEvent.sdkReady) {
+        client.on(event: .sdkReady) {
             sdkReadyExpectation.fulfill()
         }
 
-        client.on(event: SplitEvent.sdkReadyTimedOut) {
+        client.on(event: .sdkReadyTimedOut) {
             IntegrationHelper.tlog("TIMEOUT")
         }
 
@@ -357,11 +357,11 @@ class TelemetryIntegrationTest: XCTestCase {
 
         let sdkReadyExpectation = XCTestExpectation(description: "SDK READY Expectation")
 
-        client.on(event: SplitEvent.sdkReady) {
+        client.on(event: .sdkReady) {
             sdkReadyExpectation.fulfill()
         }
 
-        client.on(event: SplitEvent.sdkReadyTimedOut) {
+        client.on(event: .sdkReadyTimedOut) {
             IntegrationHelper.tlog("TIMEOUT")
         }
 
diff --git a/SplitTests/Service/MySegments/SegmentsSyncHelperTests.swift b/SplitTests/Service/MySegments/SegmentsSyncHelperTests.swift
index 395e88c25..c16a6568f 100644
--- a/SplitTests/Service/MySegments/SegmentsSyncHelperTests.swift
+++ b/SplitTests/Service/MySegments/SegmentsSyncHelperTests.swift
@@ -69,8 +69,19 @@ class SegmentsSyncHelperTests: XCTestCase {
         XCTAssertEqual(userKey, mySegmentsFetcher.lastUserKey)
         XCTAssertNil(mySegmentsFetcher.lastTill)
         XCTAssertTrue(res.success)
-        XCTAssertEqual(res.msUpdated, segmentsChanged)
-        XCTAssertEqual(res.mlsUpdated, segmentsChanged)
+        
+        var msUpdated = false
+        if !res.msUpdated.isEmpty {
+            msUpdated = true
+        }
+        
+        var mlsUpdated = false
+        if !res.mlsUpdated.isEmpty {
+            mlsUpdated = true
+        }
+        
+        XCTAssertEqual(msUpdated, segmentsChanged)
+        XCTAssertEqual(mlsUpdated, segmentsChanged)
         XCTAssertEqual(301, res.msChangeNumber)
         XCTAssertEqual(301, res.mlsChangeNumber)
     }
diff --git a/SplitTests/SplitEventsManagerTest.swift b/SplitTests/SplitEventsManagerTest.swift
index 9f66d2936..29fc3df5f 100644
--- a/SplitTests/SplitEventsManagerTest.swift
+++ b/SplitTests/SplitEventsManagerTest.swift
@@ -22,20 +22,20 @@ class SplitEventsManagerTest: XCTestCase {
         let config: SplitClientConfig = SplitClientConfig()
         let eventManager: SplitEventsManager = DefaultSplitEventsManager(config: config)
         let updatedTask = TestTask(exp: nil)
-        eventManager.register(event: .sdkUpdated, task: updatedTask)
+        eventManager.register(event: SplitEvent(type: .sdkUpdated), task: updatedTask)
         eventManager.start()
         
-        eventManager.notifyInternalEvent(SplitInternalEvent.mySegmentsUpdated)
-        eventManager.notifyInternalEvent(SplitInternalEvent.myLargeSegmentsUpdated)
-        eventManager.notifyInternalEvent(SplitInternalEvent.splitsUpdated)
-        eventManager.notifyInternalEvent(SplitInternalEvent.splitsUpdated)
+        eventManager.notifyInternalEvent(.mySegmentsUpdated)
+        eventManager.notifyInternalEvent(.myLargeSegmentsUpdated)
+        eventManager.notifyInternalEvent(.splitsUpdated)
+        eventManager.notifyInternalEvent(.splitsUpdated)
         ThreadUtils.delay(seconds: 0.2)
         
         let expectation = XCTestExpectation(description: "SDK Readky triggered")
         queue.async {
             while !shouldStop {
                 sleep(UInt32(self.intervalExecutionTime))
-                if eventManager.eventAlreadyTriggered(event: SplitEvent.sdkReady) {
+                if eventManager.eventAlreadyTriggered(event: .sdkReady) {
                     shouldStop = true;
                     expectation.fulfill()
                 }
@@ -43,9 +43,9 @@ class SplitEventsManagerTest: XCTestCase {
         }
         wait(for: [expectation], timeout: expectationTimeOut)
         
-        XCTAssertTrue(eventManager.eventAlreadyTriggered(event: SplitEvent.sdkReady), "SDK Ready should be triggered");
-        XCTAssertFalse(eventManager.eventAlreadyTriggered(event: SplitEvent.sdkUpdated), "SDK Update shouldn't be triggered");
-        XCTAssertFalse(eventManager.eventAlreadyTriggered(event: SplitEvent.sdkReadyTimedOut), "SDK Time out shouldn't be triggered");
+        XCTAssertTrue(eventManager.eventAlreadyTriggered(event: .sdkReady), "SDK Ready should be triggered");
+        XCTAssertFalse(eventManager.eventAlreadyTriggered(event: .sdkUpdated), "SDK Update shouldn't be triggered");
+        XCTAssertFalse(eventManager.eventAlreadyTriggered(event: .sdkReadyTimedOut), "SDK Time out shouldn't be triggered");
 
         eventManager.stop()
     }
@@ -56,20 +56,20 @@ class SplitEventsManagerTest: XCTestCase {
         let eventManager: SplitEventsManager = DefaultSplitEventsManager(config: config)
         eventManager.start()
 
-        eventManager.notifyInternalEvent(SplitInternalEvent.mySegmentsLoadedFromCache)
-        eventManager.notifyInternalEvent(SplitInternalEvent.myLargeSegmentsLoadedFromCache)
-        eventManager.notifyInternalEvent(SplitInternalEvent.splitsLoadedFromCache)
-        eventManager.notifyInternalEvent(SplitInternalEvent.attributesLoadedFromCache)
+        eventManager.notifyInternalEvent(.mySegmentsLoadedFromCache)
+        eventManager.notifyInternalEvent(.myLargeSegmentsLoadedFromCache)
+        eventManager.notifyInternalEvent(.splitsLoadedFromCache)
+        eventManager.notifyInternalEvent(.attributesLoadedFromCache)
 
-        eventManager.notifyInternalEvent(SplitInternalEvent.mySegmentsUpdated)
-        eventManager.notifyInternalEvent(SplitInternalEvent.myLargeSegmentsUpdated)
-        eventManager.notifyInternalEvent(SplitInternalEvent.splitsUpdated)
+        eventManager.notifyInternalEvent(.mySegmentsUpdated)
+        eventManager.notifyInternalEvent(.myLargeSegmentsUpdated)
+        eventManager.notifyInternalEvent(.splitsUpdated)
         var shouldStop = false
         let expectation = XCTestExpectation(description: "SDK Readky from cache triggered")
         queue.async {
             while !shouldStop {
                 sleep(UInt32(self.intervalExecutionTime))
-                if eventManager.eventAlreadyTriggered(event: SplitEvent.sdkReady) {
+                if eventManager.eventAlreadyTriggered(event: .sdkReady) {
                     shouldStop = true;
                     expectation.fulfill()
                 }
@@ -77,9 +77,9 @@ class SplitEventsManagerTest: XCTestCase {
         }
         wait(for: [expectation], timeout: expectationTimeOut)
 
-        XCTAssertTrue(eventManager.eventAlreadyTriggered(event: SplitEvent.sdkReadyFromCache), "SDK Ready should from cache be triggered");
-        XCTAssertTrue(eventManager.eventAlreadyTriggered(event: SplitEvent.sdkReady), "SDK Ready should be triggered");
-        XCTAssertFalse(eventManager.eventAlreadyTriggered(event: SplitEvent.sdkReadyTimedOut), "SDK Time out shouldn't be triggered");
+        XCTAssertTrue(eventManager.eventAlreadyTriggered(event: .sdkReadyFromCache), "SDK Ready should from cache be triggered");
+        XCTAssertTrue(eventManager.eventAlreadyTriggered(event: .sdkReady), "SDK Ready should be triggered");
+        XCTAssertFalse(eventManager.eventAlreadyTriggered(event: .sdkReadyTimedOut), "SDK Time out shouldn't be triggered");
 
         eventManager.stop()
     }
@@ -92,21 +92,21 @@ class SplitEventsManagerTest: XCTestCase {
         eventManager.start()
 
         let cacheExp = XCTestExpectation()
-        eventManager.register(event: .sdkReadyFromCache, task: TestTask(exp: cacheExp))
+        eventManager.register(event: SplitEvent(type: .sdkReadyFromCache), task: TestTask(exp: cacheExp))
         let timeoutExp = XCTestExpectation()
-        eventManager.register(event: .sdkReadyTimedOut, task: TestTask(exp: timeoutExp))
+        eventManager.register(event: SplitEvent(type: .sdkReadyTimedOut), task: TestTask(exp: timeoutExp))
 
-        eventManager.notifyInternalEvent(SplitInternalEvent.mySegmentsLoadedFromCache)
-        eventManager.notifyInternalEvent(SplitInternalEvent.myLargeSegmentsLoadedFromCache)
-        eventManager.notifyInternalEvent(SplitInternalEvent.splitsLoadedFromCache)
-        eventManager.notifyInternalEvent(SplitInternalEvent.attributesLoadedFromCache)
-        eventManager.notifyInternalEvent(SplitInternalEvent.sdkReadyTimeoutReached)
+        eventManager.notifyInternalEvent(.mySegmentsLoadedFromCache)
+        eventManager.notifyInternalEvent(.myLargeSegmentsLoadedFromCache)
+        eventManager.notifyInternalEvent(.splitsLoadedFromCache)
+        eventManager.notifyInternalEvent(.attributesLoadedFromCache)
+        eventManager.notifyInternalEvent(.sdkReadyTimeoutReached)
 
         wait(for: [cacheExp, timeoutExp], timeout: expectationTimeOut)
 
-        XCTAssertTrue(eventManager.eventAlreadyTriggered(event: SplitEvent.sdkReadyFromCache), "SDK Ready should from cache be triggered");
-        XCTAssertFalse(eventManager.eventAlreadyTriggered(event: SplitEvent.sdkReady), "SDK Ready should not be triggered");
-        XCTAssertTrue(eventManager.eventAlreadyTriggered(event: SplitEvent.sdkReadyTimedOut), "SDK Time out should be triggered");
+        XCTAssertTrue(eventManager.eventAlreadyTriggered(event: .sdkReadyFromCache), "SDK Ready should from cache be triggered");
+        XCTAssertFalse(eventManager.eventAlreadyTriggered(event: .sdkReady), "SDK Ready should not be triggered");
+        XCTAssertTrue(eventManager.eventAlreadyTriggered(event: .sdkReadyTimedOut), "SDK Time out should be triggered");
 
         eventManager.stop()
     }
@@ -119,11 +119,11 @@ class SplitEventsManagerTest: XCTestCase {
         eventManager.start()
 
         let timeoutExp = XCTestExpectation()
-        eventManager.register(event: .sdkReadyTimedOut, task: TestTask(exp: timeoutExp))
+        eventManager.register(event: SplitEvent(type: .sdkReadyTimedOut), task: TestTask(exp: timeoutExp))
         wait(for: [timeoutExp], timeout: expectationTimeOut)
         
-        XCTAssertTrue(eventManager.eventAlreadyTriggered(event: SplitEvent.sdkReadyTimedOut), "SDK Time out should be triggered")
-        XCTAssertFalse(eventManager.eventAlreadyTriggered(event: SplitEvent.sdkReady), "SDK Ready shouldn't be triggered")
+        XCTAssertTrue(eventManager.eventAlreadyTriggered(event: .sdkReadyTimedOut), "SDK Time out should be triggered")
+        XCTAssertFalse(eventManager.eventAlreadyTriggered(event: .sdkReady), "SDK Ready shouldn't be triggered")
 
         eventManager.stop()
     }
@@ -136,23 +136,23 @@ class SplitEventsManagerTest: XCTestCase {
         eventManager.start()
 
         let expectationTimeout = XCTestExpectation(description: "SDK Readky triggered")
-        eventManager.register(event: .sdkReadyTimedOut, task: TestTask(exp: expectationTimeout))
+        eventManager.register(event: SplitEvent(type: .sdkReadyTimedOut), task: TestTask(exp: expectationTimeout))
 
         wait(for: [expectationTimeout], timeout: expectationTimeOut)
         
         //At this line timeout has been reached
-        let timeoutTriggered  = eventManager.eventAlreadyTriggered(event: SplitEvent.sdkReadyTimedOut)
+        let timeoutTriggered  = eventManager.eventAlreadyTriggered(event: .sdkReadyTimedOut)
 
         let readyExp = XCTestExpectation(description: "SDK Readky triggered")
-        eventManager.register(event: .sdkReady, task: TestTask(exp: readyExp))
+        eventManager.register(event: SplitEvent(type: .sdkReady), task: TestTask(exp: readyExp))
 
-        eventManager.notifyInternalEvent(SplitInternalEvent.mySegmentsUpdated)
-        eventManager.notifyInternalEvent(SplitInternalEvent.myLargeSegmentsUpdated)
-        eventManager.notifyInternalEvent(SplitInternalEvent.splitsUpdated)
+        eventManager.notifyInternalEvent(.mySegmentsUpdated)
+        eventManager.notifyInternalEvent(.myLargeSegmentsUpdated)
+        eventManager.notifyInternalEvent(.splitsUpdated)
 
         wait(for: [readyExp], timeout: expectationTimeOut)
         
-        XCTAssertTrue(eventManager.eventAlreadyTriggered(event: SplitEvent.sdkReady), "SDK Ready should be triggered");
+        XCTAssertTrue(eventManager.eventAlreadyTriggered(event: .sdkReady), "SDK Ready should be triggered");
         XCTAssertTrue(timeoutTriggered)
 
         eventManager.stop()
@@ -167,20 +167,20 @@ class SplitEventsManagerTest: XCTestCase {
 
         let readyExp = XCTestExpectation()
         let updatedTask = sdkTask(exp: sdkUpdatedExp)
-        eventManager.register(event: .sdkReady, task: TestTask(exp: readyExp))
-        eventManager.register(event: .sdkUpdated, task: updatedTask)
+        eventManager.register(event: SplitEvent(type: .sdkReady), task: TestTask(exp: readyExp))
+        eventManager.register(event: SplitEvent(type: .sdkUpdated), task: updatedTask)
 
-        eventManager.notifyInternalEvent(SplitInternalEvent.mySegmentsUpdated)
-        eventManager.notifyInternalEvent(SplitInternalEvent.myLargeSegmentsUpdated)
-        eventManager.notifyInternalEvent(SplitInternalEvent.splitsUpdated)
+        eventManager.notifyInternalEvent(.mySegmentsUpdated)
+        eventManager.notifyInternalEvent(.myLargeSegmentsUpdated)
+        eventManager.notifyInternalEvent(.splitsUpdated)
         ThreadUtils.delay(seconds: 0.5)
-        eventManager.notifyInternalEvent(SplitInternalEvent.splitsUpdated)
+        eventManager.notifyInternalEvent(.splitsUpdated)
 
         wait(for: [readyExp, sdkUpdatedExp], timeout: expectationTimeOut)
 
-        XCTAssertTrue(eventManager.eventAlreadyTriggered(event: SplitEvent.sdkReady), "SDK Ready should be triggered");
+        XCTAssertTrue(eventManager.eventAlreadyTriggered(event: .sdkReady), "SDK Ready should be triggered");
         XCTAssertTrue(updatedTask.taskTriggered, "SDK Update should be triggered");
-        XCTAssertFalse(eventManager.eventAlreadyTriggered(event: SplitEvent.sdkReadyTimedOut), "SDK Time out shouldn't be triggered");
+        XCTAssertFalse(eventManager.eventAlreadyTriggered(event: .sdkReadyTimedOut), "SDK Time out shouldn't be triggered");
 
         eventManager.stop()
     }
@@ -193,21 +193,21 @@ class SplitEventsManagerTest: XCTestCase {
         eventManager.start()
         let readyExp = XCTestExpectation()
         let updatedTask = sdkTask(exp: sdkUpdatedExp)
-        eventManager.register(event: .sdkReady, task: TestTask(exp: readyExp))
-        eventManager.register(event: .sdkUpdated, task: updatedTask)
+        eventManager.register(event: SplitEvent(type: .sdkReady), task: TestTask(exp: readyExp))
+        eventManager.register(event: SplitEvent(type: .sdkUpdated), task: updatedTask)
 
 
-        eventManager.notifyInternalEvent(SplitInternalEvent.splitsUpdated)
-        eventManager.notifyInternalEvent(SplitInternalEvent.mySegmentsUpdated)
-        eventManager.notifyInternalEvent(SplitInternalEvent.myLargeSegmentsUpdated)
+        eventManager.notifyInternalEvent(.splitsUpdated)
+        eventManager.notifyInternalEvent(.mySegmentsUpdated)
+        eventManager.notifyInternalEvent(.myLargeSegmentsUpdated)
         ThreadUtils.delay(seconds: 0.5)
-        eventManager.notifyInternalEvent(SplitInternalEvent.mySegmentsUpdated)
+        eventManager.notifyInternalEvent(.mySegmentsUpdated)
 
         wait(for: [readyExp, sdkUpdatedExp], timeout: expectationTimeOut)
 
-        XCTAssertTrue(eventManager.eventAlreadyTriggered(event: SplitEvent.sdkReady), "SDK Ready should be triggered");
+        XCTAssertTrue(eventManager.eventAlreadyTriggered(event: .sdkReady), "SDK Ready should be triggered");
         XCTAssertTrue(updatedTask.taskTriggered, "SDK Update should be triggered");
-        XCTAssertFalse(eventManager.eventAlreadyTriggered(event: SplitEvent.sdkReadyTimedOut), "SDK Time out shouldn't be triggered");
+        XCTAssertFalse(eventManager.eventAlreadyTriggered(event: .sdkReadyTimedOut), "SDK Time out shouldn't be triggered");
 
         eventManager.stop()
     }
@@ -220,20 +220,20 @@ class SplitEventsManagerTest: XCTestCase {
         let readyExp = XCTestExpectation()
         let sdkUpdatedExp = XCTestExpectation()
         let updatedTask = sdkTask(exp: sdkUpdatedExp)
-        eventManager.register(event: .sdkReady, task: TestTask(exp: readyExp))
-        eventManager.register(event: .sdkUpdated, task: updatedTask)
+        eventManager.register(event: SplitEvent(type: .sdkReady), task: TestTask(exp: readyExp))
+        eventManager.register(event: SplitEvent(type: .sdkUpdated), task: updatedTask)
 
-        eventManager.notifyInternalEvent(SplitInternalEvent.mySegmentsUpdated)
-        eventManager.notifyInternalEvent(SplitInternalEvent.myLargeSegmentsUpdated)
-        eventManager.notifyInternalEvent(SplitInternalEvent.splitsUpdated)
+        eventManager.notifyInternalEvent(.mySegmentsUpdated)
+        eventManager.notifyInternalEvent(.myLargeSegmentsUpdated)
+        eventManager.notifyInternalEvent(.splitsUpdated)
         ThreadUtils.delay(seconds: 0.5)
-        eventManager.notifyInternalEvent(SplitInternalEvent.splitKilledNotification)
+        eventManager.notifyInternalEvent(.splitKilledNotification)
 
         wait(for: [readyExp, sdkUpdatedExp], timeout: expectationTimeOut)
 
-        XCTAssertTrue(eventManager.eventAlreadyTriggered(event: SplitEvent.sdkReady), "SDK Ready should be triggered");
+        XCTAssertTrue(eventManager.eventAlreadyTriggered(event: .sdkReady), "SDK Ready should be triggered");
         XCTAssertTrue(updatedTask.taskTriggered, "SDK Update should be triggered");
-        XCTAssertFalse(eventManager.eventAlreadyTriggered(event: SplitEvent.sdkReadyTimedOut), "SDK Time out shouldn't be triggered");
+        XCTAssertFalse(eventManager.eventAlreadyTriggered(event: .sdkReadyTimedOut), "SDK Time out shouldn't be triggered");
 
         eventManager.stop()
     }
@@ -246,19 +246,19 @@ class SplitEventsManagerTest: XCTestCase {
         let eventManager: SplitEventsManager = DefaultSplitEventsManager(config: config)
         let timeOutTask = sdkTask(exp: sdkTiemoutExp)
         let updatedTask = sdkTask(exp: sdkTiemoutExp)
-        eventManager.register(event: .sdkUpdated, task: updatedTask)
-        eventManager.register(event: .sdkReadyTimedOut, task: timeOutTask)
+        eventManager.register(event: SplitEvent(type: .sdkUpdated), task: updatedTask)
+        eventManager.register(event: SplitEvent(type: .sdkReadyTimedOut), task: timeOutTask)
         eventManager.start()
 
-        eventManager.notifyInternalEvent(SplitInternalEvent.mySegmentsUpdated)
-        eventManager.notifyInternalEvent(SplitInternalEvent.splitKilledNotification)
+        eventManager.notifyInternalEvent(SplitInternalEvent(.mySegmentsUpdated))
+        eventManager.notifyInternalEvent(SplitInternalEvent(.splitKilledNotification))
 
         wait(for: [sdkTiemoutExp], timeout: timeout)
 
         XCTAssertFalse(updatedTask.taskTriggered);
-        XCTAssertFalse(eventManager.eventAlreadyTriggered(event: SplitEvent.sdkReady));
+        XCTAssertFalse(eventManager.eventAlreadyTriggered(event: .sdkReady));
         XCTAssertTrue(timeOutTask.taskTriggered);
-        XCTAssertTrue(eventManager.eventAlreadyTriggered(event: SplitEvent.sdkReadyTimedOut));
+        XCTAssertTrue(eventManager.eventAlreadyTriggered(event: .sdkReadyTimedOut));
 
         eventManager.stop()
     }
@@ -273,27 +273,19 @@ class SplitEventsManagerTest: XCTestCase {
     }
 }
 
-class TestTask: SplitEventTask {
-
-    var event: SplitEvent = .sdkReady
-
-    var runInBackground: Bool = false
-
-    var queue: DispatchQueue?
-    
+class TestTask: SplitEventActionTask {
     var taskTriggered = false
     let label: String
     var exp: XCTestExpectation?
+    var metadata: SplitMetadata?
+    
     init(exp: XCTestExpectation?, label: String = "") {
         self.exp = exp
         self.label = label
+        super.init(action: {}, event: .sdkReady, runInBackground: false, factory: SplitFactoryStub(apiKey: IntegrationHelper.dummyApiKey))
     }
 
-    func takeQueue() -> DispatchQueue? {
-        return nil
-    }
-
-    func run() {
+    override func run(_ metadata : SplitMetadata?) {
         print("run: \(self.label)")
         taskTriggered = true
         if let exp = self.exp {
diff --git a/SplitTests/Storage/DbForTwoDifferentApiKeyTest.swift b/SplitTests/Storage/DbForTwoDifferentApiKeyTest.swift
index c079b5856..54b1610a3 100644
--- a/SplitTests/Storage/DbForTwoDifferentApiKeyTest.swift
+++ b/SplitTests/Storage/DbForTwoDifferentApiKeyTest.swift
@@ -70,11 +70,11 @@ class DbForDifferentApiKeysTest: XCTestCase {
 
         let sdkReadyExpectation1 = XCTestExpectation(description: "SDK READY Expectation")
 
-        client1.on(event: SplitEvent.sdkReady) {
+        client1.on(event: .sdkReady) {
             sdkReadyExpectation1.fulfill()
         }
 
-        client1.on(event: SplitEvent.sdkReadyTimedOut) {
+        client1.on(event: .sdkReadyTimedOut) {
             sdkReadyExpectation1.fulfill()
         }
 
@@ -103,11 +103,11 @@ class DbForDifferentApiKeysTest: XCTestCase {
 
         let sdkReadyExpectation2 = XCTestExpectation(description: "SDK READY Expectation")
 
-        client2.on(event: SplitEvent.sdkReady) {
+        client2.on(event: .sdkReady) {
             sdkReadyExpectation2.fulfill()
         }
 
-        client2.on(event: SplitEvent.sdkReadyTimedOut) {
+        client2.on(event: .sdkReadyTimedOut) {
             sdkReadyExpectation2.fulfill()
         }