diff --git a/README.md b/README.md
index f81b10c..efec110 100644
--- a/README.md
+++ b/README.md
@@ -9,7 +9,7 @@ A PDF of the working specification for Outlook rules files (.rwz) files can be f
 
 ```swift
 let data = Data(contentsOfFile: "<path-to-file>.rwz")!
-let file = try OutlookRulesFile(data: data)
+let file = try OutlookRules(data: data)
 print(file.rules.count)
 print(file.rules[0].name)
 print(file.rules[0].enabled)
diff --git a/Sources/OutlookRulesReader/OutlookRulesFile.swift b/Sources/OutlookRulesReader/OutlookRules.swift
similarity index 73%
rename from Sources/OutlookRulesReader/OutlookRulesFile.swift
rename to Sources/OutlookRulesReader/OutlookRules.swift
index 949ff55..43e9e24 100644
--- a/Sources/OutlookRulesReader/OutlookRulesFile.swift
+++ b/Sources/OutlookRulesReader/OutlookRules.swift
@@ -1,5 +1,5 @@
 //
-//  OutlookRulesFile.swift
+//  OutlookRules.swift
 //
 //
 //  Created by Hugh Bellamy on 28/07/2020.
@@ -8,8 +8,9 @@
 import DataStream
 import Foundation
 
-public struct OutlookRulesFile: CustomDebugStringConvertible {
-    public var rules: [Rule] = []
+public struct OutlookRules: CustomDebugStringConvertible {
+    public let rules: [Rule]
+    private var header: RulesHeader
     private var footer: RulesFooter?
     public var templateDirectory: String {
         get {
@@ -21,6 +22,7 @@ public struct OutlookRulesFile: CustomDebugStringConvertible {
     
     public init(rules: [Rule] = []) {
         self.rules = rules
+        self.header = RulesHeader(numberOfRules: 0)
         self.footer = RulesFooter()
     }
     
@@ -30,7 +32,7 @@ public struct OutlookRulesFile: CustomDebugStringConvertible {
     }
     
     public init(dataStream: inout DataStream) throws {
-        let header = try RulesHeader(dataStream: &dataStream)
+        self.header = try RulesHeader(dataStream: &dataStream)
         
         var rules: [Rule] = []
         rules.reserveCapacity(Int(header.numberOfRules))
@@ -48,18 +50,20 @@ public struct OutlookRulesFile: CustomDebugStringConvertible {
         }
     }
     
-    public func getData() -> Data {
+    public func getData(version: OutlookRulesVersion? = nil) -> Data {
+        let version = version ?? self.header.version
+        
         var dataStream = OutputDataStream()
         
         let header = RulesHeader(numberOfRules: UInt16(rules.count))
-        header.write(to: &dataStream)
+        header.write(to: &dataStream, version: version)
         
         for (index, rule) in rules.enumerated() {
-            rule.write(to: &dataStream, index: index)
+            rule.write(to: &dataStream, index: index, version: version)
         }
         
         let footer = RulesFooter()
-        footer.write(to: &dataStream)
+        footer.write(to: &dataStream, version: version)
         
         return dataStream.data
     }
diff --git a/Sources/OutlookRulesReader/OutlookRulesReadError.swift b/Sources/OutlookRulesReader/OutlookRulesReadError.swift
index 63cc94b..5a6928c 100644
--- a/Sources/OutlookRulesReader/OutlookRulesReadError.swift
+++ b/Sources/OutlookRulesReader/OutlookRulesReadError.swift
@@ -1,5 +1,5 @@
 //
-//  OutlookRulesFileError.swift
+//  OutlookRulesError.swift
 //  
 //
 //  Created by Hugh Bellamy on 28/07/2020.
diff --git a/Sources/OutlookRulesReader/Rule.swift b/Sources/OutlookRulesReader/Rule.swift
index ddc5003..ccc582b 100644
--- a/Sources/OutlookRulesReader/Rule.swift
+++ b/Sources/OutlookRulesReader/Rule.swift
@@ -10,265 +10,45 @@ import DataStream
 public struct Rule: CustomDebugStringConvertible {
     public var name: String
     public var enabled: Bool
-    public var applyCondition: ApplyConditionFlags!
+    public var eventFlags: RuleEventFlags
     
-    public var conditions: [RuleElement] = []
-    public var actions: [RuleElement] = []
-    public var exceptions: [RuleElement] = []
+    public var elements: [RuleElement] = []
+    
+    public var conditions: [RuleElement] {
+        elements.filter { $0.identifier.rawValue >= 200 && $0.identifier.rawValue < 300 }
+    }
+    public var actions: [RuleElement] {
+        elements.filter { $0.identifier.rawValue >= 300 && $0.identifier.rawValue < 400 }
+    }
+    public var exceptions: [RuleElement] {
+        elements.filter { $0.identifier.rawValue >= 500 && $0.identifier.rawValue < 600 }
+    }
 
     public init(
-        applyCondition: ApplyConditionFlags,
+        eventFlags: RuleEventFlags,
         name: String,
         enabled: Bool = true,
         conditions: [RuleElement] = [],
         actions: [RuleElement] = [],
         exceptions: [RuleElement] = []
     ) {
-        self.applyCondition = applyCondition
+        self.eventFlags = eventFlags
         self.name = name
         self.enabled = enabled
-        self.conditions = conditions
-        self.actions = actions
-        self.exceptions = exceptions
+        self.elements = conditions + actions + exceptions
     }
     
     public init(dataStream: inout DataStream, index: Int, version: OutlookRulesVersion) throws {
+        /// Header (n bytes)
         let header = try RuleHeader(dataStream: &dataStream, index: index, version: version)
         self.name = header.name
         self.enabled = header.enabled
         
+        /// Elements (variable)
+        var elements: [RuleElement] = []
+        elements.reserveCapacity(Int(header.numberOfElements))
         for i in 0..<header.numberOfElements {
-            /// Identifier (4 bytes)
-            let rawIdentifier: UInt32 = try dataStream.read(endianess: .littleEndian)
-            guard let identifier = RuleElementIdentifier(rawValue: rawIdentifier) else {
-                fatalError("Unknown identifier \(rawIdentifier.hexString)")
-            }
-            
-            /// Data (variable)
-            func addCondition<T>(type: T.Type) throws where T: RuleElementData {
-                let data = try T(dataStream: &dataStream, version: version)
-                conditions.append(RuleElement(identifier: identifier, data: data))
-            }
-            
-            func addAction<T>(type: T.Type) throws where T: RuleElementData {
-                let data = try T(dataStream: &dataStream, version: version)
-                actions.append(RuleElement(identifier: identifier, data: data))
-            }
-            
-            func addException<T>(type: T.Type) throws where T: RuleElementData {
-                let data = try T(dataStream: &dataStream, version: version)
-                exceptions.append(RuleElement(identifier: identifier, data: data))
-            }
-
-            switch identifier {
-            /// Mandatory Elements
-            case .applyCondition: // 0x0190
-                applyCondition = try ApplyConditionRuleElementData(dataStream: &dataStream, version: version).flags
-            case .unknown0x64: // 0x0064
-                let _ = try RuleElement0x64Data(dataStream: &dataStream, version: version)
-                
-            /// Conditions
-            case .nameInToBoxCondition: // 0x000C8
-                try addCondition(type: SimpleRuleElementData.self)
-            case .sentOnlyToMeCondition: // 0x000C9
-                try addCondition(type: SimpleRuleElementData.self)
-            case .nameNotInToBoxCondition: // 0x00CA
-                try addCondition(type: SimpleRuleElementData.self)
-            case .fromCondition: // 0x00CB
-                try addCondition(type: PeopleOrPublicGroupListRuleElementData.self)
-            case .sentToCondition: // 0x00CC
-                try addCondition(type: PeopleOrPublicGroupListRuleElementData.self)
-            case .specificWordsInSubjectCondition: // 0x00CD
-                try addCondition(type: StringsListRuleElementData.self)
-            case .specificWordsInBodyCondition: // 0x00CE
-                try addCondition(type: StringsListRuleElementData.self)
-            case .specificWordsInSubjectOrBodyCondition: // 0x00CF
-                try addCondition(type: StringsListRuleElementData.self)
-            case .flaggedForActionCondition: // 0x00D0
-                try addCondition(type: FlaggedForActionRuleElementData.self)
-            case .importanceCondition: // 0x00D2
-                try addCondition(type: ImportanceRuleElementData.self)
-            case .sensitivityCondition: // 0x00D3
-                try addCondition(type: SensitivityRuleElementData.self)
-            case .assignedToCategoryCondition: // 0x00D7
-                try addCondition(type: CategoriesListRuleElementData.self)
-            case .automaticReplyCondition: // 0x00DC
-                try addCondition(type: SimpleRuleElementData.self)
-            case .hasAttachmentCondition: // 0x00DE
-                try addCondition(type: SimpleRuleElementData.self)
-            case .withSelectedPropertiesOfDocumentOrFormsCondition: // 0x00DF
-                try addCondition(type: WithSelectedPropertiesOfDocumentOrFormsRuleElementData.self)
-            case .sizeInSpecificRangeCondition: // 0x00E0
-                try addCondition(type: SizeInSpecificRangeRuleElementData.self)
-            case .receivedInSpecificDateSpanCondition: // 0x00E1
-                try addCondition(type: ReceivedInSpecificDateSpanRuleElementData.self)
-            case .nameInCcBoxCondition: // 0x00E2
-                try addCondition(type: SimpleRuleElementData.self)
-            case .nameInToOrCcBoxCondition: // 0x00E3
-                try addCondition(type: SimpleRuleElementData.self)
-            case .usesFormCondition: // 0x00E4
-                try addCondition(type: FormTypeRuleElementData.self)
-            case .specificWordsInRecipientsAddressCondition: // 0x00E5
-                try addCondition(type: StringsListRuleElementData.self)
-            case .specificWordsInSendersAddressCondition: // 0x00E6
-                try addCondition(type: StringsListRuleElementData.self)
-            case .specificWordsInMessageHeaderCondition: // 0x00E8
-                try addCondition(type: StringsListRuleElementData.self)
-            case .exceptionListCondition: // 0x00E9
-                try addCondition(type: SendersListRuleElementData.self)
-            case .junkCondition: // 0x00EB
-                try addCondition(type: SendersListRuleElementData.self)
-            case .adultCondition: // 0x00EC
-                try addCondition(type: SendersListRuleElementData.self)
-            case .relevanceInSpecificRangeCondition: // 0x00ED
-                try addCondition(type: RelevanceInSpecificRangeRuleElementData.self)
-            case .throughSpecifiedAccountCondition: // 0x00EE
-                try addCondition(type: ThroughAccountRuleElementData.self)
-            case .onThisComputerOnlyCondition: // 0x00EF
-                try addCondition(type: OnThisComputerOnlyRuleElementData.self)
-            case .senderInSpecifiedAddressBookCondition: // 0x00F0
-                try addCondition(type: SenderInSpecifiedAddressBookRuleElementData.self)
-            case .whichIsAMeetingInvitationOrInviteCondition: // 0x00F1
-                try addCondition(type: SimpleRuleElementData.self)
-            case .alertCondition: // 0x00F3
-                try addCondition(type: AlertRuleElementData.self)
-            case .specificInfoPathFormCondition: // 0x00F4
-                try addCondition(type: FormTypeRuleElementData.self)
-            case .fromRSSFeedsWithSpecifiedTextInTitleCondition: // 0x00F5
-                try addCondition(type: StringsListRuleElementData.self)
-            case .assignedToAnyCategoryCondition: // 0x00F6
-                try addCondition(type: SimpleRuleElementData.self)
-            case .fromAnyRSSFeedCondition: // 0x00F7
-                try addCondition(type: SimpleRuleElementData.self)
-                
-            /// Actions
-            case .forwardAction: // 0x012B
-                try addAction(type: PeopleOrPublicGroupListRuleElementData.self)
-            case .moveToFolderAction: // 0x012C
-                try addAction(type: MoveToFolderRuleElementData.self)
-            case .deleteAction: // 0x012D
-                try addAction(type: SimpleRuleElementData.self)
-            case .replyUsingTemplateAction: // 0x012F
-                try addAction(type: PathRuleElementData.self)
-            case .displayMessageInNewItemAlertWindowAction: // 0x0130
-                try addAction(type: DisplayMessageInNewItemAlertWindowRuleElementData.self)
-            case .flagAction: // 0x0131
-                try addAction(type: FlagRuleElementData.self)
-            case .clearFlagAction: // 0x0132
-                try addAction(type: SimpleRuleElementData.self)
-            case .assignToCategoryAction: // 0x0133
-                try addAction(type: CategoriesListRuleElementData.self)
-            case .playSoundAction: // 0x0136
-                try addAction(type: PathRuleElementData.self)
-            case .markImportanceAction: // 0x0137
-                try addAction(type: ImportanceRuleElementData.self)
-            case .markSensitivityAction: // 0x0138
-                try addAction(type: SensitivityRuleElementData.self)
-            case .moveCopyToFolderAction: // 0x0139
-                try addAction(type: MoveToFolderRuleElementData.self)
-            case .notifyReadAction: // 0x013A
-                try addAction(type: SimpleRuleElementData.self)
-            case .notifyDeliveredAction: // 0x013B
-                try addAction(type: SimpleRuleElementData.self)
-            case .ccAction: // 0x013C
-                try addAction(type: PeopleOrPublicGroupListRuleElementData.self)
-            case .deferDeliveryAction: // 0x013E
-                try addAction(type: DeferDeliveryRuleElementData.self)
-            case .performCustomActionAction:
-                try addAction(type: PerformCustomActionRuleElementData.self)
-            case .stopProcessingMoreRulesAction: // 0x0142
-                try addAction(type: SimpleRuleElementData.self)
-            case .doNotSearchForCommercialOrAdultContentAction: // 0x0143
-                try addAction(type: SimpleRuleElementData.self)
-            case .redirectAction: // 0x0144
-                try addAction(type: PeopleOrPublicGroupListRuleElementData.self)
-            case .addToRelevanceAction: // 0x0145
-                try addAction(type: AddToRelevanceRuleElementData.self)
-            case .automaticReply: // 0x0146
-                try addAction(type: AutomaticReplyRuleElementData.self)
-            case .forwardAsAttachmentAction: // 0x0147
-                try addAction(type: PeopleOrPublicGroupListRuleElementData.self)
-            case .printAction: // 0x0148
-                try addAction(type: SimpleRuleElementData.self)
-            case .startApplicationAction: // 0x0149
-                try addAction(type: PathRuleElementData.self)
-            case .permanentlyDeleteAction: // 0x014A
-                try addAction(type: SimpleRuleElementData.self)
-            case .runScriptAction: // 0x014B
-                try addAction(type: RunScriptRuleElementData.self)
-            case .markAsReadAction: // 0x014C
-                try addAction(type: SimpleRuleElementData.self)
-            case .displayDesktopAlertAction: // 0x014F
-                try addAction(type: SimpleRuleElementData.self)
-            case .flagForFollowUpAction: // 0x0151
-                try addAction(type: FlagForFollowUpRuleElementData.self)
-            case .clearCategoriesAction: // 0x0152
-                try addAction(type: SimpleRuleElementData.self)
-            case .applyRetentionPolicyAction: // 0x0153
-                try addAction(type: ApplyRetentionPolicyRuleElementData.self)
-
-            /// Exceptions
-            case .nameInToBoxException: // 0x01F4
-                try addException(type: SimpleRuleElementData.self)
-            case .sentOnlyToMeException: // 0x01F5
-                try addException(type: SimpleRuleElementData.self)
-            case .nameNotInToBoxException: // 0x01F6
-                try addException(type: SimpleRuleElementData.self)
-            case .fromException: // 0x01F7
-                try addException(type: PeopleOrPublicGroupListRuleElementData.self)
-            case .toException: // 0x01F8
-                try addException(type: PeopleOrPublicGroupListRuleElementData.self)
-            case .specificWordsInSubjectException: // 0x01F9
-                try addException(type: StringsListRuleElementData.self)
-            case .specificWordsInBodyException: // 0x01FA
-                try addException(type: StringsListRuleElementData.self)
-            case .specificWordsInSubjectOrBodyException: // 0x01FB
-                try addException(type: StringsListRuleElementData.self)
-            case .flaggedForActionException: // 0x1FC
-                try addException(type: FlaggedForActionRuleElementData.self)
-            case .importanceException: // 0x01FE
-                try addException(type: ImportanceRuleElementData.self)
-            case .sensitivityConditionException: // 0x01FF
-                try addException(type: SensitivityRuleElementData.self)
-            case .assignedToCategoryException: // 0x0203
-                try addException(type: CategoriesListRuleElementData.self)
-            case .automaticReplyException: // 0x0208
-                try addException(type: SimpleRuleElementData.self)
-            case .hasAttachmentException: // 0x020A
-                try addException(type: SimpleRuleElementData.self)
-            case .withSelectedPropertiesOfDocumentOrFormsException: // 0x020B
-                try addException(type: WithSelectedPropertiesOfDocumentOrFormsRuleElementData.self)
-            case .sizeInSpecificRangeException: // 0x020C
-                try addException(type: SizeInSpecificRangeRuleElementData.self)
-            case .receivedInSpecificDateSpanException: // 0x020D
-                try addException(type: ReceivedInSpecificDateSpanRuleElementData.self)
-            case .nameInCcBoxException: // 0x020E
-                try addException(type: SimpleRuleElementData.self)
-            case .nameInToOrCcBoxException: // 0x020F
-                try addException(type: SimpleRuleElementData.self)
-            case .usesFormException: // 0x0210
-                try addException(type: FormTypeRuleElementData.self)
-            case .specificWordsInRecipientsAddressException: // 0x0211
-                try addException(type: StringsListRuleElementData.self)
-            case .specificWordsInSendersAddressException: // 0x0212
-                try addException(type: StringsListRuleElementData.self)
-            case .specificWordsInMessageHeaderException: // 0x0213
-                try addException(type: StringsListRuleElementData.self)
-            case .throughSpecifiedAccountException: // 0x0214
-                try addException(type: ThroughAccountRuleElementData.self)
-            case .senderInSpecifiedAddressBookException: // 0x0215
-                try addException(type: SenderInSpecifiedAddressBookRuleElementData.self)
-            case .whichIsAMeetingInvitationOrInviteException: // 0x0216
-                try addException(type: SimpleRuleElementData.self)
-            case .specificInfoPathFormException: // 0x0218
-                try addException(type: FormTypeRuleElementData.self)
-            case .fromRSSFeedsWithSpecifiedTextInTitleException: // 0x0219
-                try addException(type: StringsListRuleElementData.self)
-            case .assignedToAnyCategoryException: // 0x021A
-                try addException(type: SimpleRuleElementData.self)
-            case .fromAnyRSSFeedException: // 0x021B
-                try addException(type: SimpleRuleElementData.self)
-            }
+            elements.append(try RuleElement(dataStream: &dataStream, version: version))
 
             /// Separator (2 bytes)
             if i != header.numberOfElements - 1 {
@@ -278,6 +58,15 @@ public struct Rule: CustomDebugStringConvertible {
                 }
             }
         }
+        
+        self.elements = elements
+        
+        guard let eventElement = elements.first(where: { $0.identifier == .eventFlags }),
+              let eventParameter = eventElement.parameter as? EventParameter else {
+            throw OutlookRulesReadError.corrupted
+        }
+        
+        self.eventFlags = eventParameter.flags
     }
 
     public var debugDescription: String {
@@ -286,23 +75,24 @@ public struct Rule: CustomDebugStringConvertible {
         return s
     }
     
-    public func write(to dataStream: inout OutputDataStream, index: Int) {
+    public func write(to dataStream: inout OutputDataStream, index: Int, version: OutlookRulesVersion) {
         var elements: [RuleElement] = [
             // First element is rule condition
-            RuleElement(identifier: .applyCondition, data: ApplyConditionRuleElementData(flags: self.applyCondition)),
+            RuleElement(identifier: .eventFlags, parameter: EventParameter(flags: self.eventFlags)),
 
             // Second element is unknown (0x0064).
-            RuleElement(identifier: .unknown0x64, data: RuleElement0x64Data())
+            RuleElement(identifier: .unknown0x64, parameter: Unknown0x64Parameter())
         ]
         elements.append(contentsOf: conditions)
         elements.append(contentsOf: actions)
-        
+        elements.append(contentsOf: exceptions)
+
         let numberOfElements = UInt16(elements.count)
         let separatorDataSize = UInt32(2 * (elements.count - 1))
         
         /// Number of Rule Elements (2 bytes)
         /// Separator (2 bytes)
-        /// Magic (2 bytes)
+        /// Padding (2 bytes)
         /// Class Name Length (2 bytes)
         /// Class Name (12 bytes - CRuleElement)
         let remainingLength: UInt32 = 2 + 2 + 2 + 2 + 12
@@ -312,8 +102,8 @@ public struct Rule: CustomDebugStringConvertible {
         header.write(to: &dataStream, index: index)
 
         for (i, element) in elements.enumerated() {
-            // Element (variable)
-            element.write(to: &dataStream)
+            /// Element (variable)
+            element.write(to: &dataStream, version: version)
             
             if i != elements.count - 1 {
                 /// Separator (2 bytes)
diff --git a/Sources/OutlookRulesReader/RuleElement.swift b/Sources/OutlookRulesReader/RuleElement.swift
index 34c1db1..e1e2125 100644
--- a/Sources/OutlookRulesReader/RuleElement.swift
+++ b/Sources/OutlookRulesReader/RuleElement.swift
@@ -1,6 +1,6 @@
 //
 //  RuleElement.swift
-//  
+//
 //
 //  Created by Hugh Bellamy on 11/08/2020.
 //
@@ -9,25 +9,271 @@ import DataStream
 
 public struct RuleElement {
     public var dataSize: UInt32 {
-        return 4 + data.dataSize
+        8 + parameters.reduce(0, { $0 + $1.dataSize })
     }
     
     public var identifier: RuleElementIdentifier
-    public var data: RuleElementData
+    public var parameters: [RuleParameter]
+    
+    public var parameter: RuleParameter? {
+        parameters.first
+    }
+
+    public init(identifier: RuleElementIdentifier, parameter: RuleParameter) {
+        self.init(identifier: identifier, parameters: [parameter])
+    }
     
-    public init(identifier: RuleElementIdentifier, data: RuleElementData) {
+    public init(identifier: RuleElementIdentifier, parameters: [RuleParameter] = []) {
         /// Identifier (4 bytes)
         self.identifier = identifier
         
-        /// Data (variable)
-        self.data = data
+        /// Parameters (variable)
+        self.parameters = parameters
+    }
+    
+    public init(dataStream: inout DataStream, version: OutlookRulesVersion) throws {
+        /// Identifier (4 bytes)
+        let identifierRaw: UInt32 = try dataStream.read(endianess: .littleEndian)
+        guard let identifier = RuleElementIdentifier(rawValue: identifierRaw) else {
+            throw OutlookRulesReadError.corrupted
+        }
+        
+        self.identifier = identifier
+        
+        /// Number of Parameters (4 bytes)
+        let numberOfParameters: UInt32 = try dataStream.read(endianess: .littleEndian)
+        
+        /// Parameters (variable)
+        var parameters: [RuleParameter] = []
+        parameters.reserveCapacity(Int(numberOfParameters))
+        for _ in 0..<numberOfParameters {
+            let parameter: RuleParameter
+            switch identifier {
+                /// Mandatory Elements
+                case .eventFlags: // 0x0190
+                    parameter = try EventParameter(dataStream: &dataStream, version: version)
+                case .unknown0x64: // 0x0064
+                    parameter = try Unknown0x64Parameter(dataStream: &dataStream, version: version)
+                    
+                /// Conditions
+                case .nameInToBoxCondition: // 0x000C8
+                    continue
+                case .sentOnlyToMeCondition: // 0x000C9
+                    continue
+                case .nameNotInToBoxCondition: // 0x00CA
+                    continue
+                case .fromCondition: // 0x00CB
+                    parameter = try AddressParameter(dataStream: &dataStream, version: version)
+                case .sentToCondition: // 0x00CC
+                    parameter = try AddressParameter(dataStream: &dataStream, version: version)
+                case .specificWordsInSubjectCondition: // 0x00CD
+                    parameter = try StringParameter(dataStream: &dataStream, version: version)
+                case .specificWordsInBodyCondition: // 0x00CE
+                    parameter = try StringParameter(dataStream: &dataStream, version: version)
+                case .specificWordsInSubjectOrBodyCondition: // 0x00CF
+                    parameter = try StringParameter(dataStream: &dataStream, version: version)
+                case .flaggedForActionCondition: // 0x00D0
+                    parameter = try FlaggedForActionParameter(dataStream: &dataStream, version: version)
+                case .importanceCondition: // 0x00D2
+                    parameter = try ImportanceParameter(dataStream: &dataStream, version: version)
+                case .sensitivityCondition: // 0x00D3
+                    parameter = try SensitivityParameter(dataStream: &dataStream, version: version)
+                case .assignedToCategoryCondition: // 0x00D7
+                    parameter = try CategoryParameter(dataStream: &dataStream, version: version)
+                case .automaticReplyCondition: // 0x00DC
+                    continue
+                case .hasAttachmentCondition: // 0x00DE
+                    continue
+                case .withSelectedPropertiesOfDocumentOrFormsCondition: // 0x00DF
+                    parameter = try FormParameter(dataStream: &dataStream, version: version)
+                case .sizeInSpecificRangeCondition: // 0x00E0
+                    parameter = try SizeParameter(dataStream: &dataStream, version: version)
+                case .receivedInSpecificDateSpanCondition: // 0x00E1
+                    parameter = try TimeParameter(dataStream: &dataStream, version: version)
+                case .nameInCcBoxCondition: // 0x00E2
+                    continue
+                case .nameInToOrCcBoxCondition: // 0x00E3
+                    continue
+                case .usesFormCondition: // 0x00E4
+                    parameter = try FormTypeParameter(dataStream: &dataStream, version: version)
+                case .specificWordsInRecipientsAddressCondition: // 0x00E5
+                    parameter = try StringParameter(dataStream: &dataStream, version: version)
+                case .specificWordsInSendersAddressCondition: // 0x00E6
+                    parameter = try StringParameter(dataStream: &dataStream, version: version)
+                case .specificWordsInMessageHeaderCondition: // 0x00E8
+                    parameter = try StringParameter(dataStream: &dataStream, version: version)
+                case .exceptionListCondition: // 0x00E9
+                    parameter = try SendersListParameter(dataStream: &dataStream, version: version)
+                case .junkCondition: // 0x00EB
+                    parameter = try SendersListParameter(dataStream: &dataStream, version: version)
+                case .adultCondition: // 0x00EC
+                    parameter = try SendersListParameter(dataStream: &dataStream, version: version)
+                case .relevanceInSpecificRangeCondition: // 0x00ED
+                    parameter = try RelevanceRangeParameter(dataStream: &dataStream, version: version)
+                case .throughSpecifiedAccountCondition: // 0x00EE
+                    parameter = try AccountParameter(dataStream: &dataStream, version: version)
+                case .onThisComputerOnlyCondition: // 0x00EF
+                    parameter = try ProfileStampParameter(dataStream: &dataStream, version: version)
+                case .senderInSpecifiedAddressBookCondition: // 0x00F0
+                    parameter = try AddressBookParameter(dataStream: &dataStream, version: version)
+                case .whichIsAMeetingInvitationOrInviteCondition: // 0x00F1
+                    continue
+                case .alertCondition: // 0x00F3
+                    parameter = try AlertParameter(dataStream: &dataStream, version: version)
+                case .specificInfoPathFormCondition: // 0x00F4
+                    parameter = try FormTypeParameter(dataStream: &dataStream, version: version)
+                case .fromRSSFeedsWithSpecifiedTextInTitleCondition: // 0x00F5
+                    parameter = try StringParameter(dataStream: &dataStream, version: version)
+                case .assignedToAnyCategoryCondition: // 0x00F6
+                    continue
+                case .fromAnyRSSFeedCondition: // 0x00F7
+                    continue
+                    
+                /// Actions
+                case .forwardAction: // 0x012B
+                    parameter = try AddressParameter(dataStream: &dataStream, version: version)
+                case .moveToFolderAction: // 0x012C
+                    parameter = try FolderParameter(dataStream: &dataStream, version: version)
+                case .deleteAction: // 0x012D
+                    continue
+                case .replyUsingTemplateAction: // 0x012F
+                    parameter = try PathParameter(dataStream: &dataStream, version: version)
+                case .displayMessageInNewItemAlertWindowAction: // 0x0130
+                    parameter = try MessageParameter(dataStream: &dataStream, version: version)
+                case .flagAction: // 0x0131
+                    parameter = try FlagRuleElementData(dataStream: &dataStream, version: version)
+                case .clearFlagAction: // 0x0132
+                    continue
+                case .assignToCategoryAction: // 0x0133
+                    parameter = try CategoryParameter(dataStream: &dataStream, version: version)
+                case .playSoundAction: // 0x0136
+                    parameter = try PathParameter(dataStream: &dataStream, version: version)
+                case .markImportanceAction: // 0x0137
+                    parameter = try ImportanceParameter(dataStream: &dataStream, version: version)
+                case .markSensitivityAction: // 0x0138
+                    parameter = try SensitivityParameter(dataStream: &dataStream, version: version)
+                case .moveCopyToFolderAction: // 0x0139
+                    parameter = try FolderParameter(dataStream: &dataStream, version: version)
+                case .notifyReadAction: // 0x013A
+                    continue
+                case .notifyDeliveredAction: // 0x013B
+                    continue
+                case .ccAction: // 0x013C
+                    parameter = try AddressParameter(dataStream: &dataStream, version: version)
+                case .deferDeliveryAction: // 0x013E
+                    parameter = try DeferParameter(dataStream: &dataStream, version: version)
+                case .performCustomActionAction:
+                    parameter = try CustomActionParameter(dataStream: &dataStream, version: version)
+                case .stopProcessingMoreRulesAction: // 0x0142
+                    continue
+                case .doNotSearchForCommercialOrAdultContentAction: // 0x0143
+                    continue
+                case .redirectAction: // 0x0144
+                    parameter = try AddressParameter(dataStream: &dataStream, version: version)
+                case .addToRelevanceAction: // 0x0145
+                    parameter = try RelevanceParameter(dataStream: &dataStream, version: version)
+                case .automaticReply: // 0x0146
+                    parameter = try TemplateParameter(dataStream: &dataStream, version: version)
+                case .forwardAsAttachmentAction: // 0x0147
+                    parameter = try AddressParameter(dataStream: &dataStream, version: version)
+                case .printAction: // 0x0148
+                    continue
+                case .startApplicationAction: // 0x0149
+                    parameter = try PathParameter(dataStream: &dataStream, version: version)
+                case .permanentlyDeleteAction: // 0x014A
+                    continue
+                case .runScriptAction: // 0x014B
+                    parameter = try ScriptParameter(dataStream: &dataStream, version: version)
+                case .markAsReadAction: // 0x014C
+                    continue
+                case .displayDesktopAlertAction: // 0x014F
+                    continue
+                case .flagForFollowUpAction: // 0x0151
+                    parameter = try FlagForFollowUpParameter(dataStream: &dataStream, version: version)
+                case .clearCategoriesAction: // 0x0152
+                    continue
+                case .applyRetentionPolicyAction: // 0x0153
+                    parameter = try RetentionPolicyParameter(dataStream: &dataStream, version: version)
+
+                /// Exceptions
+                case .nameInToBoxException: // 0x01F4
+                    continue
+                case .sentOnlyToMeException: // 0x01F5
+                    continue
+                case .nameNotInToBoxException: // 0x01F6
+                    continue
+                case .fromException: // 0x01F7
+                    parameter = try AddressParameter(dataStream: &dataStream, version: version)
+                case .toException: // 0x01F8
+                    parameter = try AddressParameter(dataStream: &dataStream, version: version)
+                case .specificWordsInSubjectException: // 0x01F9
+                    parameter = try StringParameter(dataStream: &dataStream, version: version)
+                case .specificWordsInBodyException: // 0x01FA
+                    parameter = try StringParameter(dataStream: &dataStream, version: version)
+                case .specificWordsInSubjectOrBodyException: // 0x01FB
+                    parameter = try StringParameter(dataStream: &dataStream, version: version)
+                case .flaggedForActionException: // 0x1FC
+                    parameter = try FlaggedForActionParameter(dataStream: &dataStream, version: version)
+                case .importanceException: // 0x01FE
+                    parameter = try ImportanceParameter(dataStream: &dataStream, version: version)
+                case .sensitivityConditionException: // 0x01FF
+                    parameter = try SensitivityParameter(dataStream: &dataStream, version: version)
+                case .assignedToCategoryException: // 0x0203
+                    parameter = try CategoryParameter(dataStream: &dataStream, version: version)
+                case .automaticReplyException: // 0x0208
+                    continue
+                case .hasAttachmentException: // 0x020A
+                    continue
+                case .withSelectedPropertiesOfDocumentOrFormsException: // 0x020B
+                    parameter = try FormParameter(dataStream: &dataStream, version: version)
+                case .sizeInSpecificRangeException: // 0x020C
+                    parameter = try SizeParameter(dataStream: &dataStream, version: version)
+                case .receivedInSpecificDateSpanException: // 0x020D
+                    parameter = try TimeParameter(dataStream: &dataStream, version: version)
+                case .nameInCcBoxException: // 0x020E
+                    continue
+                case .nameInToOrCcBoxException: // 0x020F
+                    continue
+                case .usesFormException: // 0x0210
+                    parameter = try FormTypeParameter(dataStream: &dataStream, version: version)
+                case .specificWordsInRecipientsAddressException: // 0x0211
+                    parameter = try StringParameter(dataStream: &dataStream, version: version)
+                case .specificWordsInSendersAddressException: // 0x0212
+                    parameter = try StringParameter(dataStream: &dataStream, version: version)
+                case .specificWordsInMessageHeaderException: // 0x0213
+                    parameter = try StringParameter(dataStream: &dataStream, version: version)
+                case .throughSpecifiedAccountException: // 0x0214
+                    parameter = try AccountParameter(dataStream: &dataStream, version: version)
+                case .senderInSpecifiedAddressBookException: // 0x0215
+                    parameter = try AddressBookParameter(dataStream: &dataStream, version: version)
+                case .whichIsAMeetingInvitationOrInviteException: // 0x0216
+                    continue
+                case .specificInfoPathFormException: // 0x0218
+                    parameter = try FormTypeParameter(dataStream: &dataStream, version: version)
+                case .fromRSSFeedsWithSpecifiedTextInTitleException: // 0x0219
+                    parameter = try StringParameter(dataStream: &dataStream, version: version)
+                case .assignedToAnyCategoryException: // 0x021A
+                    continue
+                case .fromAnyRSSFeedException: // 0x021B
+                    continue
+            }
+            
+            parameters.append(parameter)
+        }
+        
+        self.parameters = parameters
     }
     
-    func write(to dataStream: inout OutputDataStream) {
+    func write(to dataStream: inout OutputDataStream, version: OutlookRulesVersion) {
         /// Identifier (4 bytes)
         dataStream.write(identifier.rawValue, endianess: .littleEndian)
         
+        /// Number of Parameters (4 bytes)
+        dataStream.write(UInt32(parameters.count), endianess: .littleEndian)
+        
         /// Data (variable)
-        data.write(to: &dataStream)
+        for parameter in parameters {
+            parameter.write(to: &dataStream, version: version)
+        }
     }
 }
diff --git a/Sources/OutlookRulesReader/RuleElementData.swift b/Sources/OutlookRulesReader/RuleElementData.swift
index 0c078da..25e2808 100644
--- a/Sources/OutlookRulesReader/RuleElementData.swift
+++ b/Sources/OutlookRulesReader/RuleElementData.swift
@@ -1,5 +1,5 @@
 //
-//  RuleElementData.swift
+//  RuleParameter.swift
 //
 //
 //  Created by Hugh Bellamy on 28/07/2020.
@@ -7,8 +7,8 @@
 
 import DataStream
 
-public protocol RuleElementData {
+public protocol RuleParameter {
     var dataSize: UInt32 { get }
     init(dataStream: inout DataStream, version: OutlookRulesVersion) throws
-    func write(to dataStream: inout OutputDataStream)
+    func write(to dataStream: inout OutputDataStream, version: OutlookRulesVersion)
 }
diff --git a/Sources/OutlookRulesReader/RuleElementIdentifier.swift b/Sources/OutlookRulesReader/RuleElementIdentifier.swift
index 9b06188..d88a8ac 100644
--- a/Sources/OutlookRulesReader/RuleElementIdentifier.swift
+++ b/Sources/OutlookRulesReader/RuleElementIdentifier.swift
@@ -7,7 +7,7 @@
 
 public enum RuleElementIdentifier: UInt32 {
     /// "type of messages to which this rule applies"
-    case applyCondition = 0x00000190
+    case eventFlags = 0x00000190
     
     /// Unknown
     case unknown0x64 = 0x00000064
diff --git a/Sources/OutlookRulesReader/RulesFooter.swift b/Sources/OutlookRulesReader/RulesFooter.swift
index ff519c8..da0e15a 100644
--- a/Sources/OutlookRulesReader/RulesFooter.swift
+++ b/Sources/OutlookRulesReader/RulesFooter.swift
@@ -50,7 +50,7 @@ internal struct RulesFooter {
         assert(dataStream.remainingCount == 0)
     }
     
-    public func write(to dataStream: inout OutputDataStream) {
+    public func write(to dataStream: inout OutputDataStream, version: OutlookRulesVersion) {
         /// Template Directory Length (4 bytes)
         dataStream.write(UInt32(templateDirectory.count), endianess: .littleEndian)
         
diff --git a/Sources/OutlookRulesReader/RulesHeader.swift b/Sources/OutlookRulesReader/RulesHeader.swift
index 9903036..b150248 100644
--- a/Sources/OutlookRulesReader/RulesHeader.swift
+++ b/Sources/OutlookRulesReader/RulesHeader.swift
@@ -157,7 +157,7 @@ internal struct RulesHeader {
         self.numberOfRules = try dataStream.read(endianess: .littleEndian)
     }
     
-    public func write(to dataStream: inout OutputDataStream) {
+    public func write(to dataStream: inout OutputDataStream, version: OutlookRulesVersion) {
         if let signature = signature {
             /// Signature (4 bytes)
             dataStream.write(signature, endianess: .littleEndian)
diff --git a/Sources/OutlookRulesReader/Structures/Objects/DocumentProperty.swift b/Sources/OutlookRulesReader/Structures/Objects/DocumentProperty.swift
index 13a047f..b393c4e 100644
--- a/Sources/OutlookRulesReader/Structures/Objects/DocumentProperty.swift
+++ b/Sources/OutlookRulesReader/Structures/Objects/DocumentProperty.swift
@@ -130,9 +130,13 @@ public struct DocumentProperty {
         self.unknown2 = try dataStream.read(endianess: .littleEndian)
     }
     
-    public func write(to dataStream: inout OutputDataStream) {
+    public func write(to dataStream: inout OutputDataStream, version: OutlookRulesVersion) {
         /// Field (variable)
-        UTF16String(value: field).write(to: &dataStream)
+        if version >= .outlook2002 {
+            UTF16String(value: field).write(to: &dataStream)
+        } else {
+            ASCIIString(value: field).write(to: &dataStream)
+        }
 
         /// Tag (4 bytes)
         tag.write(to: &dataStream)
@@ -141,7 +145,11 @@ public struct DocumentProperty {
         dataStream.write(rawStringMatchType, endianess: .littleEndian)
 
         /// String Value (variable)
-        UTF16String(value: stringValue).write(to: &dataStream)
+        if version >= .outlook2002 {
+            UTF16String(value: stringValue).write(to: &dataStream)
+        } else {
+            ASCIIString(value: stringValue).write(to: &dataStream)
+        }
         
         /// Number Match Type (4 bytes)
         dataStream.write(rawNumberMatchType, endianess: .littleEndian)
diff --git a/Sources/OutlookRulesReader/Structures/Objects/DateWithTimestamp.swift b/Sources/OutlookRulesReader/Structures/Objects/OleDateTime.swift
similarity index 100%
rename from Sources/OutlookRulesReader/Structures/Objects/DateWithTimestamp.swift
rename to Sources/OutlookRulesReader/Structures/Objects/OleDateTime.swift
diff --git a/Sources/OutlookRulesReader/Structures/Rule Elements/ThroughAccountRuleElementData.swift b/Sources/OutlookRulesReader/Structures/Parameters/AccountParameter.swift
similarity index 69%
rename from Sources/OutlookRulesReader/Structures/Rule Elements/ThroughAccountRuleElementData.swift
rename to Sources/OutlookRulesReader/Structures/Parameters/AccountParameter.swift
index cf36328..8213800 100644
--- a/Sources/OutlookRulesReader/Structures/Rule Elements/ThroughAccountRuleElementData.swift	
+++ b/Sources/OutlookRulesReader/Structures/Parameters/AccountParameter.swift
@@ -1,5 +1,5 @@
 //
-//  ThroughAccountCondition.swift
+//  AccountParameter.swift
 //
 //
 //  Created by Hugh Bellamy on 29/07/2020.
@@ -7,15 +7,14 @@
 
 import DataStream
 
-public struct ThroughAccountRuleElementData: RuleElementData {
+public struct AccountParameter: RuleParameter {
     public var dataSize: UInt32 {
-        var baseSize: UInt32 = 8
+        var baseSize: UInt32 = 4
         baseSize += UTF16String(value: accountName).dataSize
         baseSize += ASCIIString(value: accountName).dataSize
         return baseSize
     }
 
-    public var extended: UInt32 = 1
     public var reserved: UInt32 = 0
     public var accountName: String
     public var unknown: String
@@ -26,12 +25,6 @@ public struct ThroughAccountRuleElementData: RuleElementData {
     }
     
     public init(dataStream: inout DataStream, version: OutlookRulesVersion) throws {
-        /// Extended (4 bytes)
-        self.extended = try dataStream.read(endianess: .littleEndian)
-        guard self.extended == 0x00000001 else {
-            throw OutlookRulesReadError.corrupted
-        }
-        
         /// Reserved (4 bytes)
         self.reserved = try dataStream.read(endianess: .littleEndian)
 
@@ -42,10 +35,7 @@ public struct ThroughAccountRuleElementData: RuleElementData {
         self.unknown = try ASCIIString(dataStream: &dataStream).value
     }
     
-    public func write(to dataStream: inout OutputDataStream) {
-        /// Extended (4 bytes)
-        dataStream.write(extended, endianess: .littleEndian)
-        
+    public func write(to dataStream: inout OutputDataStream, version: OutlookRulesVersion) {        
         /// Reserved (4 bytes)
         dataStream.write(reserved, endianess: .littleEndian)
         
diff --git a/Sources/OutlookRulesReader/Structures/Rule Elements/SenderInSpecifiedAddressBookRuleElementData.swift b/Sources/OutlookRulesReader/Structures/Parameters/AddressBookParameter.swift
similarity index 66%
rename from Sources/OutlookRulesReader/Structures/Rule Elements/SenderInSpecifiedAddressBookRuleElementData.swift
rename to Sources/OutlookRulesReader/Structures/Parameters/AddressBookParameter.swift
index 00c282c..2ef076d 100644
--- a/Sources/OutlookRulesReader/Structures/Rule Elements/SenderInSpecifiedAddressBookRuleElementData.swift	
+++ b/Sources/OutlookRulesReader/Structures/Parameters/AddressBookParameter.swift
@@ -1,5 +1,5 @@
 //
-//  SenderInSpecifiedAddressBookRuleElementData.swift
+//  AddressBookParameter.swift
 //
 //
 //  Created by Hugh Bellamy on 28/07/2020.
@@ -8,15 +8,14 @@
 import DataStream
 import MAPI
 
-public struct SenderInSpecifiedAddressBookRuleElementData: RuleElementData {
+public struct AddressBookParameter: RuleParameter {
     public var dataSize: UInt32 {
-        var baseSize: UInt32 = 12
+        var baseSize: UInt32 = 4
         baseSize += UInt32(FlatEntry(entryID: entryId).dataSize)
         baseSize += UTF16String(value: name).dataSize
         return baseSize
     }
 
-    public var extended: UInt32 = 1
     public var reserved: UInt32 = 0
     public var entryId: EntryID
     public var name: String
@@ -27,12 +26,6 @@ public struct SenderInSpecifiedAddressBookRuleElementData: RuleElementData {
     }
 
     public init(dataStream: inout DataStream, version: OutlookRulesVersion) throws {
-        /// Extended (4 bytes)
-        self.extended = try dataStream.read(endianess: .littleEndian)
-        guard self.extended == 0x00000001 else {
-            throw OutlookRulesReadError.corrupted
-        }
-        
         /// Reserved (4 bytes)
         self.reserved = try dataStream.read(endianess: .littleEndian)
         
@@ -43,10 +36,7 @@ public struct SenderInSpecifiedAddressBookRuleElementData: RuleElementData {
         self.name = try UTF16String(dataStream: &dataStream).value
     }
     
-    public func write(to dataStream: inout OutputDataStream) {
-        /// Extended (4 bytes)
-        dataStream.write(extended, endianess: .littleEndian)
-        
+    public func write(to dataStream: inout OutputDataStream, version: OutlookRulesVersion) {
         /// Reserved (4 bytes)
         dataStream.write(reserved, endianess: .littleEndian)
         
diff --git a/Sources/OutlookRulesReader/Structures/Rule Elements/PeopleOrPublicGroupListRuleElementData.swift b/Sources/OutlookRulesReader/Structures/Parameters/AddressParameter.swift
similarity index 61%
rename from Sources/OutlookRulesReader/Structures/Rule Elements/PeopleOrPublicGroupListRuleElementData.swift
rename to Sources/OutlookRulesReader/Structures/Parameters/AddressParameter.swift
index bb0d1ff..dc866a6 100644
--- a/Sources/OutlookRulesReader/Structures/Rule Elements/PeopleOrPublicGroupListRuleElementData.swift	
+++ b/Sources/OutlookRulesReader/Structures/Parameters/AddressParameter.swift
@@ -1,5 +1,5 @@
 //
-//  PeopleOrPublicGroupList.swift
+//  AddressParameter.swift
 //  
 //
 //  Created by Hugh Bellamy on 08/08/2020.
@@ -7,44 +7,35 @@
 
 import DataStream
 
-public struct PeopleOrPublicGroupListRuleElementData: RuleElementData {
+public struct AddressParameter: RuleParameter {
     public var dataSize: UInt32 {
-        let result: UInt32 = 20
+        let result: UInt32 = 16
         for _ in values {
             // TODO
         }
         return result
     }
 
-    public var extended: UInt32 = 1
     public var reserved: UInt32 = 0
-    public var numberOfValues: UInt32 = 0
     public var values: [[UInt16 : Any]] = []
     public var unknown1: UInt32 = 1
     public var unknown2: UInt32 = 0
 
     public init(values: [[UInt16: Any]]) {
-        self.numberOfValues = UInt32(values.count)
         self.values = values
     }
 
     public init(dataStream: inout DataStream, version: OutlookRulesVersion) throws {
-        /// Extended (4 bytes)
-        self.extended = try dataStream.read(endianess: .littleEndian)
-        guard self.extended == 0x00000001 else {
-            throw OutlookRulesReadError.corrupted
-        }
-        
         /// Reserved (4 bytes)
         self.reserved = try dataStream.read(endianess: .littleEndian)
         
         /// Number of Values (4 bytes)
-        self.numberOfValues = try dataStream.read(endianess: .littleEndian)
+        let numberOfValues: UInt32 = try dataStream.read(endianess: .littleEndian)
         
         /// Values (variable)
         var values: [[UInt16 : Any]] = []
-        values.reserveCapacity(Int(self.numberOfValues))
-        for _ in 0..<self.numberOfValues {
+        values.reserveCapacity(Int(numberOfValues))
+        for _ in 0..<numberOfValues {
             let list = try PropertiesList(dataStream: &dataStream)
             values.append(list.properties)
         }
@@ -58,7 +49,7 @@ public struct PeopleOrPublicGroupListRuleElementData: RuleElementData {
         self.unknown2 = try dataStream.read(endianess: .littleEndian)
     }
 
-    public func write(to dataStream: inout OutputDataStream) {
+    public func write(to dataStream: inout OutputDataStream, version: OutlookRulesVersion) {
         // TODO
     }
 }
diff --git a/Sources/OutlookRulesReader/Structures/Rule Elements/AlertRuleElementData.swift b/Sources/OutlookRulesReader/Structures/Parameters/AlertParameter.swift
similarity index 57%
rename from Sources/OutlookRulesReader/Structures/Rule Elements/AlertRuleElementData.swift
rename to Sources/OutlookRulesReader/Structures/Parameters/AlertParameter.swift
index 674076e..7da78e7 100644
--- a/Sources/OutlookRulesReader/Structures/Rule Elements/AlertRuleElementData.swift	
+++ b/Sources/OutlookRulesReader/Structures/Parameters/AlertParameter.swift
@@ -1,5 +1,5 @@
 //
-//  AlertRuleElementData.swift
+//  AlertParameter.swift
 //
 //
 //  Created by Hugh Bellamy on 08/08/2020.
@@ -7,12 +7,11 @@
 
 import DataStream
 
-public struct AlertRuleElementData: RuleElementData {
+public struct AlertParameter: RuleParameter {
     public var dataSize: UInt32 {
-        return 8 + UTF16String(value: name).dataSize
+        4 +  UTF16String(value: name).dataSize
     }
 
-    public var extended: UInt32 = 1
     public var reserved: UInt32 = 0
     public var name: String
     
@@ -21,12 +20,6 @@ public struct AlertRuleElementData: RuleElementData {
     }
     
     public init(dataStream: inout DataStream, version: OutlookRulesVersion) throws {
-        /// Extended (4 bytes)
-        self.extended = try dataStream.read(endianess: .littleEndian)
-        guard self.extended == 0x00000001 else {
-            throw OutlookRulesReadError.corrupted
-        }
-        
         /// Reserved (4 bytes)
         self.reserved = try dataStream.read(endianess: .littleEndian)
         
@@ -34,10 +27,7 @@ public struct AlertRuleElementData: RuleElementData {
         self.name = try UTF16String(dataStream: &dataStream).value
     }
     
-    public func write(to dataStream: inout OutputDataStream) {
-        /// Extended (4 bytes)
-        dataStream.write(extended, endianess: .littleEndian)
-        
+    public func write(to dataStream: inout OutputDataStream, version: OutlookRulesVersion) {
         /// Reserved (4 bytes)
         dataStream.write(reserved, endianess: .littleEndian)
         
diff --git a/Sources/OutlookRulesReader/Structures/Parameters/ApplyConditionRuleElementData.swift b/Sources/OutlookRulesReader/Structures/Parameters/ApplyConditionRuleElementData.swift
new file mode 100644
index 0000000..6183702
--- /dev/null
+++ b/Sources/OutlookRulesReader/Structures/Parameters/ApplyConditionRuleElementData.swift
@@ -0,0 +1,51 @@
+//
+//  EventParameter.swift
+//  
+//
+//  Created by Hugh Bellamy on 28/07/2020.
+//
+
+import DataStream
+
+public struct RuleEventFlags: OptionSet {
+    public let rawValue: UInt32
+    
+    public init(rawValue: UInt32) {
+        self.rawValue = rawValue
+    }
+    
+    public init(dataStream: inout DataStream) throws {
+        self.rawValue = try dataStream.read(endianess: .littleEndian)
+    }
+    
+    public static let afterReceived = RuleEventFlags(rawValue: 0x01)
+    public static let afterSent = RuleEventFlags(rawValue: 0x04)
+    public static let afterServerReceived = RuleEventFlags(rawValue: 0x08)
+}
+
+public struct EventParameter: RuleParameter {
+    public let dataSize: UInt32 = 8
+
+    public var reserved: UInt32 = 0
+    public let flags: RuleEventFlags
+    
+    public init(flags: RuleEventFlags) {
+        self.flags = flags
+    }
+    
+    public init(dataStream: inout DataStream, version: OutlookRulesVersion) throws {
+        /// Reserved (4 bytes)
+        self.reserved = try dataStream.read(endianess: .littleEndian)
+        
+        /// Flags (4 bytes)
+        self.flags = try RuleEventFlags(dataStream: &dataStream)
+    }
+    
+    public func write(to dataStream: inout OutputDataStream, version: OutlookRulesVersion) {
+        /// Reserved (4 bytes)
+        dataStream.write(reserved, endianess: .littleEndian)
+        
+        /// Flags (4 bytes)
+        dataStream.write(flags.rawValue, endianess: .littleEndian)
+    }
+}
diff --git a/Sources/OutlookRulesReader/Structures/Rule Elements/CategoriesListRuleElementData.swift b/Sources/OutlookRulesReader/Structures/Parameters/CategoryParameter.swift
similarity index 66%
rename from Sources/OutlookRulesReader/Structures/Rule Elements/CategoriesListRuleElementData.swift
rename to Sources/OutlookRulesReader/Structures/Parameters/CategoryParameter.swift
index 2e653cb..7331ee9 100644
--- a/Sources/OutlookRulesReader/Structures/Rule Elements/CategoriesListRuleElementData.swift	
+++ b/Sources/OutlookRulesReader/Structures/Parameters/CategoryParameter.swift
@@ -1,5 +1,5 @@
 //
-//  CategoriesListRuleElementData.swift
+//  CategoryParameter.swift
 //
 //
 //  Created by Hugh Bellamy on 08/08/2020.
@@ -7,9 +7,9 @@
 
 import DataStream
 
-public struct CategoriesListRuleElementData: RuleElementData {
+public struct CategoryParameter: RuleParameter {
     public var dataSize: UInt32 {
-        return 8 + UTF16String(value: rawCategories).dataSize
+        4 +  UTF16String(value: rawCategories).dataSize
     }
 
     public var extended: UInt32 = 1
@@ -28,12 +28,6 @@ public struct CategoriesListRuleElementData: RuleElementData {
     }
     
     public init(dataStream: inout DataStream, version: OutlookRulesVersion) throws {
-        /// Extended (4 bytes)
-        self.extended = try dataStream.read(endianess: .littleEndian)
-        guard self.extended == 0x00000001 else {
-            throw OutlookRulesReadError.corrupted
-        }
-        
         /// Reserved (4 bytes)
         self.reserved = try dataStream.read(endianess: .littleEndian)
         
@@ -45,14 +39,15 @@ public struct CategoriesListRuleElementData: RuleElementData {
         }
     }
     
-    public func write(to dataStream: inout OutputDataStream) {
-        /// Extended (4 bytes)
-        dataStream.write(extended, endianess: .littleEndian)
-        
+    public func write(to dataStream: inout OutputDataStream, version: OutlookRulesVersion) {
         /// Reserved (4 bytes)
         dataStream.write(reserved, endianess: .littleEndian)
         
         /// Categories (variable)
-        UTF16String(value: rawCategories).write(to: &dataStream)
+        if version >= .outlook2002 {
+            UTF16String(value: rawCategories).write(to: &dataStream)
+        } else {
+            ASCIIString(value: rawCategories).write(to: &dataStream)
+        }
     }
 }
diff --git a/Sources/OutlookRulesReader/Structures/Rule Elements/PerformCustomActionRuleElementData.swift b/Sources/OutlookRulesReader/Structures/Parameters/CustomActionParameter.swift
similarity index 69%
rename from Sources/OutlookRulesReader/Structures/Rule Elements/PerformCustomActionRuleElementData.swift
rename to Sources/OutlookRulesReader/Structures/Parameters/CustomActionParameter.swift
index 27ee226..0952b73 100644
--- a/Sources/OutlookRulesReader/Structures/Rule Elements/PerformCustomActionRuleElementData.swift	
+++ b/Sources/OutlookRulesReader/Structures/Parameters/CustomActionParameter.swift
@@ -1,5 +1,5 @@
 //
-//  PerformCustomActionRuleElementData.swift
+//  CustomActionParameter.swift
 //  
 //
 //  Created by Hugh Bellamy on 31/01/2021.
@@ -7,16 +7,15 @@
 
 import DataStream
 
-public struct PerformCustomActionRuleElementData: RuleElementData {
+public struct CustomActionParameter: RuleParameter {
     public var dataSize: UInt32 {
-        var baseSize: UInt32 = 8
+        var baseSize: UInt32 = 4
         baseSize += UTF16String(value: location).dataSize
         baseSize += UTF16String(value: name).dataSize
         baseSize += UTF16String(value: actionValue).dataSize
         return baseSize
     }
 
-    public var extended: UInt32 = 1
     public var reserved: UInt32 = 0
     public var location: String
     public var name: String
@@ -31,12 +30,6 @@ public struct PerformCustomActionRuleElementData: RuleElementData {
     }
     
     public init(dataStream: inout DataStream, version: OutlookRulesVersion) throws {
-        /// Extended (4 bytes)
-        self.extended = try dataStream.read(endianess: .littleEndian)
-        guard self.extended == 0x00000001 else {
-            throw OutlookRulesReadError.corrupted
-        }
-        
         /// Reserved (4 bytes)
         self.reserved = try dataStream.read(endianess: .littleEndian)
         
@@ -69,23 +62,36 @@ public struct PerformCustomActionRuleElementData: RuleElementData {
         }
     }
     
-    public func write(to dataStream: inout OutputDataStream) {
-        /// Extended (4 bytes)
-        dataStream.write(extended, endianess: .littleEndian)
-        
+    public func write(to dataStream: inout OutputDataStream, version: OutlookRulesVersion) {
         /// Reserved (4 bytes)
         dataStream.write(reserved, endianess: .littleEndian)
         
         /// Location (variable)
-        UTF16String(value: location).write(to: &dataStream)
+        if version >= .outlook2002 {
+            UTF16String(value: location).write(to: &dataStream)
+        } else {
+            ASCIIString(value: location).write(to: &dataStream)
+        }
         
         /// Name (variable)
-        UTF16String(value: name).write(to: &dataStream)
+        if version >= .outlook2002 {
+            UTF16String(value: name).write(to: &dataStream)
+        } else {
+            ASCIIString(value: name).write(to: &dataStream)
+        }
         
         /// Options (variable)
-        UTF16String(value: options).write(to: &dataStream)
+        if version >= .outlook2002 {
+            UTF16String(value: options).write(to: &dataStream)
+        } else {
+            ASCIIString(value: options).write(to: &dataStream)
+        }
         
         /// Action Value (variable)
-        UTF16String(value: actionValue).write(to: &dataStream)
+        if version >= .outlook2002 {
+            UTF16String(value: actionValue).write(to: &dataStream)
+        } else {
+            ASCIIString(value: actionValue).write(to: &dataStream)
+        }
     }
 }
diff --git a/Sources/OutlookRulesReader/Structures/Rule Elements/DeferDeliveryRuleElementData.swift b/Sources/OutlookRulesReader/Structures/Parameters/DeferParameter.swift
similarity index 56%
rename from Sources/OutlookRulesReader/Structures/Rule Elements/DeferDeliveryRuleElementData.swift
rename to Sources/OutlookRulesReader/Structures/Parameters/DeferParameter.swift
index 72047af..8451230 100644
--- a/Sources/OutlookRulesReader/Structures/Rule Elements/DeferDeliveryRuleElementData.swift	
+++ b/Sources/OutlookRulesReader/Structures/Parameters/DeferParameter.swift
@@ -1,5 +1,5 @@
 //
-//  DeferDeliveryRuleElementData.swift
+//  DeferParameter.swift
 //
 //
 //  Created by Hugh Bellamy on 28/07/2020.
@@ -7,10 +7,9 @@
 
 import DataStream
 
-public struct DeferDeliveryRuleElementData: RuleElementData {
-    public let dataSize: UInt32 = 12
+public struct DeferParameter: RuleParameter {
+    public let dataSize: UInt32 = 8
 
-    public var extended: UInt32 = 1
     public var reserved: UInt32 = 0
     public var minutes: UInt32
     
@@ -19,12 +18,6 @@ public struct DeferDeliveryRuleElementData: RuleElementData {
     }
     
     public init(dataStream: inout DataStream, version: OutlookRulesVersion) throws {
-        /// Extended (4 bytes)
-        self.extended = try dataStream.read(endianess: .littleEndian)
-        guard self.extended == 0x00000001 else {
-            throw OutlookRulesReadError.corrupted
-        }
-        
         /// Reserved (4 bytes)
         self.reserved = try dataStream.read(endianess: .littleEndian)
         
@@ -32,10 +25,7 @@ public struct DeferDeliveryRuleElementData: RuleElementData {
         self.minutes = try dataStream.read(endianess: .littleEndian)
     }
     
-    public func write(to dataStream: inout OutputDataStream) {
-        /// Extended (4 bytes)
-        dataStream.write(extended, endianess: .littleEndian)
-        
+    public func write(to dataStream: inout OutputDataStream, version: OutlookRulesVersion) {
         /// Reserved (4 bytes)
         dataStream.write(reserved, endianess: .littleEndian)
 
diff --git a/Sources/OutlookRulesReader/Structures/Rule Elements/FlagForFollowUpRuleElementData.swift b/Sources/OutlookRulesReader/Structures/Parameters/FlagForFollowUpParameter.swift
similarity index 69%
rename from Sources/OutlookRulesReader/Structures/Rule Elements/FlagForFollowUpRuleElementData.swift
rename to Sources/OutlookRulesReader/Structures/Parameters/FlagForFollowUpParameter.swift
index 52d9e38..d8639bb 100644
--- a/Sources/OutlookRulesReader/Structures/Rule Elements/FlagForFollowUpRuleElementData.swift	
+++ b/Sources/OutlookRulesReader/Structures/Parameters/FlagForFollowUpParameter.swift
@@ -1,5 +1,5 @@
 //
-//  FlagForFollowUpRuleElementData.swift
+//  FlagForFollowUpParameter.swift
 //
 //
 //  Created by Hugh Bellamy on 08/08/2020.
@@ -7,6 +7,7 @@
 
 import DataStream
 
+/// Specifies the time period for which an Outlook item is marked as a task.
 public enum FollowUp: UInt32 {
     case today = 0x00000001
     case tomorrow = 0x00000002
@@ -16,14 +17,11 @@ public enum FollowUp: UInt32 {
     case completed = 0x0000000A
 }
 
-public struct FlagForFollowUpRuleElementData: RuleElementData {
+public struct FlagForFollowUpParameter: RuleParameter {
     public var dataSize: UInt32 {
-        var baseSize: UInt32 = 12
-        baseSize += UTF16String(value: actionName).dataSize
-        return baseSize
+        4 + UTF16String(value: actionName).dataSize
     }
 
-    public var extended: UInt32 = 1
     public var reserved: UInt32 = 0
     public var rawFollowUp: UInt32
     public var followUp: FollowUp {
@@ -41,12 +39,6 @@ public struct FlagForFollowUpRuleElementData: RuleElementData {
     }
     
     public init(dataStream: inout DataStream, version: OutlookRulesVersion) throws {
-        /// Extended (4 bytes)
-        self.extended = try dataStream.read(endianess: .littleEndian)
-        guard self.extended == 0x00000001 else {
-            throw OutlookRulesReadError.corrupted
-        }
-        
         /// Reserved (4 bytes)
         self.reserved = try dataStream.read(endianess: .littleEndian)
         
@@ -57,10 +49,7 @@ public struct FlagForFollowUpRuleElementData: RuleElementData {
         self.actionName = try UTF16String(dataStream: &dataStream).value
     }
     
-    public func write(to dataStream: inout OutputDataStream) {
-        /// Extended (4 bytes)
-        dataStream.write(extended, endianess: .littleEndian)
-        
+    public func write(to dataStream: inout OutputDataStream, version: OutlookRulesVersion) {
         /// Reserved (4 bytes)
         dataStream.write(reserved, endianess: .littleEndian)
         
diff --git a/Sources/OutlookRulesReader/Structures/Rule Elements/FlagRuleElementData.swift b/Sources/OutlookRulesReader/Structures/Parameters/FlagRuleElementData.swift
similarity index 75%
rename from Sources/OutlookRulesReader/Structures/Rule Elements/FlagRuleElementData.swift
rename to Sources/OutlookRulesReader/Structures/Parameters/FlagRuleElementData.swift
index a8882cb..164847a 100644
--- a/Sources/OutlookRulesReader/Structures/Rule Elements/FlagRuleElementData.swift	
+++ b/Sources/OutlookRulesReader/Structures/Parameters/FlagRuleElementData.swift
@@ -7,14 +7,13 @@
 
 import DataStream
 
-public struct FlagRuleElementData: RuleElementData {
+public struct FlagRuleElementData: RuleParameter {
     public var dataSize: UInt32 {
-        var baseSize: UInt32 = 16
+        var baseSize: UInt32 = 12
         baseSize += UTF16String(value: actionName).dataSize
         return baseSize
     }
 
-    public var extended: UInt32 = 1
     public var reserved: UInt32 = 0
     public var days: UInt32
     public var actionName: String
@@ -26,12 +25,6 @@ public struct FlagRuleElementData: RuleElementData {
     }
     
     public init(dataStream: inout DataStream, version: OutlookRulesVersion) throws {
-        /// Extended (4 bytes)
-        self.extended = try dataStream.read(endianess: .littleEndian)
-        guard self.extended == 0x00000001 else {
-            throw OutlookRulesReadError.corrupted
-        }
-        
         /// Reserved (4 bytes)
         self.reserved = try dataStream.read(endianess: .littleEndian)
         
@@ -49,10 +42,7 @@ public struct FlagRuleElementData: RuleElementData {
         self.unknown = try dataStream.read(endianess: .littleEndian)
     }
     
-    public func write(to dataStream: inout OutputDataStream) {
-        /// Extended (4 bytes)
-        dataStream.write(extended, endianess: .littleEndian)
-        
+    public func write(to dataStream: inout OutputDataStream, version: OutlookRulesVersion) {
         /// Reserved (4 bytes)
         dataStream.write(reserved, endianess: .littleEndian)
         
diff --git a/Sources/OutlookRulesReader/Structures/Rule Elements/FlaggedForActionRuleElementData.swift b/Sources/OutlookRulesReader/Structures/Parameters/FlaggedForActionParameter.swift
similarity index 74%
rename from Sources/OutlookRulesReader/Structures/Rule Elements/FlaggedForActionRuleElementData.swift
rename to Sources/OutlookRulesReader/Structures/Parameters/FlaggedForActionParameter.swift
index de3680f..c743c32 100644
--- a/Sources/OutlookRulesReader/Structures/Rule Elements/FlaggedForActionRuleElementData.swift	
+++ b/Sources/OutlookRulesReader/Structures/Parameters/FlaggedForActionParameter.swift
@@ -1,5 +1,5 @@
 //
-//  FlaggedForActionCondition.swift
+//  FlaggedForActionParameter.swift
 //  
 //
 //  Created by Hugh Bellamy on 08/08/2020.
@@ -7,7 +7,7 @@
 
 import DataStream
 
-public struct FlaggedForActionRuleElementData: RuleElementData {
+public struct FlaggedForActionParameter: RuleParameter {
     public var dataSize: UInt32 {
         var baseSize: UInt32 = 12
         baseSize += UTF16String(value: action).dataSize
@@ -15,7 +15,6 @@ public struct FlaggedForActionRuleElementData: RuleElementData {
         return baseSize
     }
 
-    public var extended: UInt32 = 1
     public var reserved: UInt32 = 0
     public var unknown1: UInt32 = 0
     public var action: String
@@ -26,12 +25,6 @@ public struct FlaggedForActionRuleElementData: RuleElementData {
     }
     
     public init(dataStream: inout DataStream, version: OutlookRulesVersion) throws {
-        /// Extended (4 bytes)
-        self.extended = try dataStream.read(endianess: .littleEndian)
-        guard self.extended == 0x00000001 else {
-            throw OutlookRulesReadError.corrupted
-        }
-        
         /// Reserved (4 bytes)
         self.reserved = try dataStream.read(endianess: .littleEndian)
         
@@ -49,10 +42,7 @@ public struct FlaggedForActionRuleElementData: RuleElementData {
         self.unknown2 = try dataStream.read(endianess: .littleEndian)
     }
     
-    public func write(to dataStream: inout OutputDataStream) {
-        /// Extended (4 bytes)
-        dataStream.write(extended, endianess: .littleEndian)
-        
+    public func write(to dataStream: inout OutputDataStream, version: OutlookRulesVersion) {
         /// Reserved (4 bytes)
         dataStream.write(reserved, endianess: .littleEndian)
         
diff --git a/Sources/OutlookRulesReader/Structures/Rule Elements/MoveToFolderRuleElementData.swift b/Sources/OutlookRulesReader/Structures/Parameters/FolderParameter.swift
similarity index 77%
rename from Sources/OutlookRulesReader/Structures/Rule Elements/MoveToFolderRuleElementData.swift
rename to Sources/OutlookRulesReader/Structures/Parameters/FolderParameter.swift
index 79f8bff..099c97d 100644
--- a/Sources/OutlookRulesReader/Structures/Rule Elements/MoveToFolderRuleElementData.swift	
+++ b/Sources/OutlookRulesReader/Structures/Parameters/FolderParameter.swift
@@ -1,5 +1,5 @@
 //
-//  MoveToFolderRuleElementData.swift
+//  FolderParameter.swift
 //
 //
 //  Created by Hugh Bellamy on 08/08/2020.
@@ -8,7 +8,7 @@
 import DataStream
 import MAPI
 
-public struct MoveToFolderRuleElementData: RuleElementData {
+public struct FolderParameter: RuleParameter {
     public var dataSize: UInt32 {
         var baseSize: UInt32 = 8
         baseSize += UInt32(FlatEntry(entryID: folderEntryId).dataSize)
@@ -17,7 +17,6 @@ public struct MoveToFolderRuleElementData: RuleElementData {
         return baseSize
     }
 
-    public var extended: UInt32 = 1
     public var reserved: UInt32 = 0
     public var folderEntryId: EntryID
     public var storeEntryId: EntryID
@@ -31,12 +30,6 @@ public struct MoveToFolderRuleElementData: RuleElementData {
     }
     
     public init(dataStream: inout DataStream, version: OutlookRulesVersion) throws {
-        /// Extended (4 bytes)
-        self.extended = try dataStream.read(endianess: .littleEndian)
-        guard self.extended == 0x00000001 else {
-            throw OutlookRulesReadError.corrupted
-        }
-        
         /// Reserved (4 bytes)
         self.reserved = try dataStream.read(endianess: .littleEndian)
 
@@ -61,10 +54,7 @@ public struct MoveToFolderRuleElementData: RuleElementData {
         }
     }
     
-    public func write(to dataStream: inout OutputDataStream) {
-        /// Extended (4 bytes)
-        dataStream.write(extended, endianess: .littleEndian)
-        
+    public func write(to dataStream: inout OutputDataStream, version: OutlookRulesVersion) {
         /// Reserved (4 bytes)
         dataStream.write(reserved, endianess: .littleEndian)
         
@@ -77,9 +67,9 @@ public struct MoveToFolderRuleElementData: RuleElementData {
         /// Folder Name (variable)
         UTF16String(value: folderName).write(to: &dataStream)
         
-        if let secondaryUserStore = secondaryUserStore {
+        if version != .noSignature {
             /// Secondary User Store (4 bytes)
-            dataStream.write((secondaryUserStore ? 1 : 0) as UInt32, endianess: .littleEndian)
+            dataStream.write((secondaryUserStore! ? 1 : 0) as UInt32, endianess: .littleEndian)
         }
     }
 }
diff --git a/Sources/OutlookRulesReader/Structures/Rule Elements/WithSelectedPropertiesOfDocumentOrFormsRuleElementData.swift b/Sources/OutlookRulesReader/Structures/Parameters/FormParameter.swift
similarity index 83%
rename from Sources/OutlookRulesReader/Structures/Rule Elements/WithSelectedPropertiesOfDocumentOrFormsRuleElementData.swift
rename to Sources/OutlookRulesReader/Structures/Parameters/FormParameter.swift
index a454010..e6bd180 100644
--- a/Sources/OutlookRulesReader/Structures/Rule Elements/WithSelectedPropertiesOfDocumentOrFormsRuleElementData.swift	
+++ b/Sources/OutlookRulesReader/Structures/Parameters/FormParameter.swift
@@ -1,5 +1,5 @@
 //
-//  UsesFormRuleElementData.swift
+//  FormParameter.swift
 //
 //
 //  Created by Hugh Bellamy on 29/07/2020.
@@ -9,9 +9,9 @@ import DataStream
 import Foundation
 import MAPI
 
-public struct WithSelectedPropertiesOfDocumentOrFormsRuleElementData: RuleElementData {
+public struct FormParameter: RuleParameter {
     public var dataSize: UInt32 {
-        var baseSize: UInt32 = 8
+        var baseSize: UInt32 = 4
         for form in forms {
             baseSize += UTF16String(value: form).dataSize
         }
@@ -27,7 +27,6 @@ public struct WithSelectedPropertiesOfDocumentOrFormsRuleElementData: RuleElemen
         return baseSize
     }
     
-    public var extended: UInt32 = 1
     public var reserved: UInt32 = 0
     public var forms: [String]
     public var documentProperties: [DocumentProperty]
@@ -40,12 +39,6 @@ public struct WithSelectedPropertiesOfDocumentOrFormsRuleElementData: RuleElemen
     }
     
     public init(dataStream: inout DataStream, version: OutlookRulesVersion) throws {
-        /// Extended (4 bytes)
-        self.extended = try dataStream.read(endianess: .littleEndian)
-        guard self.extended == 0x00000001 else {
-            throw OutlookRulesReadError.corrupted
-        }
-        
         /// Reserved (4 bytes)
         self.reserved = try dataStream.read(endianess: .littleEndian)
 
@@ -86,10 +79,7 @@ public struct WithSelectedPropertiesOfDocumentOrFormsRuleElementData: RuleElemen
         self.classes = classes
     }
     
-    public func write(to dataStream: inout OutputDataStream) {
-        /// Extended (4 bytes)
-        dataStream.write(extended, endianess: .littleEndian)
-        
+    public func write(to dataStream: inout OutputDataStream, version: OutlookRulesVersion) {
         /// Reserved (4 bytes)
         dataStream.write(reserved, endianess: .littleEndian)
 
@@ -101,7 +91,7 @@ public struct WithSelectedPropertiesOfDocumentOrFormsRuleElementData: RuleElemen
         
         /// Document Properties (variable)
         for documentProperty in documentProperties {
-            documentProperty.write(to: &dataStream)
+            documentProperty.write(to: &dataStream, version: version)
         }
         
         /// Number of Classes (4 bytes)
diff --git a/Sources/OutlookRulesReader/Structures/Objects/Form.swift b/Sources/OutlookRulesReader/Structures/Parameters/FormTypeParameter.swift
similarity index 75%
rename from Sources/OutlookRulesReader/Structures/Objects/Form.swift
rename to Sources/OutlookRulesReader/Structures/Parameters/FormTypeParameter.swift
index 0bbfeff..b41e236 100644
--- a/Sources/OutlookRulesReader/Structures/Objects/Form.swift
+++ b/Sources/OutlookRulesReader/Structures/Parameters/FormTypeParameter.swift
@@ -1,13 +1,13 @@
 //
-//  Form.swift
-//  
+//  FormTypeParameter.swift
 //
-//  Created by Hugh Bellamy on 04/02/2021.
+//
+//  Created by Hugh Bellamy on 29/07/2020.
 //
 
 import DataStream
 
-public struct Form {
+public struct FormTypeParameter: RuleParameter {
     public var dataSize: UInt32 {
         var baseSize: UInt32 = 4
         baseSize += UTF16String(value: name).dataSize
@@ -39,12 +39,16 @@ public struct Form {
         self.className = try ASCIIString(dataStream: &dataStream).value
     }
     
-    public func write(to dataStream: inout OutputDataStream) {
+    public func write(to dataStream: inout OutputDataStream, version: OutlookRulesVersion) {
         /// Reserved (4 bytes)
         dataStream.write(reserved, endianess: .littleEndian)
         
         /// Name (variable)
-        UTF16String(value: name).write(to: &dataStream)
+        if version >= .outlook2002 {
+            UTF16String(value: name).write(to: &dataStream)
+        } else {
+            ASCIIString(value: name).write(to: &dataStream)
+        }
 
         /// Class Name (variable)
         ASCIIString(value: name).write(to: &dataStream)
diff --git a/Sources/OutlookRulesReader/Structures/Rule Elements/ImportanceRuleElementData.swift b/Sources/OutlookRulesReader/Structures/Parameters/ImportanceParameter.swift
similarity index 66%
rename from Sources/OutlookRulesReader/Structures/Rule Elements/ImportanceRuleElementData.swift
rename to Sources/OutlookRulesReader/Structures/Parameters/ImportanceParameter.swift
index 00cf2f9..cfac010 100644
--- a/Sources/OutlookRulesReader/Structures/Rule Elements/ImportanceRuleElementData.swift	
+++ b/Sources/OutlookRulesReader/Structures/Parameters/ImportanceParameter.swift
@@ -1,5 +1,5 @@
 //
-//  ImportanceRuleElementData.swift
+//  ImportanceParameter.swift
 //
 //
 //  Created by Hugh Bellamy on 28/07/2020.
@@ -8,10 +8,9 @@
 import DataStream
 import MAPI
 
-public struct ImportanceRuleElementData: RuleElementData {
+public struct ImportanceParameter: RuleParameter {
     public let dataSize: UInt32 = 12
 
-    public var extended: UInt32 = 1
     public var reserved: UInt32 = 0
     public var rawImportance: UInt32
     public var importance: MessageImportance {
@@ -27,12 +26,6 @@ public struct ImportanceRuleElementData: RuleElementData {
     }
     
     public init(dataStream: inout DataStream, version: OutlookRulesVersion) throws {
-        /// Extended (4 bytes)
-        self.extended = try dataStream.read(endianess: .littleEndian)
-        guard self.extended == 0x00000001 else {
-            throw OutlookRulesReadError.corrupted
-        }
-        
         /// Reserved (4 bytes)
         self.reserved = try dataStream.read(endianess: .littleEndian)
         
@@ -40,10 +33,7 @@ public struct ImportanceRuleElementData: RuleElementData {
         self.rawImportance = try dataStream.read(endianess: .littleEndian)
     }
     
-    public func write(to dataStream: inout OutputDataStream) {
-        /// Extended (4 bytes)
-        dataStream.write(extended, endianess: .littleEndian)
-        
+    public func write(to dataStream: inout OutputDataStream, version: OutlookRulesVersion) {
         /// Reserved (4 bytes)
         dataStream.write(reserved, endianess: .littleEndian)
 
diff --git a/Sources/OutlookRulesReader/Structures/Rule Elements/DisplayMessageInNewItemAlertWindowRuleElementData.swift b/Sources/OutlookRulesReader/Structures/Parameters/MessageParameter.swift
similarity index 56%
rename from Sources/OutlookRulesReader/Structures/Rule Elements/DisplayMessageInNewItemAlertWindowRuleElementData.swift
rename to Sources/OutlookRulesReader/Structures/Parameters/MessageParameter.swift
index 19e2ebe..f3398a7 100644
--- a/Sources/OutlookRulesReader/Structures/Rule Elements/DisplayMessageInNewItemAlertWindowRuleElementData.swift	
+++ b/Sources/OutlookRulesReader/Structures/Parameters/MessageParameter.swift
@@ -1,5 +1,5 @@
 //
-//  DisplayMessageInNewItemAlertWindowRuleElementData.swift
+//  MessageParameter.swift
 //
 //
 //  Created by Hugh Bellamy on 08/08/2020.
@@ -7,12 +7,11 @@
 
 import DataStream
 
-public struct DisplayMessageInNewItemAlertWindowRuleElementData: RuleElementData {
+public struct MessageParameter: RuleParameter {
     public var dataSize: UInt32 {
-        return 8 + UTF16String(value: message).dataSize
+        4 + UTF16String(value: message).dataSize
     }
 
-    public var extended: UInt32 = 1
     public var reserved: UInt32 = 0
     public var message: String
     
@@ -21,12 +20,6 @@ public struct DisplayMessageInNewItemAlertWindowRuleElementData: RuleElementData
     }
     
     public init(dataStream: inout DataStream, version: OutlookRulesVersion) throws {
-        /// Extended (4 bytes)
-        self.extended = try dataStream.read(endianess: .littleEndian)
-        guard self.extended == 0x00000001 else {
-            throw OutlookRulesReadError.corrupted
-        }
-        
         /// Reserved (4 bytes)
         self.reserved = try dataStream.read(endianess: .littleEndian)
         
@@ -38,14 +31,15 @@ public struct DisplayMessageInNewItemAlertWindowRuleElementData: RuleElementData
         }
     }
     
-    public func write(to dataStream: inout OutputDataStream) {
-        /// Extended (4 bytes)
-        dataStream.write(extended, endianess: .littleEndian)
-        
+    public func write(to dataStream: inout OutputDataStream, version: OutlookRulesVersion) {
         /// Reserved (4 bytes)
         dataStream.write(reserved, endianess: .littleEndian)
         
         /// Message (variable)
-        UTF16String(value: message).write(to: &dataStream)
+        if version >= .outlook2002 {
+            UTF16String(value: message).write(to: &dataStream)
+        } else {
+            ASCIIString(value: message).write(to: &dataStream)
+        }
     }
 }
diff --git a/Sources/OutlookRulesReader/Structures/Rule Elements/PathRuleElementData.swift b/Sources/OutlookRulesReader/Structures/Parameters/PathParameter.swift
similarity index 58%
rename from Sources/OutlookRulesReader/Structures/Rule Elements/PathRuleElementData.swift
rename to Sources/OutlookRulesReader/Structures/Parameters/PathParameter.swift
index a431a4a..8ce5445 100644
--- a/Sources/OutlookRulesReader/Structures/Rule Elements/PathRuleElementData.swift	
+++ b/Sources/OutlookRulesReader/Structures/Parameters/PathParameter.swift
@@ -1,5 +1,5 @@
 //
-//  PathRuleElementData.swift
+//  PathParameter.swift
 //
 //
 //  Created by Hugh Bellamy on 08/08/2020.
@@ -7,12 +7,11 @@
 
 import DataStream
 
-public struct PathRuleElementData: RuleElementData {
+public struct PathParameter: RuleParameter {
     public var dataSize: UInt32 {
-        return 8 + UTF16String(value: path).dataSize
+        4 +  UTF16String(value: path).dataSize
     }
 
-    public var extended: UInt32 = 1
     public var reserved: UInt32 = 0
     public var path: String
     
@@ -21,12 +20,6 @@ public struct PathRuleElementData: RuleElementData {
     }
     
     public init(dataStream: inout DataStream, version: OutlookRulesVersion) throws {
-        /// Extended (4 bytes)
-        self.extended = try dataStream.read(endianess: .littleEndian)
-        guard self.extended == 0x00000001 else {
-            throw OutlookRulesReadError.corrupted
-        }
-        
         /// Reserved (4 bytes)
         self.reserved = try dataStream.read(endianess: .littleEndian)
         
@@ -38,14 +31,15 @@ public struct PathRuleElementData: RuleElementData {
         }
     }
     
-    public func write(to dataStream: inout OutputDataStream) {
-        /// Extended (4 bytes)
-        dataStream.write(extended, endianess: .littleEndian)
-        
+    public func write(to dataStream: inout OutputDataStream, version: OutlookRulesVersion) {
         /// Reserved (4 bytes)
         dataStream.write(reserved, endianess: .littleEndian)
         
         /// Path (variable)
-        UTF16String(value: path).write(to: &dataStream)
+        if version >= .outlook2002 {
+            UTF16String(value: path).write(to: &dataStream)
+        } else {
+            ASCIIString(value: path).write(to: &dataStream)
+        }
     }
 }
diff --git a/Sources/OutlookRulesReader/Structures/Rule Elements/OnThisComputerOnlyRuleElementData.swift b/Sources/OutlookRulesReader/Structures/Parameters/ProfileStampParameter.swift
similarity index 60%
rename from Sources/OutlookRulesReader/Structures/Rule Elements/OnThisComputerOnlyRuleElementData.swift
rename to Sources/OutlookRulesReader/Structures/Parameters/ProfileStampParameter.swift
index 243ae6a..e0d5794 100644
--- a/Sources/OutlookRulesReader/Structures/Rule Elements/OnThisComputerOnlyRuleElementData.swift	
+++ b/Sources/OutlookRulesReader/Structures/Parameters/ProfileStampParameter.swift
@@ -1,5 +1,5 @@
 //
-//  OnThisComputerOnlyCondition.swift
+//  ProfileStampParameter.swift
 //  
 //
 //  Created by Hugh Bellamy on 07/08/2020.
@@ -8,10 +8,9 @@
 import DataStream
 import WindowsDataTypes
 
-public struct OnThisComputerOnlyRuleElementData: RuleElementData {
-    public let dataSize: UInt32 = 24
+public struct ProfileStampParameter: RuleParameter {
+    public let dataSize: UInt32 = 20
 
-    public var extended: UInt32 = 1
     public var reserved: UInt32 = 0
     public var uuid: GUID
     
@@ -20,9 +19,6 @@ public struct OnThisComputerOnlyRuleElementData: RuleElementData {
     }
     
     public init(dataStream: inout DataStream, version: OutlookRulesVersion) throws {
-        /// Extended (4 bytes)
-        self.extended = try dataStream.read(endianess: .littleEndian)
-
         /// Reserved (4 bytes)
         self.reserved = try dataStream.read(endianess: .littleEndian)
 
@@ -30,10 +26,7 @@ public struct OnThisComputerOnlyRuleElementData: RuleElementData {
         self.uuid = try GUID(dataStream: &dataStream)
     }
     
-    public func write(to dataStream: inout OutputDataStream) {
-        /// Extended (4 bytes)
-        dataStream.write(extended, endianess: .littleEndian)
-
+    public func write(to dataStream: inout OutputDataStream, version: OutlookRulesVersion) {
         /// Reserved (4 bytes)
         dataStream.write(reserved, endianess: .littleEndian)
 
diff --git a/Sources/OutlookRulesReader/Structures/Parameters/RelevanceParameter.swift b/Sources/OutlookRulesReader/Structures/Parameters/RelevanceParameter.swift
new file mode 100644
index 0000000..89df3cd
--- /dev/null
+++ b/Sources/OutlookRulesReader/Structures/Parameters/RelevanceParameter.swift
@@ -0,0 +1,35 @@
+//
+//  RelevanceParameter.swift
+//
+//
+//  Created by Hugh Bellamy on 28/07/2020.
+//
+
+import DataStream
+
+internal struct RelevanceParameter: RuleParameter {
+    public let dataSize: UInt32 = 8
+
+    public var reserved: UInt32 = 0
+    public var value: UInt32 = 1
+    
+    public init(value: UInt32) {
+        self.value = value
+    }
+    
+    public init(dataStream: inout DataStream, version: OutlookRulesVersion) throws {
+        /// Reserved (4 bytes)
+        self.reserved = try dataStream.read(endianess: .littleEndian)
+        
+        /// Value (4 bytes)
+        self.value = try dataStream.read(endianess: .littleEndian)
+    }
+    
+    public func write(to dataStream: inout OutputDataStream, version: OutlookRulesVersion) {
+        /// Reserved (4 bytes)
+        dataStream.write(reserved, endianess: .littleEndian)
+        
+        /// Value (4 bytes)
+        dataStream.write(value, endianess: .littleEndian)
+    }
+}
diff --git a/Sources/OutlookRulesReader/Structures/Rule Elements/RelevanceInSpecificRangeRuleElementData.swift b/Sources/OutlookRulesReader/Structures/Parameters/RelevanceRangeParameter.swift
similarity index 68%
rename from Sources/OutlookRulesReader/Structures/Rule Elements/RelevanceInSpecificRangeRuleElementData.swift
rename to Sources/OutlookRulesReader/Structures/Parameters/RelevanceRangeParameter.swift
index 5b8a39e..0031b86 100644
--- a/Sources/OutlookRulesReader/Structures/Rule Elements/RelevanceInSpecificRangeRuleElementData.swift	
+++ b/Sources/OutlookRulesReader/Structures/Parameters/RelevanceRangeParameter.swift
@@ -1,5 +1,5 @@
 //
-//  RelevanceInSpecificRangeRuleElementData.swift
+//  RelevanceRangeParameter.swift
 //
 //
 //  Created by Hugh Bellamy on 28/07/2020.
@@ -7,10 +7,9 @@
 
 import DataStream
 
-public struct RelevanceInSpecificRangeRuleElementData: RuleElementData {
+public struct RelevanceRangeParameter: RuleParameter {
     public let dataSize: UInt32 = 12
 
-    public var extended: UInt32 = 1
     public var reserved: UInt32 = 0
     public var minimumRelevance: UInt32
     public var maximumRelevance: UInt32
@@ -21,12 +20,6 @@ public struct RelevanceInSpecificRangeRuleElementData: RuleElementData {
     }
     
     public init(dataStream: inout DataStream, version: OutlookRulesVersion) throws {
-        /// Extended (4 bytes)
-        self.extended = try dataStream.read(endianess: .littleEndian)
-        guard self.extended == 0x00000001 else {
-            throw OutlookRulesReadError.corrupted
-        }
-        
         /// Reserved (4 bytes)
         self.reserved = try dataStream.read(endianess: .littleEndian)
         
@@ -37,10 +30,7 @@ public struct RelevanceInSpecificRangeRuleElementData: RuleElementData {
         self.maximumRelevance = try dataStream.read(endianess: .littleEndian)
     }
     
-    public func write(to dataStream: inout OutputDataStream) {
-        /// Extended (4 bytes)
-        dataStream.write(extended, endianess: .littleEndian)
-        
+    public func write(to dataStream: inout OutputDataStream, version: OutlookRulesVersion) {
         /// Reserved (4 bytes)
         dataStream.write(reserved, endianess: .littleEndian)
 
diff --git a/Sources/OutlookRulesReader/Structures/Rule Elements/ApplyRetentionPolicyRuleElementData.swift b/Sources/OutlookRulesReader/Structures/Parameters/RetentionPolicyParameter.swift
similarity index 62%
rename from Sources/OutlookRulesReader/Structures/Rule Elements/ApplyRetentionPolicyRuleElementData.swift
rename to Sources/OutlookRulesReader/Structures/Parameters/RetentionPolicyParameter.swift
index b2f2251..ab6eac1 100644
--- a/Sources/OutlookRulesReader/Structures/Rule Elements/ApplyRetentionPolicyRuleElementData.swift	
+++ b/Sources/OutlookRulesReader/Structures/Parameters/RetentionPolicyParameter.swift
@@ -1,5 +1,5 @@
 //
-//  ApplyRetentionPolicyRuleElementData.swift
+//  RetentionPolicyParameter.swift
 //
 //
 //  Created by Hugh Bellamy on 08/08/2020.
@@ -8,12 +8,11 @@
 import DataStream
 import WindowsDataTypes
 
-public struct ApplyRetentionPolicyRuleElementData: RuleElementData {
+public struct RetentionPolicyParameter: RuleParameter {
     public var dataSize: UInt32 {
-        return 24 + UTF16String(value: name).dataSize
+        return 20 + UTF16String(value: name).dataSize
     }
 
-    public var extended: UInt32 = 1
     public var reserved: UInt32 = 0
     public var guid: GUID
     public var name: String
@@ -24,12 +23,6 @@ public struct ApplyRetentionPolicyRuleElementData: RuleElementData {
     }
     
     public init(dataStream: inout DataStream, version: OutlookRulesVersion) throws {
-        /// Extended (4 bytes)
-        self.extended = try dataStream.read(endianess: .littleEndian)
-        guard self.extended == 0x00000001 else {
-            throw OutlookRulesReadError.corrupted
-        }
-        
         /// Reserved (4 bytes)
         self.reserved = try dataStream.read(endianess: .littleEndian)
         
@@ -40,10 +33,7 @@ public struct ApplyRetentionPolicyRuleElementData: RuleElementData {
         self.name = try UTF16String(dataStream: &dataStream).value
     }
     
-    public func write(to dataStream: inout OutputDataStream) {
-        /// Extended (4 bytes)
-        dataStream.write(extended, endianess: .littleEndian)
-        
+    public func write(to dataStream: inout OutputDataStream, version: OutlookRulesVersion) {
         /// Reserved (4 bytes)
         dataStream.write(reserved, endianess: .littleEndian)
         
diff --git a/Sources/OutlookRulesReader/Structures/Rule Elements/RunScriptRuleElementData.swift b/Sources/OutlookRulesReader/Structures/Parameters/ScriptParameter.swift
similarity index 63%
rename from Sources/OutlookRulesReader/Structures/Rule Elements/RunScriptRuleElementData.swift
rename to Sources/OutlookRulesReader/Structures/Parameters/ScriptParameter.swift
index d4b5361..1c4910d 100644
--- a/Sources/OutlookRulesReader/Structures/Rule Elements/RunScriptRuleElementData.swift	
+++ b/Sources/OutlookRulesReader/Structures/Parameters/ScriptParameter.swift
@@ -1,5 +1,5 @@
 //
-//  RunScriptRuleElementData.swift
+//  ScriptParameter.swift
 //
 //
 //  Created by Hugh Bellamy on 08/08/2020.
@@ -7,12 +7,11 @@
 
 import DataStream
 
-public struct RunScriptRuleElementData: RuleElementData {
+public struct ScriptParameter: RuleParameter {
     public var dataSize: UInt32 {
-        return 8 + UTF16String(value: name).dataSize + UTF16String(value: function).dataSize
+        4 +  UTF16String(value: name).dataSize + UTF16String(value: function).dataSize
     }
 
-    public var extended: UInt32 = 1
     public var reserved: UInt32 = 0
     public var name: String
     public var function: String
@@ -23,12 +22,6 @@ public struct RunScriptRuleElementData: RuleElementData {
     }
     
     public init(dataStream: inout DataStream, version: OutlookRulesVersion) throws {
-        /// Extended (4 bytes)
-        self.extended = try dataStream.read(endianess: .littleEndian)
-        guard self.extended == 0x00000001 else {
-            throw OutlookRulesReadError.corrupted
-        }
-        
         /// Reserved (4 bytes)
         self.reserved = try dataStream.read(endianess: .littleEndian)
         
@@ -39,10 +32,7 @@ public struct RunScriptRuleElementData: RuleElementData {
         self.function = try UTF16String(dataStream: &dataStream).value
     }
     
-    public func write(to dataStream: inout OutputDataStream) {
-        /// Extended (4 bytes)
-        dataStream.write(extended, endianess: .littleEndian)
-        
+    public func write(to dataStream: inout OutputDataStream, version: OutlookRulesVersion) {        
         /// Reserved (4 bytes)
         dataStream.write(reserved, endianess: .littleEndian)
         
diff --git a/Sources/OutlookRulesReader/Structures/Rule Elements/JunkRuleElementData.swift b/Sources/OutlookRulesReader/Structures/Parameters/SendersListParameter.swift
similarity index 56%
rename from Sources/OutlookRulesReader/Structures/Rule Elements/JunkRuleElementData.swift
rename to Sources/OutlookRulesReader/Structures/Parameters/SendersListParameter.swift
index 26cb0a3..e0c1463 100644
--- a/Sources/OutlookRulesReader/Structures/Rule Elements/JunkRuleElementData.swift	
+++ b/Sources/OutlookRulesReader/Structures/Parameters/SendersListParameter.swift
@@ -1,5 +1,5 @@
 //
-//  SendersListRuleElementData.swift
+//  SendersListParameter.swift
 //
 //
 //  Created by Hugh Bellamy on 08/08/2020.
@@ -7,12 +7,11 @@
 
 import DataStream
 
-public struct SendersListRuleElementData: RuleElementData {
+public struct SendersListParameter: RuleParameter {
     public var dataSize: UInt32 {
-        return 8 + ASCIIString(value: name).dataSize
+        4 +  ASCIIString(value: name).dataSize
     }
 
-    public var extended: UInt32 = 1
     public var reserved: UInt32 = 0
     public var name: String
     
@@ -21,12 +20,6 @@ public struct SendersListRuleElementData: RuleElementData {
     }
     
     public init(dataStream: inout DataStream, version: OutlookRulesVersion) throws {
-        /// Extended (4 bytes)
-        self.extended = try dataStream.read(endianess: .littleEndian)
-        guard self.extended == 0x00000001 else {
-            throw OutlookRulesReadError.corrupted
-        }
-        
         /// Reserved (4 bytes)
         self.reserved = try dataStream.read(endianess: .littleEndian)
         
@@ -34,10 +27,7 @@ public struct SendersListRuleElementData: RuleElementData {
         self.name = try ASCIIString(dataStream: &dataStream).value
     }
     
-    public func write(to dataStream: inout OutputDataStream) {
-        /// Extended (4 bytes)
-        dataStream.write(extended, endianess: .littleEndian)
-        
+    public func write(to dataStream: inout OutputDataStream, version: OutlookRulesVersion) {
         /// Reserved (4 bytes)
         dataStream.write(reserved, endianess: .littleEndian)
         
diff --git a/Sources/OutlookRulesReader/Structures/Rule Elements/SensitivityRuleElementData.swift b/Sources/OutlookRulesReader/Structures/Parameters/SensitivityParameter.swift
similarity index 66%
rename from Sources/OutlookRulesReader/Structures/Rule Elements/SensitivityRuleElementData.swift
rename to Sources/OutlookRulesReader/Structures/Parameters/SensitivityParameter.swift
index 8c1f4a1..439b2b0 100644
--- a/Sources/OutlookRulesReader/Structures/Rule Elements/SensitivityRuleElementData.swift	
+++ b/Sources/OutlookRulesReader/Structures/Parameters/SensitivityParameter.swift
@@ -1,5 +1,5 @@
 //
-//  SensitivityRuleElementData.swift
+//  SensitivityParameter.swift
 //
 //
 //  Created by Hugh Bellamy on 28/07/2020.
@@ -8,10 +8,9 @@
 import DataStream
 import MAPI
 
-public struct SensitivityRuleElementData: RuleElementData {
+public struct SensitivityParameter: RuleParameter {
     public let dataSize: UInt32 = 12
 
-    public var extended: UInt32 = 1
     public var reserved: UInt32 = 0
     public var rawSensitivity: UInt32
 
@@ -28,12 +27,6 @@ public struct SensitivityRuleElementData: RuleElementData {
     }
     
     public init(dataStream: inout DataStream, version: OutlookRulesVersion) throws {
-        /// Extended (4 bytes)
-        self.extended = try dataStream.read(endianess: .littleEndian)
-        guard self.extended == 0x00000001 else {
-            throw OutlookRulesReadError.corrupted
-        }
-        
         /// Reserved (4 bytes)
         self.reserved = try dataStream.read(endianess: .littleEndian)
         
@@ -41,10 +34,7 @@ public struct SensitivityRuleElementData: RuleElementData {
         self.rawSensitivity = try dataStream.read(endianess: .littleEndian)
     }
     
-    public func write(to dataStream: inout OutputDataStream) {
-        /// Extended (4 bytes)
-        dataStream.write(extended, endianess: .littleEndian)
-        
+    public func write(to dataStream: inout OutputDataStream, version: OutlookRulesVersion) {
         /// Reserved (4 bytes)
         dataStream.write(reserved, endianess: .littleEndian)
 
diff --git a/Sources/OutlookRulesReader/Structures/Rule Elements/SizeInSpecificRangeRuleElementData.swift b/Sources/OutlookRulesReader/Structures/Parameters/SizeParameter.swift
similarity index 69%
rename from Sources/OutlookRulesReader/Structures/Rule Elements/SizeInSpecificRangeRuleElementData.swift
rename to Sources/OutlookRulesReader/Structures/Parameters/SizeParameter.swift
index 3403620..d49df46 100644
--- a/Sources/OutlookRulesReader/Structures/Rule Elements/SizeInSpecificRangeRuleElementData.swift	
+++ b/Sources/OutlookRulesReader/Structures/Parameters/SizeParameter.swift
@@ -1,5 +1,5 @@
 //
-//  SizeInSpecificRangeRuleElementData.swift
+//  SizeParameter.swift
 //
 //
 //  Created by Hugh Bellamy on 28/07/2020.
@@ -7,10 +7,9 @@
 
 import DataStream
 
-public struct SizeInSpecificRangeRuleElementData: RuleElementData {
+public struct SizeParameter: RuleParameter {
     public let dataSize: UInt32 = 12
 
-    public var extended: UInt32 = 1
     public var reserved: UInt32 = 0
     public var minSizeInKilobytes: UInt32
     public var maxSizeInKilobytes: UInt32
@@ -21,12 +20,6 @@ public struct SizeInSpecificRangeRuleElementData: RuleElementData {
     }
     
     public init(dataStream: inout DataStream, version: OutlookRulesVersion) throws {
-        /// Extended (4 bytes)
-        self.extended = try dataStream.read(endianess: .littleEndian)
-        guard self.extended == 0x00000001 else {
-            throw OutlookRulesReadError.corrupted
-        }
-        
         /// Reserved (4 bytes)
         self.reserved = try dataStream.read(endianess: .littleEndian)
         
@@ -37,10 +30,7 @@ public struct SizeInSpecificRangeRuleElementData: RuleElementData {
         self.maxSizeInKilobytes = try dataStream.read(endianess: .littleEndian)
     }
     
-    public func write(to dataStream: inout OutputDataStream) {
-        /// Extended (4 bytes)
-        dataStream.write(extended, endianess: .littleEndian)
-        
+    public func write(to dataStream: inout OutputDataStream, version: OutlookRulesVersion) {
         /// Reserved (4 bytes)
         dataStream.write(reserved, endianess: .littleEndian)
 
diff --git a/Sources/OutlookRulesReader/Structures/Objects/SearchEntry.swift b/Sources/OutlookRulesReader/Structures/Parameters/StringsListRuleElementData.swift
similarity index 76%
rename from Sources/OutlookRulesReader/Structures/Objects/SearchEntry.swift
rename to Sources/OutlookRulesReader/Structures/Parameters/StringsListRuleElementData.swift
index e600e1e..ec32c61 100644
--- a/Sources/OutlookRulesReader/Structures/Objects/SearchEntry.swift
+++ b/Sources/OutlookRulesReader/Structures/Parameters/StringsListRuleElementData.swift
@@ -1,15 +1,15 @@
 //
-//  SearchEntry.swift
+//  StringParameter.swift
 //  
 //
-//  Created by Hugh Bellamy on 03/02/2021.
+//  Created by Hugh Bellamy on 08/08/2020.
 //
 
 import DataStream
 
-internal struct SearchEntry {
+public struct StringParameter: RuleParameter {
     public var dataSize: UInt32 {
-        return 4 + UTF16String(value: value).dataSize
+        4 + UTF16String(value: value).dataSize
     }
     
     public var flags: UInt32 = 0
@@ -31,7 +31,7 @@ internal struct SearchEntry {
         }
     }
     
-    public func write(to dataStream: inout OutputDataStream) {
+    public func write(to dataStream: inout OutputDataStream, version: OutlookRulesVersion) {
         /// Flags (4 bytes)
         dataStream.write(flags, endianess: .littleEndian)
         
diff --git a/Sources/OutlookRulesReader/Structures/Rule Elements/AutomaticReplyRuleElementData.swift b/Sources/OutlookRulesReader/Structures/Parameters/TemplateParameter.swift
similarity index 69%
rename from Sources/OutlookRulesReader/Structures/Rule Elements/AutomaticReplyRuleElementData.swift
rename to Sources/OutlookRulesReader/Structures/Parameters/TemplateParameter.swift
index 7af4a44..2e10ad0 100644
--- a/Sources/OutlookRulesReader/Structures/Rule Elements/AutomaticReplyRuleElementData.swift	
+++ b/Sources/OutlookRulesReader/Structures/Parameters/TemplateParameter.swift
@@ -1,5 +1,5 @@
 //
-//  AutomaticReplyRuleElementData.swift
+//  TemplateParameter.swift
 //
 //
 //  Created by Hugh Bellamy on 29/07/2020.
@@ -8,15 +8,14 @@
 import DataStream
 import MAPI
 
-public struct AutomaticReplyRuleElementData: RuleElementData {
+public struct TemplateParameter: RuleParameter {
     public var dataSize: UInt32 {
-        var baseSize: UInt32 = 8
+        var baseSize: UInt32 = 4
         baseSize += UInt32(FlatEntry(entryID: messageEntryId).dataSize)
         baseSize += UTF16String(value: name).dataSize
         return baseSize
     }
 
-    public var extended: UInt32 = 1
     public var reserved: UInt32 = 0
     public var messageEntryId: EntryID
     public var name: String
@@ -27,12 +26,6 @@ public struct AutomaticReplyRuleElementData: RuleElementData {
     }
     
     public init(dataStream: inout DataStream, version: OutlookRulesVersion) throws {
-        /// Extended (4 bytes)
-        self.extended = try dataStream.read(endianess: .littleEndian)
-        guard self.extended == 0x00000001 else {
-            throw OutlookRulesReadError.corrupted
-        }
-        
         /// Reserved (4 bytes)
         self.reserved = try dataStream.read(endianess: .littleEndian)
 
@@ -43,10 +36,7 @@ public struct AutomaticReplyRuleElementData: RuleElementData {
         self.name = try UTF16String(dataStream: &dataStream).value
     }
     
-    public func write(to dataStream: inout OutputDataStream) {
-        /// Extended (4 bytes)
-        dataStream.write(extended, endianess: .littleEndian)
-        
+    public func write(to dataStream: inout OutputDataStream, version: OutlookRulesVersion) {
         /// Reserved (4 bytes)
         dataStream.write(reserved, endianess: .littleEndian)
         
diff --git a/Sources/OutlookRulesReader/Structures/Rule Elements/ReceivedInSpecificDateSpanRuleElementData.swift b/Sources/OutlookRulesReader/Structures/Parameters/TimeParameter.swift
similarity index 72%
rename from Sources/OutlookRulesReader/Structures/Rule Elements/ReceivedInSpecificDateSpanRuleElementData.swift
rename to Sources/OutlookRulesReader/Structures/Parameters/TimeParameter.swift
index 7ea7c95..b02996a 100644
--- a/Sources/OutlookRulesReader/Structures/Rule Elements/ReceivedInSpecificDateSpanRuleElementData.swift	
+++ b/Sources/OutlookRulesReader/Structures/Parameters/TimeParameter.swift
@@ -1,5 +1,5 @@
 //
-//  ReceivedInSpecificDateSpanRuleElementData.swift
+//  TimeParameter.swift
 //  
 //
 //  Created by Hugh Bellamy on 08/08/2020.
@@ -8,10 +8,9 @@
 import DataStream
 import Foundation
 
-public struct ReceivedInSpecificDateSpanRuleElementData: RuleElementData {
-    public let dataSize: UInt32 = 12
+public struct TimeParameter: RuleParameter {
+    public let dataSize: UInt32 = 40
 
-    public var extended: UInt32 = 1
     public var reserved: UInt32 = 0
     public var includeAfterDate: Bool
     public var afterDate: OleDateTime
@@ -19,12 +18,6 @@ public struct ReceivedInSpecificDateSpanRuleElementData: RuleElementData {
     public var beforeDate: OleDateTime
 
     public init(dataStream: inout DataStream, version: OutlookRulesVersion) throws {
-        /// Extended (4 bytes)
-        self.extended = try dataStream.read(endianess: .littleEndian)
-        guard self.extended == 0x00000001 else {
-            throw OutlookRulesReadError.corrupted
-        }
-
         /// Reserved (4 bytes)
         self.reserved = try dataStream.read(endianess: .littleEndian)
         
@@ -41,10 +34,7 @@ public struct ReceivedInSpecificDateSpanRuleElementData: RuleElementData {
         self.beforeDate = try OleDateTime(dataStream: &dataStream)
     }
     
-    public func write(to dataStream: inout OutputDataStream) {
-        /// Extended (4 bytes)
-        dataStream.write(extended, endianess: .littleEndian)
-        
+    public func write(to dataStream: inout OutputDataStream, version: OutlookRulesVersion) {
         /// Reserved (4 bytes)
         dataStream.write(reserved, endianess: .littleEndian)
         
@@ -59,7 +49,7 @@ public struct ReceivedInSpecificDateSpanRuleElementData: RuleElementData {
         let includeBeforeDateRaw: UInt32 = includeBeforeDate ? 0x00000001 : 0x00000000
         dataStream.write(includeBeforeDateRaw, endianess: .littleEndian)
         
-        /// Before Date (4 bytes)
+        /// Before Date (12 bytes)
         beforeDate.write(to: &dataStream)
     }
 }
diff --git a/Sources/OutlookRulesReader/Structures/Rule Elements/RuleElement0x64Data.swift b/Sources/OutlookRulesReader/Structures/Parameters/Unknown0x64Parameter.swift
similarity index 60%
rename from Sources/OutlookRulesReader/Structures/Rule Elements/RuleElement0x64Data.swift
rename to Sources/OutlookRulesReader/Structures/Parameters/Unknown0x64Parameter.swift
index fbdb64e..de23b82 100644
--- a/Sources/OutlookRulesReader/Structures/Rule Elements/RuleElement0x64Data.swift	
+++ b/Sources/OutlookRulesReader/Structures/Parameters/Unknown0x64Parameter.swift
@@ -1,5 +1,5 @@
 //
-//  RuleElement0x64Condition.swift
+//  Unknown0x64Parameter.swift
 //
 //
 //  Created by Hugh Bellamy on 28/07/2020.
@@ -7,10 +7,9 @@
 
 import DataStream
 
-internal struct RuleElement0x64Data: RuleElementData {
-    public let dataSize: UInt32 = 12
+internal struct Unknown0x64Parameter: RuleParameter {
+    public let dataSize: UInt32 = 8
 
-    public var extended: UInt32 = 1
     public var reserved: UInt32 = 0
     public var flags: UInt32 = 1
     
@@ -18,9 +17,6 @@ internal struct RuleElement0x64Data: RuleElementData {
     }
     
     public init(dataStream: inout DataStream, version: OutlookRulesVersion) throws {
-        /// Unknown1 (4 bytes)
-        self.extended = try dataStream.read(endianess: .littleEndian)
-        
         /// Unknown1 (4 bytes)
         self.reserved = try dataStream.read(endianess: .littleEndian)
         
@@ -28,10 +24,7 @@ internal struct RuleElement0x64Data: RuleElementData {
         self.flags = try dataStream.read(endianess: .littleEndian)
     }
     
-    public func write(to dataStream: inout OutputDataStream) {
-        /// Extended (4 bytes)
-        dataStream.write(extended, endianess: .littleEndian)
-        
+    public func write(to dataStream: inout OutputDataStream, version: OutlookRulesVersion) {
         /// Reservd (4 bytes)
         dataStream.write(reserved, endianess: .littleEndian)
         
diff --git a/Sources/OutlookRulesReader/Structures/Rule Elements/AddToRelevanceRuleElementData.swift b/Sources/OutlookRulesReader/Structures/Rule Elements/AddToRelevanceRuleElementData.swift
deleted file mode 100644
index c6d49e4..0000000
--- a/Sources/OutlookRulesReader/Structures/Rule Elements/AddToRelevanceRuleElementData.swift	
+++ /dev/null
@@ -1,41 +0,0 @@
-//
-//  AddToRelevanceRuleElementData.swift
-//
-//
-//  Created by Hugh Bellamy on 28/07/2020.
-//
-
-import DataStream
-
-internal struct AddToRelevanceRuleElementData: RuleElementData {
-    public let dataSize: UInt32 = 12
-
-    public var extended: UInt32 = 1
-    public var reserved: UInt32 = 0
-    public var number: UInt32 = 1
-    
-    public init() {
-    }
-    
-    public init(dataStream: inout DataStream, version: OutlookRulesVersion) throws {
-        /// Extended (4 bytes)
-        self.extended = try dataStream.read(endianess: .littleEndian)
-        
-        /// Reserved (4 bytes)
-        self.reserved = try dataStream.read(endianess: .littleEndian)
-        
-        /// Number (4 bytes)
-        self.number = try dataStream.read(endianess: .littleEndian)
-    }
-    
-    public func write(to dataStream: inout OutputDataStream) {
-        /// Extended (4 bytes)
-        dataStream.write(extended, endianess: .littleEndian)
-        
-        /// Reserved (4 bytes)
-        dataStream.write(reserved, endianess: .littleEndian)
-        
-        /// Number (4 bytes)
-        dataStream.write(number, endianess: .littleEndian)
-    }
-}
diff --git a/Sources/OutlookRulesReader/Structures/Rule Elements/ApplyConditionRuleElementData.swift b/Sources/OutlookRulesReader/Structures/Rule Elements/ApplyConditionRuleElementData.swift
deleted file mode 100644
index 04615a1..0000000
--- a/Sources/OutlookRulesReader/Structures/Rule Elements/ApplyConditionRuleElementData.swift	
+++ /dev/null
@@ -1,57 +0,0 @@
-//
-//  ApplyCondition.swift
-//  
-//
-//  Created by Hugh Bellamy on 28/07/2020.
-//
-
-import DataStream
-
-public struct ApplyConditionFlags: OptionSet {
-    public let rawValue: UInt32
-    
-    public init(rawValue: UInt32) {
-        self.rawValue = rawValue
-    }
-    
-    public static let afterReceived = ApplyConditionFlags(rawValue: 0x01)
-    public static let afterSent = ApplyConditionFlags(rawValue: 0x04)
-    public static let afterServerReceived = ApplyConditionFlags(rawValue: 0x08)
-}
-
-public struct ApplyConditionRuleElementData: RuleElementData {
-    public let dataSize: UInt32 = 12
-
-    public var extended: UInt32 = 1
-    public var reserved: UInt32 = 0
-    public let flags: ApplyConditionFlags
-    
-    public init(flags: ApplyConditionFlags) {
-        self.flags = flags
-    }
-    
-    public init(dataStream: inout DataStream, version: OutlookRulesVersion) throws {
-        /// Extended (4 bytes)
-        self.extended = try dataStream.read(endianess: .littleEndian)
-        guard self.extended == 0x00000001 else {
-            throw OutlookRulesReadError.corrupted
-        }
-        
-        /// Reserved (4 bytes)
-        self.reserved = try dataStream.read(endianess: .littleEndian)
-        
-        /// Flags (4 bytes)
-        self.flags = ApplyConditionFlags(rawValue: try dataStream.read(endianess: .littleEndian))
-    }
-    
-    public func write(to dataStream: inout OutputDataStream) {
-        /// Extended (4 bytes)
-        dataStream.write(extended, endianess: .littleEndian)
-        
-        /// Reserved (4 bytes)
-        dataStream.write(reserved, endianess: .littleEndian)
-        
-        /// Flags (4 bytes)
-        dataStream.write(flags.rawValue, endianess: .littleEndian)
-    }
-}
diff --git a/Sources/OutlookRulesReader/Structures/Rule Elements/FormTypeRuleElementData.swift b/Sources/OutlookRulesReader/Structures/Rule Elements/FormTypeRuleElementData.swift
deleted file mode 100644
index 06b1ea7..0000000
--- a/Sources/OutlookRulesReader/Structures/Rule Elements/FormTypeRuleElementData.swift	
+++ /dev/null
@@ -1,52 +0,0 @@
-//
-//  UsesFormRuleElementData.swift
-//
-//
-//  Created by Hugh Bellamy on 29/07/2020.
-//
-
-import DataStream
-
-public struct FormTypeRuleElementData: RuleElementData {
-    public var dataSize: UInt32 {
-        var baseSize: UInt32 = 4
-        for form in forms {
-            baseSize += form.dataSize
-        }
-        
-        return baseSize
-    }
-    
-    public var numberOfForms: UInt32 = 0
-    public var forms: [Form]
-    
-    public init(forms: [Form]) {
-        self.numberOfForms = UInt32(forms.count)
-        self.forms = forms
-    }
-    
-    public init(dataStream: inout DataStream, version: OutlookRulesVersion) throws {
-        /// Number of Forms (4 bytes)
-        self.numberOfForms = try dataStream.read(endianess: .littleEndian)
-        
-        /// Forms (variable)
-        var forms: [Form] = []
-        forms.reserveCapacity(Int(self.numberOfForms))
-        for _ in 0..<self.numberOfForms {
-            let form = try Form(dataStream: &dataStream, version: version)
-            forms.append(form)
-        }
-        
-        self.forms = forms
-    }
-    
-    public func write(to dataStream: inout OutputDataStream) {
-        /// Number of Forms (4 bytes)
-        dataStream.write(numberOfForms, endianess: .littleEndian)
-        
-        /// Forms (variable)
-        for form in forms {
-            form.write(to: &dataStream)
-        }
-    }
-}
diff --git a/Sources/OutlookRulesReader/Structures/Rule Elements/SimpleRuleElementData.swift b/Sources/OutlookRulesReader/Structures/Rule Elements/SimpleRuleElementData.swift
deleted file mode 100644
index 8c44f1c..0000000
--- a/Sources/OutlookRulesReader/Structures/Rule Elements/SimpleRuleElementData.swift	
+++ /dev/null
@@ -1,33 +0,0 @@
-//
-//  SimpleRuleElementData.swift
-//  
-//
-//  Created by Hugh Bellamy on 08/08/2020.
-//
-
-import DataStream
-
-public struct SimpleRuleElementData: RuleElementData {
-    public var dataSize: UInt32 {
-        return 4
-    }
-
-    public var extended: UInt32
-    
-    public init() {
-        self.extended = 0
-    }
-    
-    public init(dataStream: inout DataStream, version: OutlookRulesVersion) throws {
-        /// Extended (4 bytes)
-        self.extended = try dataStream.read(endianess: .littleEndian)
-        guard self.extended == 0x00000000 else {
-            throw OutlookRulesReadError.corrupted
-        }
-    }
-    
-    public func write(to dataStream: inout OutputDataStream) {
-        /// Extended (4 bytes)
-        dataStream.write(extended, endianess: .littleEndian)
-    }
-}
diff --git a/Sources/OutlookRulesReader/Structures/Rule Elements/StringsListRuleElementData.swift b/Sources/OutlookRulesReader/Structures/Rule Elements/StringsListRuleElementData.swift
deleted file mode 100644
index b001dfd..0000000
--- a/Sources/OutlookRulesReader/Structures/Rule Elements/StringsListRuleElementData.swift	
+++ /dev/null
@@ -1,50 +0,0 @@
-//
-//  StringsListRuleElementData.swift
-//  
-//
-//  Created by Hugh Bellamy on 08/08/2020.
-//
-
-import DataStream
-
-public struct StringsListRuleElementData: RuleElementData {
-    public var dataSize: UInt32 {
-        var baseSize: UInt32 = 4
-        for entry in entries {
-            baseSize += UTF16String(value: entry).dataSize
-        }
-        
-        return baseSize
-    }
-    
-    public var entries: [String]
-    
-    public init(entries: [String]) {
-        self.entries = entries
-    }
-    
-    public init(dataStream: inout DataStream, version: OutlookRulesVersion) throws {
-        /// Number of entries (4 bytes)
-        let numberOfEntries: UInt32 = try dataStream.read(endianess: .littleEndian)
-        
-        /// Entries (variable)
-        var entries: [String] = []
-        entries.reserveCapacity(Int(numberOfEntries))
-        for _ in 0..<numberOfEntries {
-            let entry = try SearchEntry(dataStream: &dataStream, version: version)
-            entries.append(entry.value)
-        }
-        
-        self.entries = entries
-    }
-
-    public func write(to dataStream: inout OutputDataStream) {
-        /// Number of entries (4 bytes)
-        dataStream.write(UInt32(entries.count), endianess: .littleEndian)
-        
-        /// Entries (variable)
-        for entry in entries {
-            SearchEntry(value: entry).write(to: &dataStream)
-        }
-    }
-}
diff --git a/Tests/OutlookRulesReaderTests/DumpFileTests.swift b/Tests/OutlookRulesReaderTests/DumpFileTests.swift
index fc427b6..ec697dd 100644
--- a/Tests/OutlookRulesReaderTests/DumpFileTests.swift
+++ b/Tests/OutlookRulesReaderTests/DumpFileTests.swift
@@ -606,7 +606,7 @@ final class DumpFileTests: XCTestCase {
         
         for (name, fileExtension) in files {
             let data = try getData(name: name, fileExtension: fileExtension)
-            let rules = try OutlookRulesFile(data: data)
+            let rules = try OutlookRules(data: data)
             print(rules)
         }
     }
diff --git a/Tests/OutlookRulesReaderTests/Export/ExportTests.swift b/Tests/OutlookRulesReaderTests/Export/ExportTests.swift
index 9fdf4d0..e87b695 100644
--- a/Tests/OutlookRulesReaderTests/Export/ExportTests.swift
+++ b/Tests/OutlookRulesReaderTests/Export/ExportTests.swift
@@ -3,7 +3,7 @@ import XCTest
 
 final class ExportTests: XCTestCase {
     func testEmpty() {
-        let file = OutlookRulesFile(rules: [])
+        let file = OutlookRules(rules: [])
         let expected: [UInt8] = [
             0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x14, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
             0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
@@ -15,8 +15,8 @@ final class ExportTests: XCTestCase {
     }
 
     func testEmptyRule() {
-        let file = OutlookRulesFile(rules: [
-            Rule(applyCondition: .afterReceived, name: "RULENAME")
+        let file = OutlookRules(rules: [
+            Rule(eventFlags: .afterReceived, name: "RULENAME")
         ])
         let expected: [UInt8] = [
             0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x14, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
@@ -31,13 +31,14 @@ final class ExportTests: XCTestCase {
             0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
             0x00, 0x00, 0x00, 0x00, 0x00
         ]
+        try! OutlookRules(data: Data(expected))
         XCTAssertEqual(expected, [UInt8](file.getData() as NSData))
     }
     
     func testSentOnlyToMe() {
-        let file = OutlookRulesFile(rules: [
-            Rule(applyCondition: .afterReceived, name: "RULENAME", conditions: [
-                RuleElement(identifier: .sentOnlyToMeCondition, data: SimpleRuleElementData())
+        let file = OutlookRules(rules: [
+            Rule(eventFlags: .afterReceived, name: "RULENAME", conditions: [
+                RuleElement(identifier: .sentOnlyToMeCondition)
             ])
         ])
         let expected: [UInt8] = [
@@ -57,9 +58,9 @@ final class ExportTests: XCTestCase {
     }
 
     func testHasAttachment() {
-        let file = OutlookRulesFile(rules: [
-            Rule(applyCondition: .afterReceived, name: "RULENAME", conditions: [
-                RuleElement(identifier: .hasAttachmentCondition, data: SimpleRuleElementData())
+        let file = OutlookRules(rules: [
+            Rule(eventFlags: .afterReceived, name: "RULENAME", conditions: [
+                RuleElement(identifier: .hasAttachmentCondition)
             ])
         ])
         let expected: [UInt8] = [
diff --git a/Tests/OutlookRulesReaderTests/Import/ImportActionTests.swift b/Tests/OutlookRulesReaderTests/Import/ImportActionTests.swift
index 5047609..4c3bff6 100644
--- a/Tests/OutlookRulesReaderTests/Import/ImportActionTests.swift
+++ b/Tests/OutlookRulesReaderTests/Import/ImportActionTests.swift
@@ -6,7 +6,7 @@ import WindowsDataTypes
 final class ImportActionTests: XCTestCase {
     func testMoveToFolderAction() throws {
         do {
-            let file = try OutlookRulesFile(data: Data([
+            let file = try OutlookRules(data: Data([
                 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x14, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
@@ -41,17 +41,17 @@ final class ImportActionTests: XCTestCase {
             XCTAssertEqual(0, file.rules[0].conditions.count)
             XCTAssertEqual(1, file.rules[0].actions.count)
             XCTAssertEqual(.moveToFolderAction, file.rules[0].actions[0].identifier)
-            XCTAssertTrue(file.rules[0].actions[0].data is MoveToFolderRuleElementData)
+            XCTAssertTrue(file.rules[0].actions[0].parameter is FolderParameter)
             XCTAssertEqual(0, file.rules[0].exceptions.count)
 
-            let action = file.rules[0].actions[0].data as! MoveToFolderRuleElementData
+            let action = file.rules[0].actions[0].parameter as! FolderParameter
             XCTAssertEqual("Inbox", action.folderName)
         }
     }
 
     func testAssignToCategoryAction() throws {
         do {
-            let file = try OutlookRulesFile(data: Data([
+            let file = try OutlookRules(data: Data([
                 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x14, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
@@ -70,14 +70,14 @@ final class ImportActionTests: XCTestCase {
             XCTAssertEqual(0, file.rules[0].conditions.count)
             XCTAssertEqual(1, file.rules[0].actions.count)
             XCTAssertEqual(.assignToCategoryAction, file.rules[0].actions[0].identifier)
-            XCTAssertTrue(file.rules[0].actions[0].data is CategoriesListRuleElementData)
+            XCTAssertTrue(file.rules[0].actions[0].parameter is CategoryParameter)
             XCTAssertEqual(0, file.rules[0].exceptions.count)
 
-            let action = file.rules[0].actions[0].data as! CategoriesListRuleElementData
+            let action = file.rules[0].actions[0].parameter as! CategoryParameter
             XCTAssertEqual(["Blue Category"], action.categories)
         }
         do {
-            let file = try OutlookRulesFile(data: Data([
+            let file = try OutlookRules(data: Data([
                 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x14, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
@@ -98,17 +98,17 @@ final class ImportActionTests: XCTestCase {
             XCTAssertEqual(0, file.rules[0].conditions.count)
             XCTAssertEqual(1, file.rules[0].actions.count)
             XCTAssertEqual(.assignToCategoryAction, file.rules[0].actions[0].identifier)
-            XCTAssertTrue(file.rules[0].actions[0].data is CategoriesListRuleElementData)
+            XCTAssertTrue(file.rules[0].actions[0].parameter is CategoryParameter)
             XCTAssertEqual(0, file.rules[0].exceptions.count)
 
-            let action = file.rules[0].actions[0].data as! CategoriesListRuleElementData
+            let action = file.rules[0].actions[0].parameter as! CategoryParameter
             XCTAssertEqual(["Blue Category", "Green Category"], action.categories)
         }
     }
 
     func testDeleteAction() throws {
         do {
-            let file = try OutlookRulesFile(data: Data([
+            let file = try OutlookRules(data: Data([
                 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x14, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
@@ -125,14 +125,14 @@ final class ImportActionTests: XCTestCase {
             XCTAssertEqual(0, file.rules[0].conditions.count)
             XCTAssertEqual(1, file.rules[0].actions.count)
             XCTAssertEqual(.deleteAction, file.rules[0].actions[0].identifier)
-            XCTAssertTrue(file.rules[0].actions[0].data is SimpleRuleElementData)
+            XCTAssertEqual(0, file.rules[0].actions[0].parameters.count)
             XCTAssertEqual(0, file.rules[0].exceptions.count)
         }
     }
 
     func testPermanentlyDeleteAction() throws {
         do {
-            let file = try OutlookRulesFile(data: Data([
+            let file = try OutlookRules(data: Data([
                 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x14, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
@@ -150,16 +150,16 @@ final class ImportActionTests: XCTestCase {
             XCTAssertEqual(0, file.rules[0].conditions.count)
             XCTAssertEqual(2, file.rules[0].actions.count)
             XCTAssertEqual(.permanentlyDeleteAction, file.rules[0].actions[0].identifier)
-            XCTAssertTrue(file.rules[0].actions[0].data is SimpleRuleElementData)
+            XCTAssertEqual(0, file.rules[0].actions[0].parameters.count)
             XCTAssertEqual(0, file.rules[0].exceptions.count)
             XCTAssertEqual(.stopProcessingMoreRulesAction, file.rules[0].actions[1].identifier)
-            XCTAssertTrue(file.rules[0].actions[1].data is SimpleRuleElementData)
+            XCTAssertEqual(0, file.rules[0].actions[1].parameters.count)
         }
     }
     
     func testMoveCopyToFolderAction() throws {
         do {
-            let file = try OutlookRulesFile(data: Data([
+            let file = try OutlookRules(data: Data([
                 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x14, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
@@ -194,17 +194,17 @@ final class ImportActionTests: XCTestCase {
             XCTAssertEqual(0, file.rules[0].conditions.count)
             XCTAssertEqual(1, file.rules[0].actions.count)
             XCTAssertEqual(.moveCopyToFolderAction, file.rules[0].actions[0].identifier)
-            XCTAssertTrue(file.rules[0].actions[0].data is MoveToFolderRuleElementData)
+            XCTAssertTrue(file.rules[0].actions[0].parameter is FolderParameter)
             XCTAssertEqual(0, file.rules[0].exceptions.count)
 
-            let action = file.rules[0].actions[0].data as! MoveToFolderRuleElementData
+            let action = file.rules[0].actions[0].parameter as! FolderParameter
             XCTAssertEqual("Inbox", action.folderName)
         }
     }
     
     func testFlagAction() throws {
         do {
-            let file = try OutlookRulesFile(data: Data([
+            let file = try OutlookRules(data: Data([
                 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x14, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
@@ -230,15 +230,15 @@ final class ImportActionTests: XCTestCase {
             XCTAssertEqual(0, file.rules[0].conditions.count)
             XCTAssertEqual(1, file.rules[0].actions.count)
             XCTAssertEqual(.flagAction, file.rules[0].actions[0].identifier)
-            XCTAssertTrue(file.rules[0].actions[0].data is FlagRuleElementData)
+            XCTAssertTrue(file.rules[0].actions[0].parameter is FlagRuleElementData)
             XCTAssertEqual(0, file.rules[0].exceptions.count)
 
-            let action = file.rules[0].actions[0].data as! FlagRuleElementData
+            let action = file.rules[0].actions[0].parameter as! FlagRuleElementData
             XCTAssertEqual("Action", action.actionName)
             XCTAssertEqual(365, action.days)
         }
         do {
-            let file = try OutlookRulesFile(data: Data([
+            let file = try OutlookRules(data: Data([
                 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x14, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
@@ -264,10 +264,10 @@ final class ImportActionTests: XCTestCase {
             XCTAssertEqual(0, file.rules[0].conditions.count)
             XCTAssertEqual(1, file.rules[0].actions.count)
             XCTAssertEqual(.flagAction, file.rules[0].actions[0].identifier)
-            XCTAssertTrue(file.rules[0].actions[0].data is FlagRuleElementData)
+            XCTAssertTrue(file.rules[0].actions[0].parameter is FlagRuleElementData)
             XCTAssertEqual(0, file.rules[0].exceptions.count)
 
-            let action = file.rules[0].actions[0].data as! FlagRuleElementData
+            let action = file.rules[0].actions[0].parameter as! FlagRuleElementData
             XCTAssertEqual("Action", action.actionName)
             XCTAssertEqual(0, action.days)
         }
@@ -275,7 +275,7 @@ final class ImportActionTests: XCTestCase {
     
     func testForwardAction() throws {
         do {
-            let file = try OutlookRulesFile(data: Data([
+            let file = try OutlookRules(data: Data([
                 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x14, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
@@ -301,10 +301,10 @@ final class ImportActionTests: XCTestCase {
             XCTAssertEqual(0, file.rules[0].conditions.count)
             XCTAssertEqual(1, file.rules[0].actions.count)
             XCTAssertEqual(.forwardAction, file.rules[0].actions[0].identifier)
-            XCTAssertTrue(file.rules[0].actions[0].data is PeopleOrPublicGroupListRuleElementData)
+            XCTAssertTrue(file.rules[0].actions[0].parameter is AddressParameter)
             XCTAssertEqual(0, file.rules[0].exceptions.count)
 
-            let action = file.rules[0].actions[0].data as! PeopleOrPublicGroupListRuleElementData
+            let action = file.rules[0].actions[0].parameter as! AddressParameter
             XCTAssertEqual(1, action.values.count)
             XCTAssertEqual(6, action.values[0].count)
             XCTAssertEqual(MAPI_E.NOT_FOUND.rawValue, action.values[0][PropertyId.tagSmtpAddress.rawValue] as! UInt32)
@@ -315,7 +315,7 @@ final class ImportActionTests: XCTestCase {
             XCTAssertEqual(1, action.values[0][PropertyId.tagRecipientType.rawValue] as! UInt32)
         }
         do {
-            let file = try OutlookRulesFile(data: Data([
+            let file = try OutlookRules(data: Data([
                 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x14, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
@@ -384,10 +384,10 @@ final class ImportActionTests: XCTestCase {
             XCTAssertEqual(0, file.rules[0].conditions.count)
             XCTAssertEqual(1, file.rules[0].actions.count)
             XCTAssertEqual(.forwardAction, file.rules[0].actions[0].identifier)
-            XCTAssertTrue(file.rules[0].actions[0].data is PeopleOrPublicGroupListRuleElementData)
+            XCTAssertTrue(file.rules[0].actions[0].parameter is AddressParameter)
             XCTAssertEqual(0, file.rules[0].exceptions.count)
 
-            let action = file.rules[0].actions[0].data as! PeopleOrPublicGroupListRuleElementData
+            let action = file.rules[0].actions[0].parameter as! AddressParameter
             XCTAssertEqual(2, action.values.count)
             XCTAssertEqual(11, action.values[0].count)
             XCTAssertEqual(MAPI_E.NOT_FOUND.rawValue, action.values[0][PropertyId.tagSmtpAddress.rawValue] as! UInt32)
@@ -409,7 +409,7 @@ final class ImportActionTests: XCTestCase {
     
     func testAutomaticReplyAction() throws {
         do {
-            let file = try OutlookRulesFile(data: Data([
+            let file = try OutlookRules(data: Data([
                 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x14, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
@@ -440,10 +440,10 @@ final class ImportActionTests: XCTestCase {
             XCTAssertEqual(0, file.rules[0].conditions.count)
             XCTAssertEqual(1, file.rules[0].actions.count)
             XCTAssertEqual(.automaticReply, file.rules[0].actions[0].identifier)
-            XCTAssertTrue(file.rules[0].actions[0].data is AutomaticReplyRuleElementData)
+            XCTAssertTrue(file.rules[0].actions[0].parameter is TemplateParameter)
             XCTAssertEqual(0, file.rules[0].exceptions.count)
 
-            let action = file.rules[0].actions[0].data as! AutomaticReplyRuleElementData
+            let action = file.rules[0].actions[0].parameter as! TemplateParameter
             XCTAssertEqual(.privateMessage, (action.messageEntryId as! MessageEntryID).messageType)
             XCTAssertEqual("[No Subject]", action.name)
         }
@@ -451,7 +451,7 @@ final class ImportActionTests: XCTestCase {
     
     func testRedirectAction() throws {
         do {
-            let file = try OutlookRulesFile(data: Data([
+            let file = try OutlookRules(data: Data([
                 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x14, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
@@ -483,10 +483,10 @@ final class ImportActionTests: XCTestCase {
             XCTAssertEqual(0, file.rules[0].conditions.count)
             XCTAssertEqual(1, file.rules[0].actions.count)
             XCTAssertEqual(.redirectAction, file.rules[0].actions[0].identifier)
-            XCTAssertTrue(file.rules[0].actions[0].data is PeopleOrPublicGroupListRuleElementData)
+            XCTAssertTrue(file.rules[0].actions[0].parameter is AddressParameter)
             XCTAssertEqual(0, file.rules[0].exceptions.count)
 
-            let action = file.rules[0].actions[0].data as! PeopleOrPublicGroupListRuleElementData
+            let action = file.rules[0].actions[0].parameter as! AddressParameter
             XCTAssertEqual(1, action.values.count)
             XCTAssertEqual(6, action.values[0].count)
             XCTAssertEqual(MAPI_E.NOT_FOUND.rawValue, action.values[0][PropertyId.tagSmtpAddress.rawValue] as! UInt32)
@@ -497,7 +497,7 @@ final class ImportActionTests: XCTestCase {
             XCTAssertEqual(1, action.values[0][PropertyId.tagRecipientType.rawValue] as! UInt32)
         }
         do {
-            let file = try OutlookRulesFile(data: Data([
+            let file = try OutlookRules(data: Data([
                 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x14, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
@@ -572,10 +572,10 @@ final class ImportActionTests: XCTestCase {
             XCTAssertEqual(0, file.rules[0].conditions.count)
             XCTAssertEqual(1, file.rules[0].actions.count)
             XCTAssertEqual(.redirectAction, file.rules[0].actions[0].identifier)
-            XCTAssertTrue(file.rules[0].actions[0].data is PeopleOrPublicGroupListRuleElementData)
+            XCTAssertTrue(file.rules[0].actions[0].parameter is AddressParameter)
             XCTAssertEqual(0, file.rules[0].exceptions.count)
 
-            let action = file.rules[0].actions[0].data as! PeopleOrPublicGroupListRuleElementData
+            let action = file.rules[0].actions[0].parameter as! AddressParameter
             XCTAssertEqual(2, action.values.count)
             XCTAssertEqual(11, action.values[0].count)
             XCTAssertEqual(MAPI_E.NOT_FOUND.rawValue, action.values[0][PropertyId.tagSmtpAddress.rawValue] as! UInt32)
@@ -597,7 +597,7 @@ final class ImportActionTests: XCTestCase {
     
     func testAddToRelevanceAction() throws {
         do {
-            let file = try OutlookRulesFile(data: Data([
+            let file = try OutlookRules(data: Data([
                 0x80, 0x4f, 0x12, 0x00, 0x80, 0x4f, 0x12, 0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x80, 0x4f,
@@ -614,14 +614,14 @@ final class ImportActionTests: XCTestCase {
             XCTAssertEqual(0, file.rules[0].conditions.count)
             XCTAssertEqual(1, file.rules[0].actions.count)
             XCTAssertEqual(.addToRelevanceAction, file.rules[0].actions[0].identifier)
-            XCTAssertTrue(file.rules[0].actions[0].data is AddToRelevanceRuleElementData)
+            XCTAssertTrue(file.rules[0].actions[0].parameter is RelevanceParameter)
             XCTAssertEqual(0, file.rules[0].exceptions.count)
 
-            let action = file.rules[0].actions[0].data as! AddToRelevanceRuleElementData
-            XCTAssertEqual(1, action.number)
+            let action = file.rules[0].actions[0].parameter as! RelevanceParameter
+            XCTAssertEqual(1, action.value)
         }
         do {
-            let file = try OutlookRulesFile(data: Data([
+            let file = try OutlookRules(data: Data([
                 0x80, 0x4f, 0x12, 0x00, 0x80, 0x4f, 0x12, 0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x80, 0x4f,
@@ -638,17 +638,17 @@ final class ImportActionTests: XCTestCase {
             XCTAssertEqual(0, file.rules[0].conditions.count)
             XCTAssertEqual(1, file.rules[0].actions.count)
             XCTAssertEqual(.addToRelevanceAction, file.rules[0].actions[0].identifier)
-            XCTAssertTrue(file.rules[0].actions[0].data is AddToRelevanceRuleElementData)
+            XCTAssertTrue(file.rules[0].actions[0].parameter is RelevanceParameter)
             XCTAssertEqual(0, file.rules[0].exceptions.count)
 
-            let action = file.rules[0].actions[0].data as! AddToRelevanceRuleElementData
-            XCTAssertEqual(4294967295, action.number)
+            let action = file.rules[0].actions[0].parameter as! RelevanceParameter
+            XCTAssertEqual(4294967295, action.value)
         }
     }
     
     func testForwardAsAttachmentAction() throws {
         do {
-            let file = try OutlookRulesFile(data: Data([
+            let file = try OutlookRules(data: Data([
                 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x14, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
@@ -674,10 +674,10 @@ final class ImportActionTests: XCTestCase {
             XCTAssertEqual(0, file.rules[0].conditions.count)
             XCTAssertEqual(1, file.rules[0].actions.count)
             XCTAssertEqual(.forwardAsAttachmentAction, file.rules[0].actions[0].identifier)
-            XCTAssertTrue(file.rules[0].actions[0].data is PeopleOrPublicGroupListRuleElementData)
+            XCTAssertTrue(file.rules[0].actions[0].parameter is AddressParameter)
             XCTAssertEqual(0, file.rules[0].exceptions.count)
 
-            let action = file.rules[0].actions[0].data as! PeopleOrPublicGroupListRuleElementData
+            let action = file.rules[0].actions[0].parameter as! AddressParameter
             XCTAssertEqual(1, action.values.count)
             XCTAssertEqual(6, action.values[0].count)
             XCTAssertEqual(MAPI_E.NOT_FOUND.rawValue, action.values[0][PropertyId.tagSmtpAddress.rawValue] as! UInt32)
@@ -688,7 +688,7 @@ final class ImportActionTests: XCTestCase {
             XCTAssertEqual(1, action.values[0][PropertyId.tagRecipientType.rawValue] as! UInt32)
         }
         do {
-            let file = try OutlookRulesFile(data: Data([
+            let file = try OutlookRules(data: Data([
                 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x14, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
@@ -757,10 +757,10 @@ final class ImportActionTests: XCTestCase {
             XCTAssertEqual(0, file.rules[0].conditions.count)
             XCTAssertEqual(1, file.rules[0].actions.count)
             XCTAssertEqual(.forwardAsAttachmentAction, file.rules[0].actions[0].identifier)
-            XCTAssertTrue(file.rules[0].actions[0].data is PeopleOrPublicGroupListRuleElementData)
+            XCTAssertTrue(file.rules[0].actions[0].parameter is AddressParameter)
             XCTAssertEqual(0, file.rules[0].exceptions.count)
 
-            let action = file.rules[0].actions[0].data as! PeopleOrPublicGroupListRuleElementData
+            let action = file.rules[0].actions[0].parameter as! AddressParameter
             XCTAssertEqual(2, action.values.count)
             XCTAssertEqual(11, action.values[0].count)
             XCTAssertEqual(MAPI_E.NOT_FOUND.rawValue, action.values[0][PropertyId.tagSmtpAddress.rawValue] as! UInt32)
@@ -782,7 +782,7 @@ final class ImportActionTests: XCTestCase {
 
     func testReplyUsingTemplateAction() throws {
         do {
-            let file = try OutlookRulesFile(data: Data([
+            let file = try OutlookRules(data: Data([
                 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x14, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
@@ -814,17 +814,17 @@ final class ImportActionTests: XCTestCase {
             XCTAssertEqual(0, file.rules[0].conditions.count)
             XCTAssertEqual(1, file.rules[0].actions.count)
             XCTAssertEqual(.replyUsingTemplateAction, file.rules[0].actions[0].identifier)
-            XCTAssertTrue(file.rules[0].actions[0].data is PathRuleElementData)
+            XCTAssertTrue(file.rules[0].actions[0].parameter is PathParameter)
             XCTAssertEqual(0, file.rules[0].exceptions.count)
 
-            let action = file.rules[0].actions[0].data as! PathRuleElementData
+            let action = file.rules[0].actions[0].parameter as! PathParameter
             XCTAssertEqual("C:\\Program Files\\Microsoft Office\\root\\Templates\\1033\\mail.oft", action.path)
         }
     }
 
     func testFlagForFollowUpAction() throws {
         do {
-            let file = try OutlookRulesFile(data: Data([
+            let file = try OutlookRules(data: Data([
                 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x14, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
@@ -850,15 +850,15 @@ final class ImportActionTests: XCTestCase {
             XCTAssertEqual(0, file.rules[0].conditions.count)
             XCTAssertEqual(1, file.rules[0].actions.count)
             XCTAssertEqual(.flagForFollowUpAction, file.rules[0].actions[0].identifier)
-            XCTAssertTrue(file.rules[0].actions[0].data is FlagForFollowUpRuleElementData)
+            XCTAssertTrue(file.rules[0].actions[0].parameter is FlagForFollowUpParameter)
             XCTAssertEqual(0, file.rules[0].exceptions.count)
 
-            let action = file.rules[0].actions[0].data as! FlagForFollowUpRuleElementData
+            let action = file.rules[0].actions[0].parameter as! FlagForFollowUpParameter
             XCTAssertEqual("Follow up", action.actionName)
             XCTAssertEqual(.today, action.followUp)
         }
         do {
-            let file = try OutlookRulesFile(data: Data([
+            let file = try OutlookRules(data: Data([
                 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x14, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
@@ -884,15 +884,15 @@ final class ImportActionTests: XCTestCase {
             XCTAssertEqual(0, file.rules[0].conditions.count)
             XCTAssertEqual(1, file.rules[0].actions.count)
             XCTAssertEqual(.flagForFollowUpAction, file.rules[0].actions[0].identifier)
-            XCTAssertTrue(file.rules[0].actions[0].data is FlagForFollowUpRuleElementData)
+            XCTAssertTrue(file.rules[0].actions[0].parameter is FlagForFollowUpParameter)
             XCTAssertEqual(0, file.rules[0].exceptions.count)
 
-            let action = file.rules[0].actions[0].data as! FlagForFollowUpRuleElementData
+            let action = file.rules[0].actions[0].parameter as! FlagForFollowUpParameter
             XCTAssertEqual("Follow up", action.actionName)
             XCTAssertEqual(.tomorrow, action.followUp)
         }
         do {
-            let file = try OutlookRulesFile(data: Data([
+            let file = try OutlookRules(data: Data([
                 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x14, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
@@ -919,15 +919,15 @@ final class ImportActionTests: XCTestCase {
             XCTAssertEqual(0, file.rules[0].conditions.count)
             XCTAssertEqual(1, file.rules[0].actions.count)
             XCTAssertEqual(.flagForFollowUpAction, file.rules[0].actions[0].identifier)
-            XCTAssertTrue(file.rules[0].actions[0].data is FlagForFollowUpRuleElementData)
+            XCTAssertTrue(file.rules[0].actions[0].parameter is FlagForFollowUpParameter)
             XCTAssertEqual(0, file.rules[0].exceptions.count)
 
-            let action = file.rules[0].actions[0].data as! FlagForFollowUpRuleElementData
+            let action = file.rules[0].actions[0].parameter as! FlagForFollowUpParameter
             XCTAssertEqual("For Your Information", action.actionName)
             XCTAssertEqual(.thisWeek, action.followUp)
         }
         do {
-            let file = try OutlookRulesFile(data: Data([
+            let file = try OutlookRules(data: Data([
                 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x14, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
@@ -954,15 +954,15 @@ final class ImportActionTests: XCTestCase {
             XCTAssertEqual(0, file.rules[0].conditions.count)
             XCTAssertEqual(1, file.rules[0].actions.count)
             XCTAssertEqual(.flagForFollowUpAction, file.rules[0].actions[0].identifier)
-            XCTAssertTrue(file.rules[0].actions[0].data is FlagForFollowUpRuleElementData)
+            XCTAssertTrue(file.rules[0].actions[0].parameter is FlagForFollowUpParameter)
             XCTAssertEqual(0, file.rules[0].exceptions.count)
 
-            let action = file.rules[0].actions[0].data as! FlagForFollowUpRuleElementData
+            let action = file.rules[0].actions[0].parameter as! FlagForFollowUpParameter
             XCTAssertEqual("For Your Information", action.actionName)
             XCTAssertEqual(.nextWeek, action.followUp)
         }
         do {
-            let file = try OutlookRulesFile(data: Data([
+            let file = try OutlookRules(data: Data([
                 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x14, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
@@ -989,15 +989,15 @@ final class ImportActionTests: XCTestCase {
             XCTAssertEqual(0, file.rules[0].conditions.count)
             XCTAssertEqual(1, file.rules[0].actions.count)
             XCTAssertEqual(.flagForFollowUpAction, file.rules[0].actions[0].identifier)
-            XCTAssertTrue(file.rules[0].actions[0].data is FlagForFollowUpRuleElementData)
+            XCTAssertTrue(file.rules[0].actions[0].parameter is FlagForFollowUpParameter)
             XCTAssertEqual(0, file.rules[0].exceptions.count)
 
-            let action = file.rules[0].actions[0].data as! FlagForFollowUpRuleElementData
+            let action = file.rules[0].actions[0].parameter as! FlagForFollowUpParameter
             XCTAssertEqual("For Your Information", action.actionName)
             XCTAssertEqual(.noDate, action.followUp)
         }
         do {
-            let file = try OutlookRulesFile(data: Data([
+            let file = try OutlookRules(data: Data([
                 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x14, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
@@ -1024,10 +1024,10 @@ final class ImportActionTests: XCTestCase {
             XCTAssertEqual(0, file.rules[0].conditions.count)
             XCTAssertEqual(1, file.rules[0].actions.count)
             XCTAssertEqual(.flagForFollowUpAction, file.rules[0].actions[0].identifier)
-            XCTAssertTrue(file.rules[0].actions[0].data is FlagForFollowUpRuleElementData)
+            XCTAssertTrue(file.rules[0].actions[0].parameter is FlagForFollowUpParameter)
             XCTAssertEqual(0, file.rules[0].exceptions.count)
 
-            let action = file.rules[0].actions[0].data as! FlagForFollowUpRuleElementData
+            let action = file.rules[0].actions[0].parameter as! FlagForFollowUpParameter
             XCTAssertEqual("For Your Information", action.actionName)
             XCTAssertEqual(.completed, action.followUp)
         }
@@ -1035,7 +1035,7 @@ final class ImportActionTests: XCTestCase {
 
     func testClearFlagAction() throws {
         do {
-            let file = try OutlookRulesFile(data: Data([
+            let file = try OutlookRules(data: Data([
                 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x14, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
@@ -1061,14 +1061,14 @@ final class ImportActionTests: XCTestCase {
             XCTAssertEqual(0, file.rules[0].conditions.count)
             XCTAssertEqual(1, file.rules[0].actions.count)
             XCTAssertEqual(.clearFlagAction, file.rules[0].actions[0].identifier)
-            XCTAssertTrue(file.rules[0].actions[0].data is SimpleRuleElementData)
+            XCTAssertEqual(0, file.rules[0].actions[0].parameters.count)
             XCTAssertEqual(0, file.rules[0].exceptions.count)
         }
     }
 
     func testClearCategoriesAction() throws {
         do {
-            let file = try OutlookRulesFile(data: Data([
+            let file = try OutlookRules(data: Data([
                 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x14, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
@@ -1094,14 +1094,14 @@ final class ImportActionTests: XCTestCase {
             XCTAssertEqual(0, file.rules[0].conditions.count)
             XCTAssertEqual(1, file.rules[0].actions.count)
             XCTAssertEqual(.clearCategoriesAction, file.rules[0].actions[0].identifier)
-            XCTAssertTrue(file.rules[0].actions[0].data is SimpleRuleElementData)
+            XCTAssertEqual(0, file.rules[0].actions[0].parameters.count)
             XCTAssertEqual(0, file.rules[0].exceptions.count)
         }
     }
     
     func testApplyRetentionPolicyAction() throws {
         do {
-            let file = try OutlookRulesFile(data: Data([
+            let file = try OutlookRules(data: Data([
                 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x14, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
@@ -1123,10 +1123,10 @@ final class ImportActionTests: XCTestCase {
             XCTAssertEqual(0, file.rules[0].conditions.count)
             XCTAssertEqual(1, file.rules[0].actions.count)
             XCTAssertEqual(.applyRetentionPolicyAction, file.rules[0].actions[0].identifier)
-            XCTAssertTrue(file.rules[0].actions[0].data is ApplyRetentionPolicyRuleElementData)
+            XCTAssertTrue(file.rules[0].actions[0].parameter is RetentionPolicyParameter)
             XCTAssertEqual(0, file.rules[0].exceptions.count)
             
-            let action = file.rules[0].actions[0].data as! ApplyRetentionPolicyRuleElementData
+            let action = file.rules[0].actions[0].parameter as! RetentionPolicyParameter
             XCTAssertEqual(GUID(0x56453412, 0x7867, 0x9089, 0x0112, 0x233445566778), action.guid)
             XCTAssertEqual("Never Delete", action.name)
         }
@@ -1134,7 +1134,7 @@ final class ImportActionTests: XCTestCase {
 
     func testMarkImportanceAction() throws {
         do {
-            let file = try OutlookRulesFile(data: Data([
+            let file = try OutlookRules(data: Data([
                 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x14, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
@@ -1159,14 +1159,14 @@ final class ImportActionTests: XCTestCase {
             XCTAssertEqual(0, file.rules[0].conditions.count)
             XCTAssertEqual(1, file.rules[0].actions.count)
             XCTAssertEqual(.markImportanceAction, file.rules[0].actions[0].identifier)
-            XCTAssertTrue(file.rules[0].actions[0].data is ImportanceRuleElementData)
+            XCTAssertTrue(file.rules[0].actions[0].parameter is ImportanceParameter)
             XCTAssertEqual(0, file.rules[0].exceptions.count)
 
-            let action = file.rules[0].actions[0].data as! ImportanceRuleElementData
+            let action = file.rules[0].actions[0].parameter as! ImportanceParameter
             XCTAssertEqual(.low, action.importance)
         }
         do {
-            let file = try OutlookRulesFile(data: Data([
+            let file = try OutlookRules(data: Data([
                 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x14, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
@@ -1191,14 +1191,14 @@ final class ImportActionTests: XCTestCase {
             XCTAssertEqual(0, file.rules[0].conditions.count)
             XCTAssertEqual(1, file.rules[0].actions.count)
             XCTAssertEqual(.markImportanceAction, file.rules[0].actions[0].identifier)
-            XCTAssertTrue(file.rules[0].actions[0].data is ImportanceRuleElementData)
+            XCTAssertTrue(file.rules[0].actions[0].parameter is ImportanceParameter)
             XCTAssertEqual(0, file.rules[0].exceptions.count)
 
-            let action = file.rules[0].actions[0].data as! ImportanceRuleElementData
+            let action = file.rules[0].actions[0].parameter as! ImportanceParameter
             XCTAssertEqual(.normal, action.importance)
         }
         do {
-            let file = try OutlookRulesFile(data: Data([
+            let file = try OutlookRules(data: Data([
                 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x14, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
@@ -1223,17 +1223,17 @@ final class ImportActionTests: XCTestCase {
             XCTAssertEqual(0, file.rules[0].conditions.count)
             XCTAssertEqual(1, file.rules[0].actions.count)
             XCTAssertEqual(.markImportanceAction, file.rules[0].actions[0].identifier)
-            XCTAssertTrue(file.rules[0].actions[0].data is ImportanceRuleElementData)
+            XCTAssertTrue(file.rules[0].actions[0].parameter is ImportanceParameter)
             XCTAssertEqual(0, file.rules[0].exceptions.count)
 
-            let action = file.rules[0].actions[0].data as! ImportanceRuleElementData
+            let action = file.rules[0].actions[0].parameter as! ImportanceParameter
             XCTAssertEqual(.high, action.importance)
         }
     }
 
     func testPrintAction() throws {
         do {
-            let file = try OutlookRulesFile(data: Data([
+            let file = try OutlookRules(data: Data([
                 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x14, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
@@ -1257,14 +1257,14 @@ final class ImportActionTests: XCTestCase {
             XCTAssertEqual(0, file.rules[0].conditions.count)
             XCTAssertEqual(1, file.rules[0].actions.count)
             XCTAssertEqual(.printAction, file.rules[0].actions[0].identifier)
-            XCTAssertTrue(file.rules[0].actions[0].data is SimpleRuleElementData)
+            XCTAssertEqual(0, file.rules[0].actions[0].parameters.count)
             XCTAssertEqual(0, file.rules[0].exceptions.count)
         }
     }
     
     func testStartApplicationAction() throws {
         do {
-            let file = try OutlookRulesFile(data: Data([
+            let file = try OutlookRules(data: Data([
                 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x14, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
@@ -1286,14 +1286,14 @@ final class ImportActionTests: XCTestCase {
             XCTAssertEqual(0, file.rules[0].conditions.count)
             XCTAssertEqual(1, file.rules[0].actions.count)
             XCTAssertEqual(.startApplicationAction, file.rules[0].actions[0].identifier)
-            XCTAssertTrue(file.rules[0].actions[0].data is PathRuleElementData)
+            XCTAssertTrue(file.rules[0].actions[0].parameter is PathParameter)
             XCTAssertEqual(0, file.rules[0].exceptions.count)
 
-            let action = file.rules[0].actions[0].data as! PathRuleElementData
+            let action = file.rules[0].actions[0].parameter as! PathParameter
             XCTAssertEqual("C:\\Program Files\\IDA 7.2\\ida.exe", action.path)
         }
         do {
-            let file = try OutlookRulesFile(data: Data([
+            let file = try OutlookRules(data: Data([
                 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x14, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
@@ -1316,20 +1316,20 @@ final class ImportActionTests: XCTestCase {
             XCTAssertEqual(1, file.rules.count)
             XCTAssertEqual(1, file.rules[0].conditions.count)
             XCTAssertEqual(.onThisComputerOnlyCondition, file.rules[0].conditions[0].identifier)
-            XCTAssertTrue(file.rules[0].conditions[0].data is OnThisComputerOnlyRuleElementData)
+            XCTAssertTrue(file.rules[0].conditions[0].parameter is ProfileStampParameter)
             XCTAssertEqual(1, file.rules[0].actions.count)
             XCTAssertEqual(.startApplicationAction, file.rules[0].actions[0].identifier)
-            XCTAssertTrue(file.rules[0].actions[0].data is PathRuleElementData)
+            XCTAssertTrue(file.rules[0].actions[0].parameter is PathParameter)
             XCTAssertEqual(0, file.rules[0].exceptions.count)
 
-            let action = file.rules[0].actions[0].data as! PathRuleElementData
+            let action = file.rules[0].actions[0].parameter as! PathParameter
             XCTAssertEqual("C:\\Program Files\\IDA 7.2\\ida.exe", action.path)
         }
     }
 
     func testPlaySoundAction() throws {
         do {
-            let file = try OutlookRulesFile(data: Data([
+            let file = try OutlookRules(data: Data([
                 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x14, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
@@ -1358,17 +1358,17 @@ final class ImportActionTests: XCTestCase {
             XCTAssertEqual(1, file.rules.count)
             XCTAssertEqual(1, file.rules[0].conditions.count)
             XCTAssertEqual(.onThisComputerOnlyCondition, file.rules[0].conditions[0].identifier)
-            XCTAssertTrue(file.rules[0].conditions[0].data is OnThisComputerOnlyRuleElementData)
+            XCTAssertTrue(file.rules[0].conditions[0].parameter is ProfileStampParameter)
             XCTAssertEqual(1, file.rules[0].actions.count)
             XCTAssertEqual(.playSoundAction, file.rules[0].actions[0].identifier)
-            XCTAssertTrue(file.rules[0].actions[0].data is PathRuleElementData)
+            XCTAssertTrue(file.rules[0].actions[0].parameter is PathParameter)
             XCTAssertEqual(0, file.rules[0].exceptions.count)
 
-            let action = file.rules[0].actions[0].data as! PathRuleElementData
+            let action = file.rules[0].actions[0].parameter as! PathParameter
             XCTAssertEqual("C:\\Windows\\Media\\chimes.wav", action.path)
         }
         do {
-            let file = try OutlookRulesFile(data: Data([
+            let file = try OutlookRules(data: Data([
                 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x14, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
@@ -1396,17 +1396,17 @@ final class ImportActionTests: XCTestCase {
             XCTAssertEqual(0, file.rules[0].conditions.count)
             XCTAssertEqual(1, file.rules[0].actions.count)
             XCTAssertEqual(.playSoundAction, file.rules[0].actions[0].identifier)
-            XCTAssertTrue(file.rules[0].actions[0].data is PathRuleElementData)
+            XCTAssertTrue(file.rules[0].actions[0].parameter is PathParameter)
             XCTAssertEqual(0, file.rules[0].exceptions.count)
 
-            let action = file.rules[0].actions[0].data as! PathRuleElementData
+            let action = file.rules[0].actions[0].parameter as! PathParameter
             XCTAssertEqual("C:\\Windows\\Media\\chimes.wav", action.path)
         }
     }
 
     func testMarkAsReadAction() throws {
         do {
-            let file = try OutlookRulesFile(data: Data([
+            let file = try OutlookRules(data: Data([
                 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x14, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
@@ -1423,14 +1423,14 @@ final class ImportActionTests: XCTestCase {
             XCTAssertEqual(0, file.rules[0].conditions.count)
             XCTAssertEqual(1, file.rules[0].actions.count)
             XCTAssertEqual(.markAsReadAction, file.rules[0].actions[0].identifier)
-            XCTAssertTrue(file.rules[0].actions[0].data is SimpleRuleElementData)
+            XCTAssertEqual(0, file.rules[0].actions[0].parameters.count)
             XCTAssertEqual(0, file.rules[0].exceptions.count)
         }
     }
     
     func testRunScriptAction() throws {
         do {
-            let file = try OutlookRulesFile(data: Data([
+            let file = try OutlookRules(data: Data([
                 0x80, 0x4F, 0x12, 0x00, 0x00, 0x00, 0x14, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x80, 0x4F,
@@ -1455,15 +1455,15 @@ final class ImportActionTests: XCTestCase {
             XCTAssertEqual(0, file.rules[0].conditions.count)
             XCTAssertEqual(1, file.rules[0].actions.count)
             XCTAssertEqual(.runScriptAction, file.rules[0].actions[0].identifier)
-            XCTAssertTrue(file.rules[0].actions[0].data is RunScriptRuleElementData)
+            XCTAssertTrue(file.rules[0].actions[0].parameter is ScriptParameter)
             XCTAssertEqual(0, file.rules[0].exceptions.count)
             
-            let condition = file.rules[0].actions[0].data as! RunScriptRuleElementData
+            let condition = file.rules[0].actions[0].parameter as! ScriptParameter
             XCTAssertEqual("Project1.CustomMailMessageRule", condition.name)
             XCTAssertEqual("Project1.CustomMailMessageRule", condition.function)
         }
         do {
-            let file = try OutlookRulesFile(data: Data([
+            let file = try OutlookRules(data: Data([
                 0x80, 0x4F, 0x12, 0x00, 0x00, 0x00, 0x14, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x80, 0x4F,
@@ -1489,13 +1489,13 @@ final class ImportActionTests: XCTestCase {
             XCTAssertEqual(1, file.rules.count)
             XCTAssertEqual(1, file.rules[0].conditions.count)
             XCTAssertEqual(.onThisComputerOnlyCondition, file.rules[0].conditions[0].identifier)
-            XCTAssertTrue(file.rules[0].conditions[0].data is OnThisComputerOnlyRuleElementData)
+            XCTAssertTrue(file.rules[0].conditions[0].parameter is ProfileStampParameter)
             XCTAssertEqual(1, file.rules[0].actions.count)
             XCTAssertEqual(.runScriptAction, file.rules[0].actions[0].identifier)
-            XCTAssertTrue(file.rules[0].actions[0].data is RunScriptRuleElementData)
+            XCTAssertTrue(file.rules[0].actions[0].parameter is ScriptParameter)
             XCTAssertEqual(0, file.rules[0].exceptions.count)
             
-            let condition = file.rules[0].actions[0].data as! RunScriptRuleElementData
+            let condition = file.rules[0].actions[0].parameter as! ScriptParameter
             XCTAssertEqual("Project1.CustomMailMessageRule", condition.name)
             XCTAssertEqual("Project1.CustomMailMessageRule", condition.function)
         }
@@ -1503,7 +1503,7 @@ final class ImportActionTests: XCTestCase {
 
     func testStopProcessingMoreRulesAction() throws {
         do {
-            let file = try OutlookRulesFile(data: Data([
+            let file = try OutlookRules(data: Data([
                 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x14, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
@@ -1520,14 +1520,14 @@ final class ImportActionTests: XCTestCase {
             XCTAssertEqual(0, file.rules[0].conditions.count)
             XCTAssertEqual(1, file.rules[0].actions.count)
             XCTAssertEqual(.stopProcessingMoreRulesAction, file.rules[0].actions[0].identifier)
-            XCTAssertTrue(file.rules[0].actions[0].data is SimpleRuleElementData)
+            XCTAssertEqual(0, file.rules[0].actions[0].parameters.count)
             XCTAssertEqual(0, file.rules[0].exceptions.count)
         }
     }
 
     func testMarkSensitivityAction() throws {
         do {
-            let file = try OutlookRulesFile(data: Data([
+            let file = try OutlookRules(data: Data([
                 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x14, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
@@ -1545,14 +1545,14 @@ final class ImportActionTests: XCTestCase {
             XCTAssertEqual(0, file.rules[0].conditions.count)
             XCTAssertEqual(1, file.rules[0].actions.count)
             XCTAssertEqual(.markSensitivityAction, file.rules[0].actions[0].identifier)
-            XCTAssertTrue(file.rules[0].actions[0].data is SensitivityRuleElementData)
+            XCTAssertTrue(file.rules[0].actions[0].parameter is SensitivityParameter)
             XCTAssertEqual(0, file.rules[0].exceptions.count)
             
-            let condition = file.rules[0].actions[0].data as! SensitivityRuleElementData
+            let condition = file.rules[0].actions[0].parameter as! SensitivityParameter
             XCTAssertEqual(MessageSensitivity.normal, condition.sensitivity)
         }
         do {
-            let file = try OutlookRulesFile(data: Data([
+            let file = try OutlookRules(data: Data([
                 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x14, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
@@ -1570,14 +1570,14 @@ final class ImportActionTests: XCTestCase {
             XCTAssertEqual(0, file.rules[0].conditions.count)
             XCTAssertEqual(1, file.rules[0].actions.count)
             XCTAssertEqual(.markSensitivityAction, file.rules[0].actions[0].identifier)
-            XCTAssertTrue(file.rules[0].actions[0].data is SensitivityRuleElementData)
+            XCTAssertTrue(file.rules[0].actions[0].parameter is SensitivityParameter)
             XCTAssertEqual(0, file.rules[0].exceptions.count)
             
-            let condition = file.rules[0].actions[0].data as! SensitivityRuleElementData
+            let condition = file.rules[0].actions[0].parameter as! SensitivityParameter
             XCTAssertEqual(MessageSensitivity.personal, condition.sensitivity)
         }
         do {
-            let file = try OutlookRulesFile(data: Data([
+            let file = try OutlookRules(data: Data([
                 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x14, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
@@ -1602,14 +1602,14 @@ final class ImportActionTests: XCTestCase {
             XCTAssertEqual(0, file.rules[0].conditions.count)
             XCTAssertEqual(1, file.rules[0].actions.count)
             XCTAssertEqual(.markSensitivityAction, file.rules[0].actions[0].identifier)
-            XCTAssertTrue(file.rules[0].actions[0].data is SensitivityRuleElementData)
+            XCTAssertTrue(file.rules[0].actions[0].parameter is SensitivityParameter)
             XCTAssertEqual(0, file.rules[0].exceptions.count)
             
-            let condition = file.rules[0].actions[0].data as! SensitivityRuleElementData
+            let condition = file.rules[0].actions[0].parameter as! SensitivityParameter
             XCTAssertEqual(MessageSensitivity.`private`, condition.sensitivity)
         }
         do {
-            let file = try OutlookRulesFile(data: Data([
+            let file = try OutlookRules(data: Data([
                 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x14, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
@@ -1627,14 +1627,14 @@ final class ImportActionTests: XCTestCase {
             XCTAssertEqual(0, file.rules[0].conditions.count)
             XCTAssertEqual(1, file.rules[0].actions.count)
             XCTAssertEqual(.markSensitivityAction, file.rules[0].actions[0].identifier)
-            XCTAssertTrue(file.rules[0].actions[0].data is SensitivityRuleElementData)
+            XCTAssertTrue(file.rules[0].actions[0].parameter is SensitivityParameter)
             XCTAssertEqual(0, file.rules[0].exceptions.count)
             
-            let condition = file.rules[0].actions[0].data as! SensitivityRuleElementData
+            let condition = file.rules[0].actions[0].parameter as! SensitivityParameter
             XCTAssertEqual(MessageSensitivity.confidential, condition.sensitivity)
         }
         do {
-            let file = try OutlookRulesFile(data: Data([
+            let file = try OutlookRules(data: Data([
                 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x14, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
@@ -1652,17 +1652,17 @@ final class ImportActionTests: XCTestCase {
             XCTAssertEqual(0, file.rules[0].conditions.count)
             XCTAssertEqual(1, file.rules[0].actions.count)
             XCTAssertEqual(.markSensitivityAction, file.rules[0].actions[0].identifier)
-            XCTAssertTrue(file.rules[0].actions[0].data is SensitivityRuleElementData)
+            XCTAssertTrue(file.rules[0].actions[0].parameter is SensitivityParameter)
             XCTAssertEqual(0, file.rules[0].exceptions.count)
             
-            let condition = file.rules[0].actions[0].data as! SensitivityRuleElementData
+            let condition = file.rules[0].actions[0].parameter as! SensitivityParameter
             XCTAssertEqual(0x04, condition.rawSensitivity)
         }
     }
     
     func testNotifyReadAction() throws {
         do {
-            let file = try OutlookRulesFile(data: Data([
+            let file = try OutlookRules(data: Data([
                 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x14, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
@@ -1679,14 +1679,14 @@ final class ImportActionTests: XCTestCase {
             XCTAssertEqual(0, file.rules[0].conditions.count)
             XCTAssertEqual(1, file.rules[0].actions.count)
             XCTAssertEqual(.notifyReadAction, file.rules[0].actions[0].identifier)
-            XCTAssertTrue(file.rules[0].actions[0].data is SimpleRuleElementData)
+            XCTAssertEqual(0, file.rules[0].actions[0].parameters.count)
             XCTAssertEqual(0, file.rules[0].exceptions.count)
         }
     }
     
     func testNotifyDeliveredAction() throws {
         do {
-            let file = try OutlookRulesFile(data: Data([
+            let file = try OutlookRules(data: Data([
                 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x14, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
@@ -1703,14 +1703,14 @@ final class ImportActionTests: XCTestCase {
             XCTAssertEqual(0, file.rules[0].conditions.count)
             XCTAssertEqual(1, file.rules[0].actions.count)
             XCTAssertEqual(.notifyDeliveredAction, file.rules[0].actions[0].identifier)
-            XCTAssertTrue(file.rules[0].actions[0].data is SimpleRuleElementData)
+            XCTAssertEqual(0, file.rules[0].actions[0].parameters.count)
             XCTAssertEqual(0, file.rules[0].exceptions.count)
         }
     }
     
     func testCcAction() throws {
         do {
-            let file = try OutlookRulesFile(data: Data([
+            let file = try OutlookRules(data: Data([
                 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x14, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
@@ -1742,10 +1742,10 @@ final class ImportActionTests: XCTestCase {
             XCTAssertEqual(0, file.rules[0].conditions.count)
             XCTAssertEqual(1, file.rules[0].actions.count)
             XCTAssertEqual(.ccAction, file.rules[0].actions[0].identifier)
-            XCTAssertTrue(file.rules[0].actions[0].data is PeopleOrPublicGroupListRuleElementData)
+            XCTAssertTrue(file.rules[0].actions[0].parameter is AddressParameter)
             XCTAssertEqual(0, file.rules[0].exceptions.count)
 
-            let action = file.rules[0].actions[0].data as! PeopleOrPublicGroupListRuleElementData
+            let action = file.rules[0].actions[0].parameter as! AddressParameter
             XCTAssertEqual(1, action.values.count)
             XCTAssertEqual(6, action.values[0].count)
             XCTAssertEqual(MAPI_E.NOT_FOUND.rawValue, action.values[0][PropertyId.tagSmtpAddress.rawValue] as! UInt32)
@@ -1756,7 +1756,7 @@ final class ImportActionTests: XCTestCase {
             XCTAssertEqual(1, action.values[0][PropertyId.tagRecipientType.rawValue] as! UInt32)
         }
         do {
-            let file = try OutlookRulesFile(data: Data([
+            let file = try OutlookRules(data: Data([
                 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x14, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
@@ -1831,10 +1831,10 @@ final class ImportActionTests: XCTestCase {
             XCTAssertEqual(0, file.rules[0].conditions.count)
             XCTAssertEqual(1, file.rules[0].actions.count)
             XCTAssertEqual(.ccAction, file.rules[0].actions[0].identifier)
-            XCTAssertTrue(file.rules[0].actions[0].data is PeopleOrPublicGroupListRuleElementData)
+            XCTAssertTrue(file.rules[0].actions[0].parameter is AddressParameter)
             XCTAssertEqual(0, file.rules[0].exceptions.count)
 
-            let action = file.rules[0].actions[0].data as! PeopleOrPublicGroupListRuleElementData
+            let action = file.rules[0].actions[0].parameter as! AddressParameter
             XCTAssertEqual(2, action.values.count)
             XCTAssertEqual(11, action.values[0].count)
             XCTAssertEqual(MAPI_E.NOT_FOUND.rawValue, action.values[0][PropertyId.tagSmtpAddress.rawValue] as! UInt32)
@@ -1856,7 +1856,7 @@ final class ImportActionTests: XCTestCase {
     
     func testDeferDeliveryAction() throws {
         do {
-            let file = try OutlookRulesFile(data: Data([
+            let file = try OutlookRules(data: Data([
                 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x14, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
@@ -1881,14 +1881,14 @@ final class ImportActionTests: XCTestCase {
             XCTAssertEqual(0, file.rules[0].conditions.count)
             XCTAssertEqual(1, file.rules[0].actions.count)
             XCTAssertEqual(.deferDeliveryAction, file.rules[0].actions[0].identifier)
-            XCTAssertTrue(file.rules[0].actions[0].data is DeferDeliveryRuleElementData)
+            XCTAssertTrue(file.rules[0].actions[0].parameter is DeferParameter)
             XCTAssertEqual(0, file.rules[0].exceptions.count)
 
-            let action = file.rules[0].actions[0].data as! DeferDeliveryRuleElementData
+            let action = file.rules[0].actions[0].parameter as! DeferParameter
             XCTAssertEqual(0, action.minutes)
         }
         do {
-            let file = try OutlookRulesFile(data: Data([
+            let file = try OutlookRules(data: Data([
                 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x14, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
@@ -1913,14 +1913,14 @@ final class ImportActionTests: XCTestCase {
             XCTAssertEqual(0, file.rules[0].conditions.count)
             XCTAssertEqual(1, file.rules[0].actions.count)
             XCTAssertEqual(.deferDeliveryAction, file.rules[0].actions[0].identifier)
-            XCTAssertTrue(file.rules[0].actions[0].data is DeferDeliveryRuleElementData)
+            XCTAssertTrue(file.rules[0].actions[0].parameter is DeferParameter)
             XCTAssertEqual(0, file.rules[0].exceptions.count)
 
-            let action = file.rules[0].actions[0].data as! DeferDeliveryRuleElementData
+            let action = file.rules[0].actions[0].parameter as! DeferParameter
             XCTAssertEqual(1, action.minutes)
         }
         do {
-            let file = try OutlookRulesFile(data: Data([
+            let file = try OutlookRules(data: Data([
                 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x14, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
@@ -1945,14 +1945,14 @@ final class ImportActionTests: XCTestCase {
             XCTAssertEqual(0, file.rules[0].conditions.count)
             XCTAssertEqual(1, file.rules[0].actions.count)
             XCTAssertEqual(.deferDeliveryAction, file.rules[0].actions[0].identifier)
-            XCTAssertTrue(file.rules[0].actions[0].data is DeferDeliveryRuleElementData)
+            XCTAssertTrue(file.rules[0].actions[0].parameter is DeferParameter)
             XCTAssertEqual(0, file.rules[0].exceptions.count)
 
-            let action = file.rules[0].actions[0].data as! DeferDeliveryRuleElementData
+            let action = file.rules[0].actions[0].parameter as! DeferParameter
             XCTAssertEqual(120, action.minutes)
         }
         do {
-            let file = try OutlookRulesFile(data: Data([
+            let file = try OutlookRules(data: Data([
                 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x14, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
@@ -1977,17 +1977,17 @@ final class ImportActionTests: XCTestCase {
             XCTAssertEqual(0, file.rules[0].conditions.count)
             XCTAssertEqual(1, file.rules[0].actions.count)
             XCTAssertEqual(.deferDeliveryAction, file.rules[0].actions[0].identifier)
-            XCTAssertTrue(file.rules[0].actions[0].data is DeferDeliveryRuleElementData)
+            XCTAssertTrue(file.rules[0].actions[0].parameter is DeferParameter)
             XCTAssertEqual(0, file.rules[0].exceptions.count)
 
-            let action = file.rules[0].actions[0].data as! DeferDeliveryRuleElementData
+            let action = file.rules[0].actions[0].parameter as! DeferParameter
             XCTAssertEqual(121, action.minutes)
         }
     }
 
     func testPerformCustomActionAction() throws {
         do {
-            let file = try OutlookRulesFile(data: Data([
+            let file = try OutlookRules(data: Data([
                 0x80, 0x4f, 0x12, 0x00, 0x00, 0x00, 0x14, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x80, 0x4f,
@@ -2014,17 +2014,17 @@ final class ImportActionTests: XCTestCase {
             XCTAssertEqual(0, file.rules[0].conditions.count)
             XCTAssertEqual(1, file.rules[0].actions.count)
             XCTAssertEqual(.performCustomActionAction, file.rules[0].actions[0].identifier)
-            XCTAssertTrue(file.rules[0].actions[0].data is PerformCustomActionRuleElementData)
+            XCTAssertTrue(file.rules[0].actions[0].parameter is CustomActionParameter)
             XCTAssertEqual(0, file.rules[0].exceptions.count)
 
-            let action = file.rules[0].actions[0].data as! PerformCustomActionRuleElementData
+            let action = file.rules[0].actions[0].parameter as! CustomActionParameter
             XCTAssertEqual("4.0;C:\\Program Files (x86)\\TechHit.com\\AutoRead\\autoread.dll;1", action.location)
             XCTAssertEqual("AutoRead", action.name)
             XCTAssertEqual("", action.options)
             XCTAssertEqual("", action.actionValue)
         }
         do {
-            let file = try OutlookRulesFile(data: Data([
+            let file = try OutlookRules(data: Data([
                 0x80, 0x4f, 0x12, 0x00, 0x00, 0x00, 0x14, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x80, 0x4f,
@@ -2054,17 +2054,17 @@ final class ImportActionTests: XCTestCase {
             XCTAssertEqual(0, file.rules[0].conditions.count)
             XCTAssertEqual(1, file.rules[0].actions.count)
             XCTAssertEqual(.performCustomActionAction, file.rules[0].actions[0].identifier)
-            XCTAssertTrue(file.rules[0].actions[0].data is PerformCustomActionRuleElementData)
+            XCTAssertTrue(file.rules[0].actions[0].parameter is CustomActionParameter)
             XCTAssertEqual(0, file.rules[0].exceptions.count)
 
-            let action = file.rules[0].actions[0].data as! PerformCustomActionRuleElementData
+            let action = file.rules[0].actions[0].parameter as! CustomActionParameter
             XCTAssertEqual("4.0;C:\\Program Files (x86)\\TechHit.com\\AutoRead\\autoread.dll", action.location)
             XCTAssertEqual("AutoRead", action.name)
             XCTAssertEqual("v: 1|c: autoread|b: 2|", action.options)
             XCTAssertEqual("AutoRead", action.actionValue)
         }
         do {
-            let file = try OutlookRulesFile(data: Data([
+            let file = try OutlookRules(data: Data([
                 0x80, 0x4f, 0x12, 0x00, 0x00, 0x00, 0x14, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x80, 0x4f,
@@ -2094,10 +2094,10 @@ final class ImportActionTests: XCTestCase {
             XCTAssertEqual(0, file.rules[0].conditions.count)
             XCTAssertEqual(1, file.rules[0].actions.count)
             XCTAssertEqual(.performCustomActionAction, file.rules[0].actions[0].identifier)
-            XCTAssertTrue(file.rules[0].actions[0].data is PerformCustomActionRuleElementData)
+            XCTAssertTrue(file.rules[0].actions[0].parameter is CustomActionParameter)
             XCTAssertEqual(0, file.rules[0].exceptions.count)
 
-            let action = file.rules[0].actions[0].data as! PerformCustomActionRuleElementData
+            let action = file.rules[0].actions[0].parameter as! CustomActionParameter
             XCTAssertEqual("4.0;C:\\Program Files (x86)\\TechHit.com\\AutoRead\\autoread.dll", action.location)
             XCTAssertEqual("AutoRead", action.name)
             XCTAssertEqual("v: 1|c: autoread|b: 4|", action.options)
@@ -2107,7 +2107,7 @@ final class ImportActionTests: XCTestCase {
 
     func testDisplayMessageInNewItemAlertWindowAction() throws {
         do {
-            let file = try OutlookRulesFile(data: Data([
+            let file = try OutlookRules(data: Data([
                 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x14, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
@@ -2134,14 +2134,14 @@ final class ImportActionTests: XCTestCase {
             XCTAssertEqual(0, file.rules[0].conditions.count)
             XCTAssertEqual(1, file.rules[0].actions.count)
             XCTAssertEqual(.displayMessageInNewItemAlertWindowAction, file.rules[0].actions[0].identifier)
-            XCTAssertTrue(file.rules[0].actions[0].data is DisplayMessageInNewItemAlertWindowRuleElementData)
+            XCTAssertTrue(file.rules[0].actions[0].parameter is MessageParameter)
             XCTAssertEqual(0, file.rules[0].exceptions.count)
 
-            let action = file.rules[0].actions[0].data as! DisplayMessageInNewItemAlertWindowRuleElementData
+            let action = file.rules[0].actions[0].parameter as! MessageParameter
             XCTAssertEqual("ALERT!", action.message)
         }
         do {
-            let file = try OutlookRulesFile(data: Data([
+            let file = try OutlookRules(data: Data([
                 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x14, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
@@ -2199,14 +2199,14 @@ final class ImportActionTests: XCTestCase {
             XCTAssertEqual(0, file.rules[0].conditions.count)
             XCTAssertEqual(1, file.rules[0].actions.count)
             XCTAssertEqual(.displayMessageInNewItemAlertWindowAction, file.rules[0].actions[0].identifier)
-            XCTAssertTrue(file.rules[0].actions[0].data is DisplayMessageInNewItemAlertWindowRuleElementData)
+            XCTAssertTrue(file.rules[0].actions[0].parameter is MessageParameter)
             XCTAssertEqual(0, file.rules[0].exceptions.count)
 
-            let action = file.rules[0].actions[0].data as! DisplayMessageInNewItemAlertWindowRuleElementData
+            let action = file.rules[0].actions[0].parameter as! MessageParameter
             XCTAssertEqual("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", action.message)
         }
         do {
-            let file = try OutlookRulesFile(data: Data([
+            let file = try OutlookRules(data: Data([
                 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x14, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
@@ -2264,17 +2264,17 @@ final class ImportActionTests: XCTestCase {
             XCTAssertEqual(0, file.rules[0].conditions.count)
             XCTAssertEqual(1, file.rules[0].actions.count)
             XCTAssertEqual(.displayMessageInNewItemAlertWindowAction, file.rules[0].actions[0].identifier)
-            XCTAssertTrue(file.rules[0].actions[0].data is DisplayMessageInNewItemAlertWindowRuleElementData)
+            XCTAssertTrue(file.rules[0].actions[0].parameter is MessageParameter)
             XCTAssertEqual(0, file.rules[0].exceptions.count)
 
-            let action = file.rules[0].actions[0].data as! DisplayMessageInNewItemAlertWindowRuleElementData
+            let action = file.rules[0].actions[0].parameter as! MessageParameter
             XCTAssertEqual("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaab", action.message)
         }
     }
 
     func testDisplayDesktopAlertAction() throws {
         do {
-            let file = try OutlookRulesFile(data: Data([
+            let file = try OutlookRules(data: Data([
                 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x14, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
@@ -2291,14 +2291,14 @@ final class ImportActionTests: XCTestCase {
             XCTAssertEqual(0, file.rules[0].conditions.count)
             XCTAssertEqual(1, file.rules[0].actions.count)
             XCTAssertEqual(.displayDesktopAlertAction, file.rules[0].actions[0].identifier)
-            XCTAssertTrue(file.rules[0].actions[0].data is SimpleRuleElementData)
+            XCTAssertEqual(0, file.rules[0].actions[0].parameters.count)
             XCTAssertEqual(0, file.rules[0].exceptions.count)
         }
     }
     
     func testMultipleActions() throws {
         do {
-            let file = try OutlookRulesFile(data: Data([
+            let file = try OutlookRules(data: Data([
                 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x14, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
@@ -2323,9 +2323,9 @@ final class ImportActionTests: XCTestCase {
             XCTAssertEqual(0, file.rules[0].conditions.count)
             XCTAssertEqual(2, file.rules[0].actions.count)
             XCTAssertEqual(.printAction, file.rules[0].actions[0].identifier)
-            XCTAssertTrue(file.rules[0].actions[0].data is SimpleRuleElementData)
+            XCTAssertEqual(0, file.rules[0].actions[0].parameters.count)
             XCTAssertEqual(.markAsReadAction, file.rules[0].actions[1].identifier)
-            XCTAssertTrue(file.rules[0].actions[1].data is SimpleRuleElementData)
+            XCTAssertEqual(0, file.rules[0].actions[1].parameters.count)
             XCTAssertEqual(0, file.rules[0].exceptions.count)
         }
     }
diff --git a/Tests/OutlookRulesReaderTests/Import/ImportConditionTests.swift b/Tests/OutlookRulesReaderTests/Import/ImportConditionTests.swift
index 73082e3..a06c6f2 100644
--- a/Tests/OutlookRulesReaderTests/Import/ImportConditionTests.swift
+++ b/Tests/OutlookRulesReaderTests/Import/ImportConditionTests.swift
@@ -5,7 +5,7 @@ import MAPI
 final class ImportConditionTests: XCTestCase {
     func testFromCondition() throws {
         do {
-            let file = try OutlookRulesFile(data: Data([
+            let file = try OutlookRules(data: Data([
                 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x14, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
@@ -30,11 +30,11 @@ final class ImportConditionTests: XCTestCase {
             XCTAssertEqual(1, file.rules.count)
             XCTAssertEqual(1, file.rules[0].conditions.count)
             XCTAssertEqual(.fromCondition, file.rules[0].conditions[0].identifier)
-            XCTAssertTrue(file.rules[0].conditions[0].data is PeopleOrPublicGroupListRuleElementData)
+            XCTAssertTrue(file.rules[0].conditions[0].parameter is AddressParameter)
             XCTAssertEqual(0, file.rules[0].actions.count)
             XCTAssertEqual(0, file.rules[0].exceptions.count)
-            
-            let condition = file.rules[0].conditions[0].data as! PeopleOrPublicGroupListRuleElementData
+
+            let condition = file.rules[0].conditions[0].parameter as!AddressParameter
             XCTAssertEqual(1, condition.values.count)
             XCTAssertEqual(6, condition.values[0].count)
             XCTAssertEqual(MAPI_E.NOT_FOUND.rawValue, condition.values[0][PropertyId.tagSmtpAddress.rawValue] as! UInt32)
@@ -45,7 +45,7 @@ final class ImportConditionTests: XCTestCase {
             XCTAssertEqual(1, condition.values[0][PropertyId.tagRecipientType.rawValue] as! UInt32)
         }
         do {
-            let file = try OutlookRulesFile(data: Data([
+            let file = try OutlookRules(data: Data([
                 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x14, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
@@ -113,11 +113,11 @@ final class ImportConditionTests: XCTestCase {
             XCTAssertEqual(1, file.rules.count)
             XCTAssertEqual(1, file.rules[0].conditions.count)
             XCTAssertEqual(.fromCondition, file.rules[0].conditions[0].identifier)
-            XCTAssertTrue(file.rules[0].conditions[0].data is PeopleOrPublicGroupListRuleElementData)
+            XCTAssertTrue(file.rules[0].conditions[0].parameter is AddressParameter)
             XCTAssertEqual(0, file.rules[0].actions.count)
             XCTAssertEqual(0, file.rules[0].exceptions.count)
-            
-            let condition = file.rules[0].conditions[0].data as! PeopleOrPublicGroupListRuleElementData
+
+            let condition = file.rules[0].conditions[0].parameter as!AddressParameter
             XCTAssertEqual(2, condition.values.count)
             XCTAssertEqual(11, condition.values[0].count)
             XCTAssertEqual(MAPI_E.NOT_FOUND.rawValue, condition.values[0][PropertyId.tagSmtpAddress.rawValue] as! UInt32)
@@ -136,7 +136,7 @@ final class ImportConditionTests: XCTestCase {
             XCTAssertEqual(1, condition.values[0][PropertyId.tagRecipientType.rawValue] as! UInt32)
         }
         do {
-            let file = try OutlookRulesFile(data: Data([
+            let file = try OutlookRules(data: Data([
                 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x14, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
@@ -161,11 +161,11 @@ final class ImportConditionTests: XCTestCase {
             XCTAssertEqual(1, file.rules.count)
             XCTAssertEqual(1, file.rules[0].conditions.count)
             XCTAssertEqual(.fromCondition, file.rules[0].conditions[0].identifier)
-            XCTAssertTrue(file.rules[0].conditions[0].data is PeopleOrPublicGroupListRuleElementData)
+            XCTAssertTrue(file.rules[0].conditions[0].parameter is AddressParameter)
             XCTAssertEqual(0, file.rules[0].actions.count)
             XCTAssertEqual(0, file.rules[0].exceptions.count)
-            
-            let condition = file.rules[0].conditions[0].data as! PeopleOrPublicGroupListRuleElementData
+
+            let condition = file.rules[0].conditions[0].parameter as!AddressParameter
             XCTAssertEqual(1, condition.values.count)
             XCTAssertEqual(6, condition.values[0].count)
             XCTAssertEqual(MAPI_E.NOT_FOUND.rawValue, condition.values[0][PropertyId.tagSmtpAddress.rawValue] as! UInt32)
@@ -176,7 +176,7 @@ final class ImportConditionTests: XCTestCase {
             XCTAssertEqual(1, condition.values[0][PropertyId.tagRecipientType.rawValue] as! UInt32)
         }
         do {
-            let file = try OutlookRulesFile(data: Data([
+            let file = try OutlookRules(data: Data([
                 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x14, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
@@ -201,11 +201,11 @@ final class ImportConditionTests: XCTestCase {
             XCTAssertEqual(1, file.rules.count)
             XCTAssertEqual(1, file.rules[0].conditions.count)
             XCTAssertEqual(.fromCondition, file.rules[0].conditions[0].identifier)
-            XCTAssertTrue(file.rules[0].conditions[0].data is PeopleOrPublicGroupListRuleElementData)
+            XCTAssertTrue(file.rules[0].conditions[0].parameter is AddressParameter)
             XCTAssertEqual(0, file.rules[0].actions.count)
             XCTAssertEqual(0, file.rules[0].exceptions.count)
-            
-            let condition = file.rules[0].conditions[0].data as! PeopleOrPublicGroupListRuleElementData
+
+            let condition = file.rules[0].conditions[0].parameter as!AddressParameter
             XCTAssertEqual(1, condition.values.count)
             XCTAssertEqual(6, condition.values[0].count)
             XCTAssertEqual(MAPI_E.NOT_FOUND.rawValue, condition.values[0][PropertyId.tagSmtpAddress.rawValue] as! UInt32)
@@ -219,7 +219,7 @@ final class ImportConditionTests: XCTestCase {
 
     func testSpecificWordsInSubjectCondition() throws {
         do {
-            let file = try OutlookRulesFile(data: Data([
+            let file = try OutlookRules(data: Data([
                 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x14, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
@@ -236,15 +236,16 @@ final class ImportConditionTests: XCTestCase {
             XCTAssertEqual(1, file.rules.count)
             XCTAssertEqual(1, file.rules[0].conditions.count)
             XCTAssertEqual(.specificWordsInSubjectCondition, file.rules[0].conditions[0].identifier)
-            XCTAssertTrue(file.rules[0].conditions[0].data is StringsListRuleElementData)
+            XCTAssertEqual(1, file.rules[0].conditions[0].parameters.count)
+            XCTAssertTrue(file.rules[0].conditions[0].parameter is StringParameter)
             XCTAssertEqual(0, file.rules[0].actions.count)
             XCTAssertEqual(0, file.rules[0].exceptions.count)
-            
-            let condition = file.rules[0].conditions[0].data as! StringsListRuleElementData
-            XCTAssertEqual(["phrase"], condition.entries)
+
+            let condition = file.rules[0].conditions[0].parameters[0] as! StringParameter
+            XCTAssertEqual("phrase", condition.value)
         }
         do {
-            let file = try OutlookRulesFile(data: Data([
+            let file = try OutlookRules(data: Data([
                 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x14, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
@@ -262,18 +263,22 @@ final class ImportConditionTests: XCTestCase {
             XCTAssertEqual(1, file.rules.count)
             XCTAssertEqual(1, file.rules[0].conditions.count)
             XCTAssertEqual(.specificWordsInSubjectCondition, file.rules[0].conditions[0].identifier)
-            XCTAssertTrue(file.rules[0].conditions[0].data is StringsListRuleElementData)
+            XCTAssertEqual(2, file.rules[0].conditions[0].parameters.count)
+            XCTAssertTrue(file.rules[0].conditions[0].parameters[0] is StringParameter)
+            XCTAssertTrue(file.rules[0].conditions[0].parameters[1] is StringParameter)
             XCTAssertEqual(0, file.rules[0].actions.count)
             XCTAssertEqual(0, file.rules[0].exceptions.count)
-            
-            let condition = file.rules[0].conditions[0].data as! StringsListRuleElementData
-            XCTAssertEqual(["phrase", "other"], condition.entries)
+
+            let condition1 = file.rules[0].conditions[0].parameters[0] as! StringParameter
+            XCTAssertEqual("phrase", condition1.value)
+            let condition2 = file.rules[0].conditions[0].parameters[1] as! StringParameter
+            XCTAssertEqual("other", condition2.value)
         }
     }
 
     func testThroughAccountCondition() throws {
         do {
-            let file = try OutlookRulesFile(data: Data([
+            let file = try OutlookRules(data: Data([
                 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x14, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
@@ -295,20 +300,20 @@ final class ImportConditionTests: XCTestCase {
             XCTAssertEqual(1, file.rules.count)
             XCTAssertEqual(2, file.rules[0].conditions.count)
             XCTAssertEqual(.throughSpecifiedAccountCondition, file.rules[0].conditions[0].identifier)
-            XCTAssertTrue(file.rules[0].conditions[0].data is ThroughAccountRuleElementData)
+            XCTAssertTrue(file.rules[0].conditions[0].parameter is AccountParameter)
             XCTAssertEqual(0, file.rules[0].actions.count)
             XCTAssertEqual(0, file.rules[0].exceptions.count)
 
-            let condition = file.rules[0].conditions[0].data as! ThroughAccountRuleElementData
+            let condition = file.rules[0].conditions[0].parameter as! AccountParameter
             XCTAssertEqual("hughbellars@gmail.com", condition.accountName)
             XCTAssertEqual("-190692068", condition.unknown)
-            XCTAssertTrue(file.rules[0].conditions[1].data is OnThisComputerOnlyRuleElementData)
+            XCTAssertTrue(file.rules[0].conditions[1].parameter is ProfileStampParameter)
         }
     }
 
     func testSentOnlyToMeCondition() throws {
         do {
-            let file = try OutlookRulesFile(data: Data([
+            let file = try OutlookRules(data: Data([
                 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x14, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
@@ -324,7 +329,7 @@ final class ImportConditionTests: XCTestCase {
             XCTAssertEqual(1, file.rules.count)
             XCTAssertEqual(1, file.rules[0].conditions.count)
             XCTAssertEqual(.sentOnlyToMeCondition, file.rules[0].conditions[0].identifier)
-            XCTAssertTrue(file.rules[0].conditions[0].data is SimpleRuleElementData)
+            XCTAssertEqual(0, file.rules[0].conditions[0].parameters.count)
             XCTAssertEqual(0, file.rules[0].actions.count)
             XCTAssertEqual(0, file.rules[0].exceptions.count)
         }
@@ -332,7 +337,7 @@ final class ImportConditionTests: XCTestCase {
 
     func testNameInToBoxCondition() throws {
         do {
-            let file = try OutlookRulesFile(data: Data([
+            let file = try OutlookRules(data: Data([
                 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x14, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
@@ -348,7 +353,7 @@ final class ImportConditionTests: XCTestCase {
             XCTAssertEqual(1, file.rules.count)
             XCTAssertEqual(1, file.rules[0].conditions.count)
             XCTAssertEqual(.nameInToBoxCondition, file.rules[0].conditions[0].identifier)
-            XCTAssertTrue(file.rules[0].conditions[0].data is SimpleRuleElementData)
+            XCTAssertEqual(0, file.rules[0].conditions[0].parameters.count)
             XCTAssertEqual(0, file.rules[0].actions.count)
             XCTAssertEqual(0, file.rules[0].exceptions.count)
         }
@@ -356,7 +361,7 @@ final class ImportConditionTests: XCTestCase {
 
     func testImportance() throws {
         do {
-            let file = try OutlookRulesFile(data: Data([
+            let file = try OutlookRules(data: Data([
                 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x14, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
@@ -373,15 +378,15 @@ final class ImportConditionTests: XCTestCase {
             XCTAssertEqual(1, file.rules.count)
             XCTAssertEqual(1, file.rules[0].conditions.count)
             XCTAssertEqual(.importanceCondition, file.rules[0].conditions[0].identifier)
-            XCTAssertTrue(file.rules[0].conditions[0].data is ImportanceRuleElementData)
+            XCTAssertTrue(file.rules[0].conditions[0].parameter is ImportanceParameter)
             XCTAssertEqual(0, file.rules[0].actions.count)
             XCTAssertEqual(0, file.rules[0].exceptions.count)
-            
-            let condition = file.rules[0].conditions[0].data as! ImportanceRuleElementData
+
+            let condition = file.rules[0].conditions[0].parameter as! ImportanceParameter
             XCTAssertEqual(MessageImportance.low, condition.importance)
         }
         do {
-            let file = try OutlookRulesFile(data: Data([
+            let file = try OutlookRules(data: Data([
                 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x14, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
@@ -398,15 +403,15 @@ final class ImportConditionTests: XCTestCase {
             XCTAssertEqual(1, file.rules.count)
             XCTAssertEqual(1, file.rules[0].conditions.count)
             XCTAssertEqual(.importanceCondition, file.rules[0].conditions[0].identifier)
-            XCTAssertTrue(file.rules[0].conditions[0].data is ImportanceRuleElementData)
+            XCTAssertTrue(file.rules[0].conditions[0].parameter is ImportanceParameter)
             XCTAssertEqual(0, file.rules[0].actions.count)
             XCTAssertEqual(0, file.rules[0].exceptions.count)
-            
-            let condition = file.rules[0].conditions[0].data as! ImportanceRuleElementData
+
+            let condition = file.rules[0].conditions[0].parameter as! ImportanceParameter
             XCTAssertEqual(MessageImportance.normal, condition.importance)
         }
         do {
-            let file = try OutlookRulesFile(data: Data([
+            let file = try OutlookRules(data: Data([
                 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x14, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
@@ -423,15 +428,15 @@ final class ImportConditionTests: XCTestCase {
             XCTAssertEqual(1, file.rules.count)
             XCTAssertEqual(1, file.rules[0].conditions.count)
             XCTAssertEqual(.importanceCondition, file.rules[0].conditions[0].identifier)
-            XCTAssertTrue(file.rules[0].conditions[0].data is ImportanceRuleElementData)
+            XCTAssertTrue(file.rules[0].conditions[0].parameter is ImportanceParameter)
             XCTAssertEqual(0, file.rules[0].actions.count)
             XCTAssertEqual(0, file.rules[0].exceptions.count)
-            
-            let condition = file.rules[0].conditions[0].data as! ImportanceRuleElementData
+
+            let condition = file.rules[0].conditions[0].parameter as! ImportanceParameter
             XCTAssertEqual(MessageImportance.high, condition.importance)
         }
         do {
-            let file = try OutlookRulesFile(data: Data([
+            let file = try OutlookRules(data: Data([
                 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x14, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
@@ -448,18 +453,18 @@ final class ImportConditionTests: XCTestCase {
             XCTAssertEqual(1, file.rules.count)
             XCTAssertEqual(1, file.rules[0].conditions.count)
             XCTAssertEqual(.importanceCondition, file.rules[0].conditions[0].identifier)
-            XCTAssertTrue(file.rules[0].conditions[0].data is ImportanceRuleElementData)
+            XCTAssertTrue(file.rules[0].conditions[0].parameter is ImportanceParameter)
             XCTAssertEqual(0, file.rules[0].actions.count)
             XCTAssertEqual(0, file.rules[0].exceptions.count)
-            
-            let condition = file.rules[0].conditions[0].data as! ImportanceRuleElementData
+
+            let condition = file.rules[0].conditions[0].parameter as! ImportanceParameter
             XCTAssertEqual(0x03, condition.rawImportance)
         }
     }
 
     func testSensitivityCondition() throws {
         do {
-            let file = try OutlookRulesFile(data: Data([
+            let file = try OutlookRules(data: Data([
                 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x14, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
@@ -476,15 +481,15 @@ final class ImportConditionTests: XCTestCase {
             XCTAssertEqual(1, file.rules.count)
             XCTAssertEqual(1, file.rules[0].conditions.count)
             XCTAssertEqual(.sensitivityCondition, file.rules[0].conditions[0].identifier)
-            XCTAssertTrue(file.rules[0].conditions[0].data is SensitivityRuleElementData)
+            XCTAssertTrue(file.rules[0].conditions[0].parameter is SensitivityParameter)
             XCTAssertEqual(0, file.rules[0].actions.count)
             XCTAssertEqual(0, file.rules[0].exceptions.count)
-            
-            let condition = file.rules[0].conditions[0].data as! SensitivityRuleElementData
+
+            let condition = file.rules[0].conditions[0].parameter as! SensitivityParameter
             XCTAssertEqual(MessageSensitivity.normal, condition.sensitivity)
         }
         do {
-            let file = try OutlookRulesFile(data: Data([
+            let file = try OutlookRules(data: Data([
                 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x14, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
@@ -501,15 +506,15 @@ final class ImportConditionTests: XCTestCase {
             XCTAssertEqual(1, file.rules.count)
             XCTAssertEqual(1, file.rules[0].conditions.count)
             XCTAssertEqual(.sensitivityCondition, file.rules[0].conditions[0].identifier)
-            XCTAssertTrue(file.rules[0].conditions[0].data is SensitivityRuleElementData)
+            XCTAssertTrue(file.rules[0].conditions[0].parameter is SensitivityParameter)
             XCTAssertEqual(0, file.rules[0].actions.count)
             XCTAssertEqual(0, file.rules[0].exceptions.count)
-            
-            let condition = file.rules[0].conditions[0].data as! SensitivityRuleElementData
+
+            let condition = file.rules[0].conditions[0].parameter as! SensitivityParameter
             XCTAssertEqual(MessageSensitivity.personal, condition.sensitivity)
         }
         do {
-            let file = try OutlookRulesFile(data: Data([
+            let file = try OutlookRules(data: Data([
                 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x14, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
@@ -526,15 +531,15 @@ final class ImportConditionTests: XCTestCase {
             XCTAssertEqual(1, file.rules.count)
             XCTAssertEqual(1, file.rules[0].conditions.count)
             XCTAssertEqual(.sensitivityCondition, file.rules[0].conditions[0].identifier)
-            XCTAssertTrue(file.rules[0].conditions[0].data is SensitivityRuleElementData)
+            XCTAssertTrue(file.rules[0].conditions[0].parameter is SensitivityParameter)
             XCTAssertEqual(0, file.rules[0].actions.count)
             XCTAssertEqual(0, file.rules[0].exceptions.count)
-            
-            let condition = file.rules[0].conditions[0].data as! SensitivityRuleElementData
+
+            let condition = file.rules[0].conditions[0].parameter as! SensitivityParameter
             XCTAssertEqual(MessageSensitivity.`private`, condition.sensitivity)
         }
         do {
-            let file = try OutlookRulesFile(data: Data([
+            let file = try OutlookRules(data: Data([
                 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x14, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
@@ -551,15 +556,15 @@ final class ImportConditionTests: XCTestCase {
             XCTAssertEqual(1, file.rules.count)
             XCTAssertEqual(1, file.rules[0].conditions.count)
             XCTAssertEqual(.sensitivityCondition, file.rules[0].conditions[0].identifier)
-            XCTAssertTrue(file.rules[0].conditions[0].data is SensitivityRuleElementData)
+            XCTAssertTrue(file.rules[0].conditions[0].parameter is SensitivityParameter)
             XCTAssertEqual(0, file.rules[0].actions.count)
             XCTAssertEqual(0, file.rules[0].exceptions.count)
-            
-            let condition = file.rules[0].conditions[0].data as! SensitivityRuleElementData
+
+            let condition = file.rules[0].conditions[0].parameter as! SensitivityParameter
             XCTAssertEqual(MessageSensitivity.confidential, condition.sensitivity)
         }
         do {
-            let file = try OutlookRulesFile(data: Data([
+            let file = try OutlookRules(data: Data([
                 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x14, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
@@ -576,18 +581,18 @@ final class ImportConditionTests: XCTestCase {
             XCTAssertEqual(1, file.rules.count)
             XCTAssertEqual(1, file.rules[0].conditions.count)
             XCTAssertEqual(.sensitivityCondition, file.rules[0].conditions[0].identifier)
-            XCTAssertTrue(file.rules[0].conditions[0].data is SensitivityRuleElementData)
+            XCTAssertTrue(file.rules[0].conditions[0].parameter is SensitivityParameter)
             XCTAssertEqual(0, file.rules[0].actions.count)
             XCTAssertEqual(0, file.rules[0].exceptions.count)
-            
-            let condition = file.rules[0].conditions[0].data as! SensitivityRuleElementData
+
+            let condition = file.rules[0].conditions[0].parameter as! SensitivityParameter
             XCTAssertEqual(0x04, condition.rawSensitivity)
         }
     }
 
     func testFlaggedForActionCondition() throws {
         do {
-            let file = try OutlookRulesFile(data: Data([
+            let file = try OutlookRules(data: Data([
                 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x14, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
@@ -605,18 +610,18 @@ final class ImportConditionTests: XCTestCase {
             XCTAssertEqual(1, file.rules.count)
             XCTAssertEqual(1, file.rules[0].conditions.count)
             XCTAssertEqual(.flaggedForActionCondition, file.rules[0].conditions[0].identifier)
-            XCTAssertTrue(file.rules[0].conditions[0].data is FlaggedForActionRuleElementData)
+            XCTAssertTrue(file.rules[0].conditions[0].parameter is FlaggedForActionParameter)
             XCTAssertEqual(0, file.rules[0].actions.count)
             XCTAssertEqual(0, file.rules[0].exceptions.count)
-            
-            let condition = file.rules[0].conditions[0].data as! FlaggedForActionRuleElementData
+
+            let condition = file.rules[0].conditions[0].parameter as! FlaggedForActionParameter
             XCTAssertEqual("Follow up", condition.action)
         }
     }
 
     func testNameInCcBoxCondition() throws {
         do {
-            let file = try OutlookRulesFile(data: Data([
+            let file = try OutlookRules(data: Data([
                 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x14, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
@@ -632,7 +637,7 @@ final class ImportConditionTests: XCTestCase {
             XCTAssertEqual(1, file.rules.count)
             XCTAssertEqual(1, file.rules[0].conditions.count)
             XCTAssertEqual(.nameInCcBoxCondition, file.rules[0].conditions[0].identifier)
-            XCTAssertTrue(file.rules[0].conditions[0].data is SimpleRuleElementData)
+            XCTAssertEqual(0, file.rules[0].conditions[0].parameters.count)
             XCTAssertEqual(0, file.rules[0].actions.count)
             XCTAssertEqual(0, file.rules[0].exceptions.count)
         }
@@ -640,7 +645,7 @@ final class ImportConditionTests: XCTestCase {
 
     func testNameInToOrCcBoxCondition() throws {
         do {
-            let file = try OutlookRulesFile(data: Data([
+            let file = try OutlookRules(data: Data([
                 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x14, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
@@ -656,7 +661,7 @@ final class ImportConditionTests: XCTestCase {
             XCTAssertEqual(1, file.rules.count)
             XCTAssertEqual(1, file.rules[0].conditions.count)
             XCTAssertEqual(.nameInToOrCcBoxCondition, file.rules[0].conditions[0].identifier)
-            XCTAssertTrue(file.rules[0].conditions[0].data is SimpleRuleElementData)
+            XCTAssertEqual(0, file.rules[0].conditions[0].parameters.count)
             XCTAssertEqual(0, file.rules[0].actions.count)
             XCTAssertEqual(0, file.rules[0].exceptions.count)
         }
@@ -664,7 +669,7 @@ final class ImportConditionTests: XCTestCase {
 
     func testNameNotInToBoxCondition() throws {
         do {
-            let file = try OutlookRulesFile(data: Data([
+            let file = try OutlookRules(data: Data([
                 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x14, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
@@ -680,7 +685,7 @@ final class ImportConditionTests: XCTestCase {
             XCTAssertEqual(1, file.rules.count)
             XCTAssertEqual(1, file.rules[0].conditions.count)
             XCTAssertEqual(.nameNotInToBoxCondition, file.rules[0].conditions[0].identifier)
-            XCTAssertTrue(file.rules[0].conditions[0].data is SimpleRuleElementData)
+            XCTAssertEqual(0, file.rules[0].conditions[0].parameters.count)
             XCTAssertEqual(0, file.rules[0].actions.count)
             XCTAssertEqual(0, file.rules[0].exceptions.count)
         }
@@ -688,7 +693,7 @@ final class ImportConditionTests: XCTestCase {
 
     func testSentToCondition() throws {
         do {
-            let file = try OutlookRulesFile(data: Data([
+            let file = try OutlookRules(data: Data([
                 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x14, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
@@ -713,11 +718,11 @@ final class ImportConditionTests: XCTestCase {
             XCTAssertEqual(1, file.rules.count)
             XCTAssertEqual(1, file.rules[0].conditions.count)
             XCTAssertEqual(.sentToCondition, file.rules[0].conditions[0].identifier)
-            XCTAssertTrue(file.rules[0].conditions[0].data is PeopleOrPublicGroupListRuleElementData)
+            XCTAssertTrue(file.rules[0].conditions[0].parameter is AddressParameter)
             XCTAssertEqual(0, file.rules[0].actions.count)
             XCTAssertEqual(0, file.rules[0].exceptions.count)
-            
-            let condition = file.rules[0].conditions[0].data as! PeopleOrPublicGroupListRuleElementData
+
+            let condition = file.rules[0].conditions[0].parameter as!AddressParameter
             XCTAssertEqual(1, condition.values.count)
             XCTAssertEqual(6, condition.values[0].count)
             XCTAssertEqual(MAPI_E.NOT_FOUND.rawValue, condition.values[0][PropertyId.tagSmtpAddress.rawValue] as! UInt32)
@@ -728,7 +733,7 @@ final class ImportConditionTests: XCTestCase {
             XCTAssertEqual(1, condition.values[0][PropertyId.tagRecipientType.rawValue] as! UInt32)
         }
         do {
-            let file = try OutlookRulesFile(data: Data([
+            let file = try OutlookRules(data: Data([
                 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x14, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
@@ -796,10 +801,10 @@ final class ImportConditionTests: XCTestCase {
             XCTAssertEqual(1, file.rules.count)
             XCTAssertEqual(1, file.rules[0].conditions.count)
             XCTAssertEqual(.sentToCondition, file.rules[0].conditions[0].identifier)
-            XCTAssertTrue(file.rules[0].conditions[0].data is PeopleOrPublicGroupListRuleElementData)
+            XCTAssertTrue(file.rules[0].conditions[0].parameter is AddressParameter)
             XCTAssertEqual(0, file.rules[0].actions.count)
-            
-            let condition = file.rules[0].conditions[0].data as! PeopleOrPublicGroupListRuleElementData
+
+            let condition = file.rules[0].conditions[0].parameter as!AddressParameter
             XCTAssertEqual(2, condition.values.count)
             XCTAssertEqual(11, condition.values[0].count)
             XCTAssertEqual(MAPI_E.NOT_FOUND.rawValue, condition.values[0][PropertyId.tagSmtpAddress.rawValue] as! UInt32)
@@ -821,7 +826,7 @@ final class ImportConditionTests: XCTestCase {
 
     func testSpecificWordsInBodyCondition() throws {
         do {
-            let file = try OutlookRulesFile(data: Data([
+            let file = try OutlookRules(data: Data([
                 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x14, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
@@ -838,15 +843,16 @@ final class ImportConditionTests: XCTestCase {
             XCTAssertEqual(1, file.rules.count)
             XCTAssertEqual(1, file.rules[0].conditions.count)
             XCTAssertEqual(.specificWordsInBodyCondition, file.rules[0].conditions[0].identifier)
-            XCTAssertTrue(file.rules[0].conditions[0].data is StringsListRuleElementData)
+            XCTAssertEqual(1, file.rules[0].conditions[0].parameters.count)
+            XCTAssertTrue(file.rules[0].conditions[0].parameter is StringParameter)
             XCTAssertEqual(0, file.rules[0].actions.count)
             XCTAssertEqual(0, file.rules[0].exceptions.count)
-            
-            let condition = file.rules[0].conditions[0].data as! StringsListRuleElementData
-            XCTAssertEqual(["phrase"], condition.entries)
+
+            let condition = file.rules[0].conditions[0].parameters[0] as! StringParameter
+            XCTAssertEqual("phrase", condition.value)
         }
         do {
-            let file = try OutlookRulesFile(data: Data([
+            let file = try OutlookRules(data: Data([
                 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x14, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
@@ -864,18 +870,22 @@ final class ImportConditionTests: XCTestCase {
             XCTAssertEqual(1, file.rules.count)
             XCTAssertEqual(1, file.rules[0].conditions.count)
             XCTAssertEqual(.specificWordsInBodyCondition, file.rules[0].conditions[0].identifier)
-            XCTAssertTrue(file.rules[0].conditions[0].data is StringsListRuleElementData)
+            XCTAssertEqual(2, file.rules[0].conditions[0].parameters.count)
+            XCTAssertTrue(file.rules[0].conditions[0].parameters[0] is StringParameter)
+            XCTAssertTrue(file.rules[0].conditions[0].parameters[1] is StringParameter)
             XCTAssertEqual(0, file.rules[0].actions.count)
             XCTAssertEqual(0, file.rules[0].exceptions.count)
-            
-            let condition = file.rules[0].conditions[0].data as! StringsListRuleElementData
-            XCTAssertEqual(["phrase", "other"], condition.entries)
+
+            let condition1 = file.rules[0].conditions[0].parameters[0] as! StringParameter
+            XCTAssertEqual("phrase", condition1.value)
+            let condition2 = file.rules[0].conditions[0].parameters[1] as! StringParameter
+            XCTAssertEqual("other", condition2.value)
         }
     }
 
     func testSpecificWordsInSubjectOrBodyCondition() throws {
         do {
-            let file = try OutlookRulesFile(data: Data([
+            let file = try OutlookRules(data: Data([
                 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x14, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
@@ -892,15 +902,16 @@ final class ImportConditionTests: XCTestCase {
             XCTAssertEqual(1, file.rules.count)
             XCTAssertEqual(1, file.rules[0].conditions.count)
             XCTAssertEqual(.specificWordsInSubjectOrBodyCondition, file.rules[0].conditions[0].identifier)
-            XCTAssertTrue(file.rules[0].conditions[0].data is StringsListRuleElementData)
+            XCTAssertEqual(1, file.rules[0].conditions[0].parameters.count)
+            XCTAssertTrue(file.rules[0].conditions[0].parameter is StringParameter)
             XCTAssertEqual(0, file.rules[0].actions.count)
             XCTAssertEqual(0, file.rules[0].exceptions.count)
-            
-            let condition = file.rules[0].conditions[0].data as! StringsListRuleElementData
-            XCTAssertEqual(["phrase"], condition.entries)
+
+            let condition = file.rules[0].conditions[0].parameters[0] as! StringParameter
+            XCTAssertEqual("phrase", condition.value)
         }
         do {
-            let file = try OutlookRulesFile(data: Data([
+            let file = try OutlookRules(data: Data([
                 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x14, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
@@ -918,18 +929,22 @@ final class ImportConditionTests: XCTestCase {
             XCTAssertEqual(1, file.rules.count)
             XCTAssertEqual(1, file.rules[0].conditions.count)
             XCTAssertEqual(.specificWordsInSubjectOrBodyCondition, file.rules[0].conditions[0].identifier)
-            XCTAssertTrue(file.rules[0].conditions[0].data is StringsListRuleElementData)
+            XCTAssertEqual(2, file.rules[0].conditions[0].parameters.count)
+            XCTAssertTrue(file.rules[0].conditions[0].parameters[0] is StringParameter)
+            XCTAssertTrue(file.rules[0].conditions[0].parameters[1] is StringParameter)
             XCTAssertEqual(0, file.rules[0].actions.count)
             XCTAssertEqual(0, file.rules[0].exceptions.count)
-            
-            let condition = file.rules[0].conditions[0].data as! StringsListRuleElementData
-            XCTAssertEqual(["phrase", "other"], condition.entries)
+
+            let condition1 = file.rules[0].conditions[0].parameters[0] as! StringParameter
+            XCTAssertEqual("phrase", condition1.value)
+            let condition2 = file.rules[0].conditions[0].parameters[1] as! StringParameter
+            XCTAssertEqual("other", condition2.value)
         }
     }
 
     func testSpecificWordsInMessageHeader() throws {
         do {
-            let file = try OutlookRulesFile(data: Data([
+            let file = try OutlookRules(data: Data([
                 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x14, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
@@ -946,15 +961,16 @@ final class ImportConditionTests: XCTestCase {
             XCTAssertEqual(1, file.rules.count)
             XCTAssertEqual(1, file.rules[0].conditions.count)
             XCTAssertEqual(.specificWordsInMessageHeaderCondition, file.rules[0].conditions[0].identifier)
-            XCTAssertTrue(file.rules[0].conditions[0].data is StringsListRuleElementData)
+            XCTAssertEqual(1, file.rules[0].conditions[0].parameters.count)
+            XCTAssertTrue(file.rules[0].conditions[0].parameter is StringParameter)
             XCTAssertEqual(0, file.rules[0].actions.count)
             XCTAssertEqual(0, file.rules[0].exceptions.count)
-            
-            let condition = file.rules[0].conditions[0].data as! StringsListRuleElementData
-            XCTAssertEqual(["phrase"], condition.entries)
+
+            let condition = file.rules[0].conditions[0].parameters[0] as! StringParameter
+            XCTAssertEqual("phrase", condition.value)
         }
         do {
-            let file = try OutlookRulesFile(data: Data([
+            let file = try OutlookRules(data: Data([
                 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x14, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
@@ -972,18 +988,22 @@ final class ImportConditionTests: XCTestCase {
             XCTAssertEqual(1, file.rules.count)
             XCTAssertEqual(1, file.rules[0].conditions.count)
             XCTAssertEqual(.specificWordsInMessageHeaderCondition, file.rules[0].conditions[0].identifier)
-            XCTAssertTrue(file.rules[0].conditions[0].data is StringsListRuleElementData)
+            XCTAssertEqual(2, file.rules[0].conditions[0].parameters.count)
+            XCTAssertTrue(file.rules[0].conditions[0].parameters[0] is StringParameter)
+            XCTAssertTrue(file.rules[0].conditions[0].parameters[1] is StringParameter)
             XCTAssertEqual(0, file.rules[0].actions.count)
             XCTAssertEqual(0, file.rules[0].exceptions.count)
-            
-            let condition = file.rules[0].conditions[0].data as! StringsListRuleElementData
-            XCTAssertEqual(["phrase", "other"], condition.entries)
+
+            let condition1 = file.rules[0].conditions[0].parameters[0] as! StringParameter
+            XCTAssertEqual("phrase", condition1.value)
+            let condition2 = file.rules[0].conditions[0].parameters[1] as! StringParameter
+            XCTAssertEqual("other", condition2.value)
         }
     }
 
     func testSpecificWordsInSendersAddress() throws {
         do {
-            let file = try OutlookRulesFile(data: Data([
+            let file = try OutlookRules(data: Data([
                 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x14, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
@@ -1000,15 +1020,16 @@ final class ImportConditionTests: XCTestCase {
             XCTAssertEqual(1, file.rules.count)
             XCTAssertEqual(1, file.rules[0].conditions.count)
             XCTAssertEqual(.specificWordsInSendersAddressCondition, file.rules[0].conditions[0].identifier)
-            XCTAssertTrue(file.rules[0].conditions[0].data is StringsListRuleElementData)
+            XCTAssertEqual(1, file.rules[0].conditions[0].parameters.count)
+            XCTAssertTrue(file.rules[0].conditions[0].parameter is StringParameter)
             XCTAssertEqual(0, file.rules[0].actions.count)
             XCTAssertEqual(0, file.rules[0].exceptions.count)
-            
-            let condition = file.rules[0].conditions[0].data as! StringsListRuleElementData
-            XCTAssertEqual(["phrase"], condition.entries)
+
+            let condition = file.rules[0].conditions[0].parameters[0] as! StringParameter
+            XCTAssertEqual("phrase", condition.value)
         }
         do {
-            let file = try OutlookRulesFile(data: Data([
+            let file = try OutlookRules(data: Data([
                 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x14, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
@@ -1026,18 +1047,22 @@ final class ImportConditionTests: XCTestCase {
             XCTAssertEqual(1, file.rules.count)
             XCTAssertEqual(1, file.rules[0].conditions.count)
             XCTAssertEqual(.specificWordsInSendersAddressCondition, file.rules[0].conditions[0].identifier)
-            XCTAssertTrue(file.rules[0].conditions[0].data is StringsListRuleElementData)
+            XCTAssertEqual(2, file.rules[0].conditions[0].parameters.count)
+            XCTAssertTrue(file.rules[0].conditions[0].parameters[0] is StringParameter)
+            XCTAssertTrue(file.rules[0].conditions[0].parameters[1] is StringParameter)
             XCTAssertEqual(0, file.rules[0].actions.count)
             XCTAssertEqual(0, file.rules[0].exceptions.count)
-            
-            let condition = file.rules[0].conditions[0].data as! StringsListRuleElementData
-            XCTAssertEqual(["phrase", "other"], condition.entries)
+
+            let condition1 = file.rules[0].conditions[0].parameters[0] as! StringParameter
+            XCTAssertEqual("phrase", condition1.value)
+            let condition2 = file.rules[0].conditions[0].parameters[1] as! StringParameter
+            XCTAssertEqual("other", condition2.value)
         }
     }
 
     func testSpecificWordsInRecipientsAddress() throws {
         do {
-            let file = try OutlookRulesFile(data: Data([
+            let file = try OutlookRules(data: Data([
                 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x14, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
@@ -1054,15 +1079,16 @@ final class ImportConditionTests: XCTestCase {
             XCTAssertEqual(1, file.rules.count)
             XCTAssertEqual(1, file.rules[0].conditions.count)
             XCTAssertEqual(.specificWordsInRecipientsAddressCondition, file.rules[0].conditions[0].identifier)
-            XCTAssertTrue(file.rules[0].conditions[0].data is StringsListRuleElementData)
+            XCTAssertEqual(1, file.rules[0].conditions[0].parameters.count)
+            XCTAssertTrue(file.rules[0].conditions[0].parameter is StringParameter)
             XCTAssertEqual(0, file.rules[0].actions.count)
             XCTAssertEqual(0, file.rules[0].exceptions.count)
-            
-            let condition = file.rules[0].conditions[0].data as! StringsListRuleElementData
-            XCTAssertEqual(["phrase"], condition.entries)
+
+            let condition = file.rules[0].conditions[0].parameters[0] as! StringParameter
+            XCTAssertEqual("phrase", condition.value)
         }
         do {
-            let file = try OutlookRulesFile(data: Data([
+            let file = try OutlookRules(data: Data([
                 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x14, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
@@ -1080,18 +1106,22 @@ final class ImportConditionTests: XCTestCase {
             XCTAssertEqual(1, file.rules.count)
             XCTAssertEqual(1, file.rules[0].conditions.count)
             XCTAssertEqual(.specificWordsInRecipientsAddressCondition, file.rules[0].conditions[0].identifier)
-            XCTAssertTrue(file.rules[0].conditions[0].data is StringsListRuleElementData)
+            XCTAssertEqual(2, file.rules[0].conditions[0].parameters.count)
+            XCTAssertTrue(file.rules[0].conditions[0].parameters[0] is StringParameter)
+            XCTAssertTrue(file.rules[0].conditions[0].parameters[1] is StringParameter)
             XCTAssertEqual(0, file.rules[0].actions.count)
             XCTAssertEqual(0, file.rules[0].exceptions.count)
-            
-            let condition = file.rules[0].conditions[0].data as! StringsListRuleElementData
-            XCTAssertEqual(["phrase", "other"], condition.entries)
+
+            let condition1 = file.rules[0].conditions[0].parameters[0] as! StringParameter
+            XCTAssertEqual("phrase", condition1.value)
+            let condition2 = file.rules[0].conditions[0].parameters[1] as! StringParameter
+            XCTAssertEqual("other", condition2.value)
         }
     }
 
     func testAssignedToCategoryCondition() throws {
         do {
-            let file = try OutlookRulesFile(data: Data([
+            let file = try OutlookRules(data: Data([
                 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x14, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
@@ -1109,15 +1139,15 @@ final class ImportConditionTests: XCTestCase {
             XCTAssertEqual(1, file.rules.count)
             XCTAssertEqual(1, file.rules[0].conditions.count)
             XCTAssertEqual(.assignedToCategoryCondition, file.rules[0].conditions[0].identifier)
-            XCTAssertTrue(file.rules[0].conditions[0].data is CategoriesListRuleElementData)
+            XCTAssertTrue(file.rules[0].conditions[0].parameter is CategoryParameter)
             XCTAssertEqual(0, file.rules[0].actions.count)
             XCTAssertEqual(0, file.rules[0].exceptions.count)
-            
-            let condition = file.rules[0].conditions[0].data as! CategoriesListRuleElementData
+
+            let condition = file.rules[0].conditions[0].parameter as!CategoryParameter
             XCTAssertEqual(["Blue Category"], condition.categories)
         }
         do {
-            let file = try OutlookRulesFile(data: Data([
+            let file = try OutlookRules(data: Data([
                 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x14, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
@@ -1136,18 +1166,18 @@ final class ImportConditionTests: XCTestCase {
             XCTAssertEqual(1, file.rules.count)
             XCTAssertEqual(1, file.rules[0].conditions.count)
             XCTAssertEqual(.assignedToCategoryCondition, file.rules[0].conditions[0].identifier)
-            XCTAssertTrue(file.rules[0].conditions[0].data is CategoriesListRuleElementData)
+            XCTAssertTrue(file.rules[0].conditions[0].parameter is CategoryParameter)
             XCTAssertEqual(0, file.rules[0].actions.count)
             XCTAssertEqual(0, file.rules[0].exceptions.count)
-            
-            let condition = file.rules[0].conditions[0].data as! CategoriesListRuleElementData
+
+            let condition = file.rules[0].conditions[0].parameter as!CategoryParameter
             XCTAssertEqual(["Blue Category", "Other"], condition.categories)
         }
     }
 
     func testAssignedToAnyCategoryCondition() throws {
         do {
-            let file = try OutlookRulesFile(data: Data([
+            let file = try OutlookRules(data: Data([
                 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x14, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
@@ -1163,7 +1193,7 @@ final class ImportConditionTests: XCTestCase {
             XCTAssertEqual(1, file.rules.count)
             XCTAssertEqual(1, file.rules[0].conditions.count)
             XCTAssertEqual(.assignedToAnyCategoryCondition, file.rules[0].conditions[0].identifier)
-            XCTAssertTrue(file.rules[0].conditions[0].data is SimpleRuleElementData)
+            XCTAssertEqual(0, file.rules[0].conditions[0].parameters.count)
             XCTAssertEqual(0, file.rules[0].actions.count)
             XCTAssertEqual(0, file.rules[0].exceptions.count)
         }
@@ -1171,7 +1201,7 @@ final class ImportConditionTests: XCTestCase {
 
     func testWhichIsAnAutomaticReplyCondition() throws {
         do {
-            let file = try OutlookRulesFile(data: Data([
+            let file = try OutlookRules(data: Data([
                 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x14, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
@@ -1187,7 +1217,7 @@ final class ImportConditionTests: XCTestCase {
             XCTAssertEqual(1, file.rules.count)
             XCTAssertEqual(1, file.rules[0].conditions.count)
             XCTAssertEqual(.automaticReplyCondition, file.rules[0].conditions[0].identifier)
-            XCTAssertTrue(file.rules[0].conditions[0].data is SimpleRuleElementData)
+            XCTAssertEqual(0, file.rules[0].conditions[0].parameters.count)
             XCTAssertEqual(0, file.rules[0].actions.count)
             XCTAssertEqual(0, file.rules[0].exceptions.count)
         }
@@ -1195,7 +1225,7 @@ final class ImportConditionTests: XCTestCase {
 
     func testHasAttachmentCondition() throws {
         do {
-            let file = try OutlookRulesFile(data: Data([
+            let file = try OutlookRules(data: Data([
                 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x14, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
@@ -1211,7 +1241,7 @@ final class ImportConditionTests: XCTestCase {
             XCTAssertEqual(1, file.rules.count)
             XCTAssertEqual(1, file.rules[0].conditions.count)
             XCTAssertEqual(.hasAttachmentCondition, file.rules[0].conditions[0].identifier)
-            XCTAssertTrue(file.rules[0].conditions[0].data is SimpleRuleElementData)
+            XCTAssertEqual(0, file.rules[0].conditions[0].parameters.count)
             XCTAssertEqual(0, file.rules[0].actions.count)
             XCTAssertEqual(0, file.rules[0].exceptions.count)
         }
@@ -1219,7 +1249,7 @@ final class ImportConditionTests: XCTestCase {
 
     func testSizeInSpecificRangeCondition() throws {
         do {
-            let file = try OutlookRulesFile(data: Data([
+            let file = try OutlookRules(data: Data([
                 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x14, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
@@ -1236,16 +1266,16 @@ final class ImportConditionTests: XCTestCase {
             XCTAssertEqual(1, file.rules.count)
             XCTAssertEqual(1, file.rules[0].conditions.count)
             XCTAssertEqual(.sizeInSpecificRangeCondition, file.rules[0].conditions[0].identifier)
-            XCTAssertTrue(file.rules[0].conditions[0].data is SizeInSpecificRangeRuleElementData)
+            XCTAssertTrue(file.rules[0].conditions[0].parameter is SizeParameter)
             XCTAssertEqual(0, file.rules[0].actions.count)
             XCTAssertEqual(0, file.rules[0].exceptions.count)
-            
-            let condition = file.rules[0].conditions[0].data as! SizeInSpecificRangeRuleElementData
+
+            let condition = file.rules[0].conditions[0].parameter as! SizeParameter
             XCTAssertEqual(0, condition.minSizeInKilobytes)
             XCTAssertEqual(0, condition.maxSizeInKilobytes)
         }
         do {
-            let file = try OutlookRulesFile(data: Data([
+            let file = try OutlookRules(data: Data([
                 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x14, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
@@ -1262,16 +1292,16 @@ final class ImportConditionTests: XCTestCase {
             XCTAssertEqual(1, file.rules.count)
             XCTAssertEqual(1, file.rules[0].conditions.count)
             XCTAssertEqual(.sizeInSpecificRangeCondition, file.rules[0].conditions[0].identifier)
-            XCTAssertTrue(file.rules[0].conditions[0].data is SizeInSpecificRangeRuleElementData)
+            XCTAssertTrue(file.rules[0].conditions[0].parameter is SizeParameter)
             XCTAssertEqual(0, file.rules[0].actions.count)
             XCTAssertEqual(0, file.rules[0].exceptions.count)
-            
-            let condition = file.rules[0].conditions[0].data as! SizeInSpecificRangeRuleElementData
+
+            let condition = file.rules[0].conditions[0].parameter as! SizeParameter
             XCTAssertEqual(1, condition.minSizeInKilobytes)
             XCTAssertEqual(0, condition.maxSizeInKilobytes)
         }
         do {
-            let file = try OutlookRulesFile(data: Data([
+            let file = try OutlookRules(data: Data([
                 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x14, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
@@ -1288,16 +1318,16 @@ final class ImportConditionTests: XCTestCase {
             XCTAssertEqual(1, file.rules.count)
             XCTAssertEqual(1, file.rules[0].conditions.count)
             XCTAssertEqual(.sizeInSpecificRangeCondition, file.rules[0].conditions[0].identifier)
-            XCTAssertTrue(file.rules[0].conditions[0].data is SizeInSpecificRangeRuleElementData)
+            XCTAssertTrue(file.rules[0].conditions[0].parameter is SizeParameter)
             XCTAssertEqual(0, file.rules[0].actions.count)
             XCTAssertEqual(0, file.rules[0].exceptions.count)
-            
-            let condition = file.rules[0].conditions[0].data as! SizeInSpecificRangeRuleElementData
+
+            let condition = file.rules[0].conditions[0].parameter as! SizeParameter
             XCTAssertEqual(0, condition.minSizeInKilobytes)
             XCTAssertEqual(1, condition.maxSizeInKilobytes)
         }
         do {
-            let file = try OutlookRulesFile(data: Data([
+            let file = try OutlookRules(data: Data([
                 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x14, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
@@ -1314,16 +1344,16 @@ final class ImportConditionTests: XCTestCase {
             XCTAssertEqual(1, file.rules.count)
             XCTAssertEqual(1, file.rules[0].conditions.count)
             XCTAssertEqual(.sizeInSpecificRangeCondition, file.rules[0].conditions[0].identifier)
-            XCTAssertTrue(file.rules[0].conditions[0].data is SizeInSpecificRangeRuleElementData)
+            XCTAssertTrue(file.rules[0].conditions[0].parameter is SizeParameter)
             XCTAssertEqual(0, file.rules[0].actions.count)
             XCTAssertEqual(0, file.rules[0].exceptions.count)
-            
-            let condition = file.rules[0].conditions[0].data as! SizeInSpecificRangeRuleElementData
+
+            let condition = file.rules[0].conditions[0].parameter as! SizeParameter
             XCTAssertEqual(1, condition.minSizeInKilobytes)
             XCTAssertEqual(1, condition.maxSizeInKilobytes)
         }
         do {
-            let file = try OutlookRulesFile(data: Data([
+            let file = try OutlookRules(data: Data([
                 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x14, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
@@ -1340,11 +1370,11 @@ final class ImportConditionTests: XCTestCase {
             XCTAssertEqual(1, file.rules.count)
             XCTAssertEqual(1, file.rules[0].conditions.count)
             XCTAssertEqual(.sizeInSpecificRangeCondition, file.rules[0].conditions[0].identifier)
-            XCTAssertTrue(file.rules[0].conditions[0].data is SizeInSpecificRangeRuleElementData)
+            XCTAssertTrue(file.rules[0].conditions[0].parameter is SizeParameter)
             XCTAssertEqual(0, file.rules[0].actions.count)
             XCTAssertEqual(0, file.rules[0].exceptions.count)
-            
-            let condition = file.rules[0].conditions[0].data as! SizeInSpecificRangeRuleElementData
+
+            let condition = file.rules[0].conditions[0].parameter as! SizeParameter
             XCTAssertEqual(1, condition.minSizeInKilobytes)
             XCTAssertEqual(999999, condition.maxSizeInKilobytes)
         }
@@ -1355,7 +1385,7 @@ final class ImportConditionTests: XCTestCase {
         var calendar = Calendar(identifier: .gregorian)
         calendar.timeZone = timeZone
         do {
-            let file = try OutlookRulesFile(data: Data([
+            let file = try OutlookRules(data: Data([
                 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x14, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
@@ -1374,18 +1404,18 @@ final class ImportConditionTests: XCTestCase {
             XCTAssertEqual(1, file.rules.count)
             XCTAssertEqual(1, file.rules[0].conditions.count)
             XCTAssertEqual(.receivedInSpecificDateSpanCondition, file.rules[0].conditions[0].identifier)
-            XCTAssertTrue(file.rules[0].conditions[0].data is ReceivedInSpecificDateSpanRuleElementData)
+            XCTAssertTrue(file.rules[0].conditions[0].parameter is TimeParameter)
             XCTAssertEqual(0, file.rules[0].actions.count)
             XCTAssertEqual(0, file.rules[0].exceptions.count)
-            
-            let condition = file.rules[0].conditions[0].data as! ReceivedInSpecificDateSpanRuleElementData
+
+            let condition = file.rules[0].conditions[0].parameter as! TimeParameter
             XCTAssertTrue(condition.includeAfterDate)
             XCTAssertEqual(calendar.date(from: DateComponents(timeZone: timeZone, year: 2020, month: 08, day: 08, hour: 23, minute: 59, second: 0)), condition.afterDate.date)
             XCTAssertFalse(condition.includeBeforeDate)
-                XCTAssertEqual(calendar.date(from: DateComponents(timeZone: timeZone, year: 2020, month: 08, day: 09)), condition.beforeDate.date)
+            XCTAssertEqual(calendar.date(from: DateComponents(timeZone: timeZone, year: 2020, month: 08, day: 09)), condition.beforeDate.date)
         }
         do {
-            let file = try OutlookRulesFile(data: Data([
+            let file = try OutlookRules(data: Data([
                 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x14, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
@@ -1404,18 +1434,18 @@ final class ImportConditionTests: XCTestCase {
             XCTAssertEqual(1, file.rules.count)
             XCTAssertEqual(1, file.rules[0].conditions.count)
             XCTAssertEqual(.receivedInSpecificDateSpanCondition, file.rules[0].conditions[0].identifier)
-            XCTAssertTrue(file.rules[0].conditions[0].data is ReceivedInSpecificDateSpanRuleElementData)
+            XCTAssertTrue(file.rules[0].conditions[0].parameter is TimeParameter)
             XCTAssertEqual(0, file.rules[0].actions.count)
             XCTAssertEqual(0, file.rules[0].exceptions.count)
-            
-            let condition = file.rules[0].conditions[0].data as! ReceivedInSpecificDateSpanRuleElementData
+
+            let condition = file.rules[0].conditions[0].parameter as! TimeParameter
             XCTAssertFalse(condition.includeAfterDate)
             XCTAssertEqual(calendar.date(from: DateComponents(timeZone: timeZone, year: 2020, month: 08, day: 09, hour: 23, minute: 59, second: 0)), condition.afterDate.date)
             XCTAssertTrue(condition.includeBeforeDate)
             XCTAssertEqual(calendar.date(from: DateComponents(timeZone: timeZone, year: 2020, month: 08, day: 02)), condition.beforeDate.date)
         }
         do {
-            let file = try OutlookRulesFile(data: Data([
+            let file = try OutlookRules(data: Data([
                 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x14, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
@@ -1434,12 +1464,12 @@ final class ImportConditionTests: XCTestCase {
             XCTAssertEqual(1, file.rules.count)
             XCTAssertEqual(1, file.rules[0].conditions.count)
             XCTAssertEqual(.receivedInSpecificDateSpanCondition, file.rules[0].conditions[0].identifier)
-            XCTAssertTrue(file.rules[0].conditions[0].data is ReceivedInSpecificDateSpanRuleElementData)
+            XCTAssertTrue(file.rules[0].conditions[0].parameter is TimeParameter)
             XCTAssertEqual(0, file.rules[0].actions.count)
             XCTAssertEqual(0, file.rules[0].exceptions.count)
-            
+
             let calendar = Calendar(identifier: .gregorian)
-            let condition = file.rules[0].conditions[0].data as! ReceivedInSpecificDateSpanRuleElementData
+            let condition = file.rules[0].conditions[0].parameter as! TimeParameter
             XCTAssertTrue(condition.includeAfterDate)
             XCTAssertEqual(calendar.date(from: DateComponents(timeZone: timeZone, year: 2020, month: 08, day: 02, hour: 23, minute: 59, second: 0)), condition.afterDate.date)
             XCTAssertTrue(condition.includeBeforeDate)
@@ -1449,7 +1479,7 @@ final class ImportConditionTests: XCTestCase {
 
     func testUsesFormCondition() throws {
         do {
-            let file = try OutlookRulesFile(data: Data([
+            let file = try OutlookRules(data: Data([
                 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x14, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
@@ -1470,17 +1500,17 @@ final class ImportConditionTests: XCTestCase {
             XCTAssertEqual(1, file.rules.count)
             XCTAssertEqual(1, file.rules[0].conditions.count)
             XCTAssertEqual(.usesFormCondition, file.rules[0].conditions[0].identifier)
-            XCTAssertTrue(file.rules[0].conditions[0].data is FormTypeRuleElementData)
+            XCTAssertEqual(1, file.rules[0].conditions[0].parameters.count)
+            XCTAssertTrue(file.rules[0].conditions[0].parameter is FormTypeParameter)
             XCTAssertEqual(0, file.rules[0].actions.count)
             XCTAssertEqual(0, file.rules[0].exceptions.count)
-            
-            let condition = file.rules[0].conditions[0].data as! FormTypeRuleElementData
-            XCTAssertEqual(1, condition.numberOfForms)
-            XCTAssertEqual("Accept Meeting Response", condition.forms[0].name)
-            XCTAssertEqual("IPM.Schedule.Meeting.Resp.Pos", condition.forms[0].className)
+
+            let condition = file.rules[0].conditions[0].parameter as! FormTypeParameter
+            XCTAssertEqual("Accept Meeting Response", condition.name)
+            XCTAssertEqual("IPM.Schedule.Meeting.Resp.Pos", condition.className)
         }
         do {
-            let file = try OutlookRulesFile(data: Data([
+            let file = try OutlookRules(data: Data([
                 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x14, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
@@ -1505,23 +1535,25 @@ final class ImportConditionTests: XCTestCase {
             XCTAssertEqual(1, file.rules.count)
             XCTAssertEqual(1, file.rules[0].conditions.count)
             XCTAssertEqual(.usesFormCondition, file.rules[0].conditions[0].identifier)
-            XCTAssertTrue(file.rules[0].conditions[0].data is FormTypeRuleElementData)
+            XCTAssertEqual(2, file.rules[0].conditions[0].parameters.count)
+            XCTAssertTrue(file.rules[0].conditions[0].parameters[0] is FormTypeParameter)
+            XCTAssertTrue(file.rules[0].conditions[0].parameters[1] is FormTypeParameter)
             XCTAssertEqual(0, file.rules[0].actions.count)
             XCTAssertEqual(0, file.rules[0].exceptions.count)
-            
-            let condition = file.rules[0].conditions[0].data as! FormTypeRuleElementData
-            XCTAssertEqual(2, condition.numberOfForms)
-            XCTAssertEqual("Accept Meeting Response", condition.forms[0].name)
-            XCTAssertEqual("IPM.Schedule.Meeting.Resp.Pos", condition.forms[0].className)
-            XCTAssertEqual("Text Message", condition.forms[1].name)
-            XCTAssertEqual("IPM.Note.Mobile.SMS", condition.forms[1].className)
+
+            let condition1 = file.rules[0].conditions[0].parameters[0] as! FormTypeParameter
+            XCTAssertEqual("Accept Meeting Response", condition1.name)
+            XCTAssertEqual("IPM.Schedule.Meeting.Resp.Pos", condition1.className)
+            let condition2 = file.rules[0].conditions[0].parameters[1] as! FormTypeParameter
+            XCTAssertEqual("Text Message", condition2.name)
+            XCTAssertEqual("IPM.Note.Mobile.SMS", condition2.className)
         }
     }
 
     func testWithSelectedPropertiesOfDocumentOrFormsCondition() throws {
         // String, contains
         do {
-            let file = try OutlookRulesFile(data: Data([
+            let file = try OutlookRules(data: Data([
                 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x14, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
@@ -1545,11 +1577,11 @@ final class ImportConditionTests: XCTestCase {
             XCTAssertEqual(1, file.rules.count)
             XCTAssertEqual(1, file.rules[0].conditions.count)
             XCTAssertEqual(.withSelectedPropertiesOfDocumentOrFormsCondition, file.rules[0].conditions[0].identifier)
-            XCTAssertTrue(file.rules[0].conditions[0].data is WithSelectedPropertiesOfDocumentOrFormsRuleElementData)
+            XCTAssertTrue(file.rules[0].conditions[0].parameter is FormParameter)
             XCTAssertEqual(0, file.rules[0].actions.count)
             XCTAssertEqual(0, file.rules[0].exceptions.count)
-            
-            let condition = file.rules[0].conditions[0].data as! WithSelectedPropertiesOfDocumentOrFormsRuleElementData
+
+            let condition = file.rules[0].conditions[0].parameter as! FormParameter
             XCTAssertEqual(["Accept Meeting Response"], condition.forms)
             XCTAssertEqual(1, condition.documentProperties.count)
             XCTAssertEqual("Author", condition.documentProperties[0].field)
@@ -1565,7 +1597,7 @@ final class ImportConditionTests: XCTestCase {
         }
         // String, isEqual
         do {
-            let file = try OutlookRulesFile(data: Data([
+            let file = try OutlookRules(data: Data([
                 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x14, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
@@ -1587,11 +1619,11 @@ final class ImportConditionTests: XCTestCase {
             XCTAssertEqual(1, file.rules.count)
             XCTAssertEqual(1, file.rules[0].conditions.count)
             XCTAssertEqual(.withSelectedPropertiesOfDocumentOrFormsCondition, file.rules[0].conditions[0].identifier)
-            XCTAssertTrue(file.rules[0].conditions[0].data is WithSelectedPropertiesOfDocumentOrFormsRuleElementData)
+            XCTAssertTrue(file.rules[0].conditions[0].parameter is FormParameter)
             XCTAssertEqual(0, file.rules[0].actions.count)
             XCTAssertEqual(0, file.rules[0].exceptions.count)
-            
-            let condition = file.rules[0].conditions[0].data as! WithSelectedPropertiesOfDocumentOrFormsRuleElementData
+
+            let condition = file.rules[0].conditions[0].parameter as! FormParameter
             XCTAssertEqual([], condition.forms)
             XCTAssertEqual(1, condition.documentProperties.count)
             XCTAssertEqual("Author", condition.documentProperties[0].field)
@@ -1607,7 +1639,7 @@ final class ImportConditionTests: XCTestCase {
         }
         // String, doesNotContain
         do {
-            let file = try OutlookRulesFile(data: Data([
+            let file = try OutlookRules(data: Data([
                 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x14, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
@@ -1629,11 +1661,11 @@ final class ImportConditionTests: XCTestCase {
             XCTAssertEqual(1, file.rules.count)
             XCTAssertEqual(1, file.rules[0].conditions.count)
             XCTAssertEqual(.withSelectedPropertiesOfDocumentOrFormsCondition, file.rules[0].conditions[0].identifier)
-            XCTAssertTrue(file.rules[0].conditions[0].data is WithSelectedPropertiesOfDocumentOrFormsRuleElementData)
+            XCTAssertTrue(file.rules[0].conditions[0].parameter is FormParameter)
             XCTAssertEqual(0, file.rules[0].actions.count)
             XCTAssertEqual(0, file.rules[0].exceptions.count)
-            
-            let condition = file.rules[0].conditions[0].data as! WithSelectedPropertiesOfDocumentOrFormsRuleElementData
+
+            let condition = file.rules[0].conditions[0].parameter as! FormParameter
             XCTAssertEqual([], condition.forms)
             XCTAssertEqual(1, condition.documentProperties.count)
             XCTAssertEqual("Author", condition.documentProperties[0].field)
@@ -1649,7 +1681,7 @@ final class ImportConditionTests: XCTestCase {
         }
         // Number, equals (positive)
         do {
-            let file = try OutlookRulesFile(data: Data([
+            let file = try OutlookRules(data: Data([
                 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x14, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
@@ -1670,11 +1702,11 @@ final class ImportConditionTests: XCTestCase {
             XCTAssertEqual(1, file.rules.count)
             XCTAssertEqual(1, file.rules[0].conditions.count)
             XCTAssertEqual(.withSelectedPropertiesOfDocumentOrFormsCondition, file.rules[0].conditions[0].identifier)
-            XCTAssertTrue(file.rules[0].conditions[0].data is WithSelectedPropertiesOfDocumentOrFormsRuleElementData)
+            XCTAssertTrue(file.rules[0].conditions[0].parameter is FormParameter)
             XCTAssertEqual(0, file.rules[0].actions.count)
             XCTAssertEqual(0, file.rules[0].exceptions.count)
-            
-            let condition = file.rules[0].conditions[0].data as! WithSelectedPropertiesOfDocumentOrFormsRuleElementData
+
+            let condition = file.rules[0].conditions[0].parameter as! FormParameter
             XCTAssertEqual([], condition.forms)
             XCTAssertEqual(1, condition.documentProperties.count)
             XCTAssertEqual("Bytes", condition.documentProperties[0].field)
@@ -1690,7 +1722,7 @@ final class ImportConditionTests: XCTestCase {
         }
         // Number, equals (negative)
         do {
-            let file = try OutlookRulesFile(data: Data([
+            let file = try OutlookRules(data: Data([
                 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x14, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
@@ -1711,11 +1743,11 @@ final class ImportConditionTests: XCTestCase {
             XCTAssertEqual(1, file.rules.count)
             XCTAssertEqual(1, file.rules[0].conditions.count)
             XCTAssertEqual(.withSelectedPropertiesOfDocumentOrFormsCondition, file.rules[0].conditions[0].identifier)
-            XCTAssertTrue(file.rules[0].conditions[0].data is WithSelectedPropertiesOfDocumentOrFormsRuleElementData)
+            XCTAssertTrue(file.rules[0].conditions[0].parameter is FormParameter)
             XCTAssertEqual(0, file.rules[0].actions.count)
             XCTAssertEqual(0, file.rules[0].exceptions.count)
-            
-            let condition = file.rules[0].conditions[0].data as! WithSelectedPropertiesOfDocumentOrFormsRuleElementData
+
+            let condition = file.rules[0].conditions[0].parameter as! FormParameter
             XCTAssertEqual([], condition.forms)
             XCTAssertEqual(1, condition.documentProperties.count)
             XCTAssertEqual("Bytes", condition.documentProperties[0].field)
@@ -1731,7 +1763,7 @@ final class ImportConditionTests: XCTestCase {
         }
         // Number, not equal to
         do {
-            let file = try OutlookRulesFile(data: Data([
+            let file = try OutlookRules(data: Data([
                 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x14, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
@@ -1752,11 +1784,11 @@ final class ImportConditionTests: XCTestCase {
             XCTAssertEqual(1, file.rules.count)
             XCTAssertEqual(1, file.rules[0].conditions.count)
             XCTAssertEqual(.withSelectedPropertiesOfDocumentOrFormsCondition, file.rules[0].conditions[0].identifier)
-            XCTAssertTrue(file.rules[0].conditions[0].data is WithSelectedPropertiesOfDocumentOrFormsRuleElementData)
+            XCTAssertTrue(file.rules[0].conditions[0].parameter is FormParameter)
             XCTAssertEqual(0, file.rules[0].actions.count)
             XCTAssertEqual(0, file.rules[0].exceptions.count)
-            
-            let condition = file.rules[0].conditions[0].data as! WithSelectedPropertiesOfDocumentOrFormsRuleElementData
+
+            let condition = file.rules[0].conditions[0].parameter as! FormParameter
             XCTAssertEqual([], condition.forms)
             XCTAssertEqual(1, condition.documentProperties.count)
             XCTAssertEqual("Bytes", condition.documentProperties[0].field)
@@ -1772,7 +1804,7 @@ final class ImportConditionTests: XCTestCase {
         }
         // Number, is at most
         do {
-            let file = try OutlookRulesFile(data: Data([
+            let file = try OutlookRules(data: Data([
                 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x14, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
@@ -1793,11 +1825,11 @@ final class ImportConditionTests: XCTestCase {
             XCTAssertEqual(1, file.rules.count)
             XCTAssertEqual(1, file.rules[0].conditions.count)
             XCTAssertEqual(.withSelectedPropertiesOfDocumentOrFormsCondition, file.rules[0].conditions[0].identifier)
-            XCTAssertTrue(file.rules[0].conditions[0].data is WithSelectedPropertiesOfDocumentOrFormsRuleElementData)
+            XCTAssertTrue(file.rules[0].conditions[0].parameter is FormParameter)
             XCTAssertEqual(0, file.rules[0].actions.count)
             XCTAssertEqual(0, file.rules[0].exceptions.count)
-            
-            let condition = file.rules[0].conditions[0].data as! WithSelectedPropertiesOfDocumentOrFormsRuleElementData
+
+            let condition = file.rules[0].conditions[0].parameter as! FormParameter
             XCTAssertEqual([], condition.forms)
             XCTAssertEqual(1, condition.documentProperties.count)
             XCTAssertEqual("Bytes", condition.documentProperties[0].field)
@@ -1813,7 +1845,7 @@ final class ImportConditionTests: XCTestCase {
         }
         // Number, is at least
         do {
-            let file = try OutlookRulesFile(data: Data([
+            let file = try OutlookRules(data: Data([
                 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x14, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
@@ -1834,11 +1866,11 @@ final class ImportConditionTests: XCTestCase {
             XCTAssertEqual(1, file.rules.count)
             XCTAssertEqual(1, file.rules[0].conditions.count)
             XCTAssertEqual(.withSelectedPropertiesOfDocumentOrFormsCondition, file.rules[0].conditions[0].identifier)
-            XCTAssertTrue(file.rules[0].conditions[0].data is WithSelectedPropertiesOfDocumentOrFormsRuleElementData)
+            XCTAssertTrue(file.rules[0].conditions[0].parameter is FormParameter)
             XCTAssertEqual(0, file.rules[0].actions.count)
             XCTAssertEqual(0, file.rules[0].exceptions.count)
-            
-            let condition = file.rules[0].conditions[0].data as! WithSelectedPropertiesOfDocumentOrFormsRuleElementData
+
+            let condition = file.rules[0].conditions[0].parameter as! FormParameter
             XCTAssertEqual([], condition.forms)
             XCTAssertEqual(1, condition.documentProperties.count)
             XCTAssertEqual("Bytes", condition.documentProperties[0].field)
@@ -1854,7 +1886,7 @@ final class ImportConditionTests: XCTestCase {
         }
         // Number, is more than
         do {
-            let file = try OutlookRulesFile(data: Data([
+            let file = try OutlookRules(data: Data([
                 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x14, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
@@ -1875,11 +1907,11 @@ final class ImportConditionTests: XCTestCase {
             XCTAssertEqual(1, file.rules.count)
             XCTAssertEqual(1, file.rules[0].conditions.count)
             XCTAssertEqual(.withSelectedPropertiesOfDocumentOrFormsCondition, file.rules[0].conditions[0].identifier)
-            XCTAssertTrue(file.rules[0].conditions[0].data is WithSelectedPropertiesOfDocumentOrFormsRuleElementData)
+            XCTAssertTrue(file.rules[0].conditions[0].parameter is FormParameter)
             XCTAssertEqual(0, file.rules[0].actions.count)
             XCTAssertEqual(0, file.rules[0].exceptions.count)
-            
-            let condition = file.rules[0].conditions[0].data as! WithSelectedPropertiesOfDocumentOrFormsRuleElementData
+
+            let condition = file.rules[0].conditions[0].parameter as! FormParameter
             XCTAssertEqual([], condition.forms)
             XCTAssertEqual(1, condition.documentProperties.count)
             XCTAssertEqual("Bytes", condition.documentProperties[0].field)
@@ -1895,7 +1927,7 @@ final class ImportConditionTests: XCTestCase {
         }
         // Number, is less than
         do {
-            let file = try OutlookRulesFile(data: Data([
+            let file = try OutlookRules(data: Data([
                 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x14, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
@@ -1916,11 +1948,11 @@ final class ImportConditionTests: XCTestCase {
             XCTAssertEqual(1, file.rules.count)
             XCTAssertEqual(1, file.rules[0].conditions.count)
             XCTAssertEqual(.withSelectedPropertiesOfDocumentOrFormsCondition, file.rules[0].conditions[0].identifier)
-            XCTAssertTrue(file.rules[0].conditions[0].data is WithSelectedPropertiesOfDocumentOrFormsRuleElementData)
+            XCTAssertTrue(file.rules[0].conditions[0].parameter is FormParameter)
             XCTAssertEqual(0, file.rules[0].actions.count)
             XCTAssertEqual(0, file.rules[0].exceptions.count)
-            
-            let condition = file.rules[0].conditions[0].data as! WithSelectedPropertiesOfDocumentOrFormsRuleElementData
+
+            let condition = file.rules[0].conditions[0].parameter as! FormParameter
             XCTAssertEqual([], condition.forms)
             XCTAssertEqual(1, condition.documentProperties.count)
             XCTAssertEqual("Bytes", condition.documentProperties[0].field)
@@ -1939,7 +1971,7 @@ final class ImportConditionTests: XCTestCase {
         calendar.timeZone = timeZone
         // Date, before
         do {
-            let file = try OutlookRulesFile(data: Data([
+            let file = try OutlookRules(data: Data([
                 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x14, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
@@ -1961,11 +1993,11 @@ final class ImportConditionTests: XCTestCase {
             XCTAssertEqual(1, file.rules.count)
             XCTAssertEqual(1, file.rules[0].conditions.count)
             XCTAssertEqual(.withSelectedPropertiesOfDocumentOrFormsCondition, file.rules[0].conditions[0].identifier)
-            XCTAssertTrue(file.rules[0].conditions[0].data is WithSelectedPropertiesOfDocumentOrFormsRuleElementData)
+            XCTAssertTrue(file.rules[0].conditions[0].parameter is FormParameter)
             XCTAssertEqual(0, file.rules[0].actions.count)
             XCTAssertEqual(0, file.rules[0].exceptions.count)
-            
-            let condition = file.rules[0].conditions[0].data as! WithSelectedPropertiesOfDocumentOrFormsRuleElementData
+
+            let condition = file.rules[0].conditions[0].parameter as! FormParameter
             XCTAssertEqual([], condition.forms)
             XCTAssertEqual(1, condition.documentProperties.count)
             XCTAssertEqual("Creation Time", condition.documentProperties[0].field)
@@ -1982,7 +2014,7 @@ final class ImportConditionTests: XCTestCase {
         }
         // Date, after
         do {
-            let file = try OutlookRulesFile(data: Data([
+            let file = try OutlookRules(data: Data([
                 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x14, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
@@ -2004,11 +2036,11 @@ final class ImportConditionTests: XCTestCase {
             XCTAssertEqual(1, file.rules.count)
             XCTAssertEqual(1, file.rules[0].conditions.count)
             XCTAssertEqual(.withSelectedPropertiesOfDocumentOrFormsCondition, file.rules[0].conditions[0].identifier)
-            XCTAssertTrue(file.rules[0].conditions[0].data is WithSelectedPropertiesOfDocumentOrFormsRuleElementData)
+            XCTAssertTrue(file.rules[0].conditions[0].parameter is FormParameter)
             XCTAssertEqual(0, file.rules[0].actions.count)
             XCTAssertEqual(0, file.rules[0].exceptions.count)
-            
-            let condition = file.rules[0].conditions[0].data as! WithSelectedPropertiesOfDocumentOrFormsRuleElementData
+
+            let condition = file.rules[0].conditions[0].parameter as! FormParameter
             XCTAssertEqual([], condition.forms)
             XCTAssertEqual(1, condition.documentProperties.count)
             XCTAssertEqual("Creation Time", condition.documentProperties[0].field)
@@ -2025,7 +2057,7 @@ final class ImportConditionTests: XCTestCase {
         }
         // Multiple
         do {
-            let file = try OutlookRulesFile(data: Data([
+            let file = try OutlookRules(data: Data([
                 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x14, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
@@ -2059,11 +2091,11 @@ final class ImportConditionTests: XCTestCase {
             XCTAssertEqual(1, file.rules.count)
             XCTAssertEqual(1, file.rules[0].conditions.count)
             XCTAssertEqual(.withSelectedPropertiesOfDocumentOrFormsCondition, file.rules[0].conditions[0].identifier)
-            XCTAssertTrue(file.rules[0].conditions[0].data is WithSelectedPropertiesOfDocumentOrFormsRuleElementData)
+            XCTAssertTrue(file.rules[0].conditions[0].parameter is FormParameter)
             XCTAssertEqual(0, file.rules[0].actions.count)
             XCTAssertEqual(0, file.rules[0].exceptions.count)
-            
-            let condition = file.rules[0].conditions[0].data as! WithSelectedPropertiesOfDocumentOrFormsRuleElementData
+
+            let condition = file.rules[0].conditions[0].parameter as! FormParameter
             XCTAssertEqual(["Accept Meeting Response", " Text Message", " Task"], condition.forms)
             XCTAssertEqual(2, condition.documentProperties.count)
             XCTAssertEqual("Bytes", condition.documentProperties[0].field)
@@ -2087,10 +2119,10 @@ final class ImportConditionTests: XCTestCase {
             XCTAssertEqual(["IPM.Schedule.Meeting.Resp.Pos", "IPM.Note.Mobile.SMS", "IPM.Task"], condition.classes)
         }
     }
-    
+
     func testWithRelevanceInSpecificRangeCondition() throws {
         do {
-            let file = try OutlookRulesFile(data: Data([
+            let file = try OutlookRules(data: Data([
                 0x80, 0x4f, 0x12, 0x00, 0x80, 0x4f, 0x12, 0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x80, 0x4f,
@@ -2109,16 +2141,16 @@ final class ImportConditionTests: XCTestCase {
             XCTAssertEqual(1, file.rules.count)
             XCTAssertEqual(1, file.rules[0].conditions.count)
             XCTAssertEqual(.relevanceInSpecificRangeCondition, file.rules[0].conditions[0].identifier)
-            XCTAssertTrue(file.rules[0].conditions[0].data is RelevanceInSpecificRangeRuleElementData)
+            XCTAssertTrue(file.rules[0].conditions[0].parameter is RelevanceRangeParameter)
             XCTAssertEqual(0, file.rules[0].actions.count)
             XCTAssertEqual(0, file.rules[0].exceptions.count)
-            
-            let condition = file.rules[0].conditions[0].data as! RelevanceInSpecificRangeRuleElementData
+
+            let condition = file.rules[0].conditions[0].parameter as! RelevanceRangeParameter
             XCTAssertEqual(10, condition.minimumRelevance)
             XCTAssertEqual(20, condition.maximumRelevance)
         }
         do {
-            let file = try OutlookRulesFile(data: Data([
+            let file = try OutlookRules(data: Data([
                 0x80, 0x4f, 0x12, 0x00, 0x80, 0x4f, 0x12, 0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x80, 0x4f,
@@ -2137,19 +2169,19 @@ final class ImportConditionTests: XCTestCase {
             XCTAssertEqual(1, file.rules.count)
             XCTAssertEqual(1, file.rules[0].conditions.count)
             XCTAssertEqual(.relevanceInSpecificRangeCondition, file.rules[0].conditions[0].identifier)
-            XCTAssertTrue(file.rules[0].conditions[0].data is RelevanceInSpecificRangeRuleElementData)
+            XCTAssertTrue(file.rules[0].conditions[0].parameter is RelevanceRangeParameter)
             XCTAssertEqual(0, file.rules[0].actions.count)
             XCTAssertEqual(0, file.rules[0].exceptions.count)
-            
-            let condition = file.rules[0].conditions[0].data as! RelevanceInSpecificRangeRuleElementData
+
+            let condition = file.rules[0].conditions[0].parameter as! RelevanceRangeParameter
             XCTAssertEqual(0, condition.minimumRelevance)
             XCTAssertEqual(20, condition.maximumRelevance)
         }
     }
-    
+
     func testSenderInSpecifiedAddressBookCondition() throws {
         do {
-            let file = try OutlookRulesFile(data: Data([
+            let file = try OutlookRules(data: Data([
                 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x14, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
@@ -2181,19 +2213,19 @@ final class ImportConditionTests: XCTestCase {
             XCTAssertEqual(1, file.rules.count)
             XCTAssertEqual(2, file.rules[0].conditions.count)
             XCTAssertEqual(.senderInSpecifiedAddressBookCondition, file.rules[0].conditions[0].identifier)
-            XCTAssertTrue(file.rules[0].conditions[0].data is SenderInSpecifiedAddressBookRuleElementData)
+            XCTAssertTrue(file.rules[0].conditions[0].parameter is AddressBookParameter)
             XCTAssertEqual(0, file.rules[0].actions.count)
             XCTAssertEqual(0, file.rules[0].exceptions.count)
-            
-            let condition = file.rules[0].conditions[0].data as! SenderInSpecifiedAddressBookRuleElementData
+
+            let condition = file.rules[0].conditions[0].parameter as! AddressBookParameter
             XCTAssertEqual("Contacts (This computer only)", condition.name)
-            XCTAssertTrue(file.rules[0].conditions[1].data is OnThisComputerOnlyRuleElementData)
+            XCTAssertTrue(file.rules[0].conditions[1].parameter is ProfileStampParameter)
         }
     }
 
     func testWhichIsMeetingInvitationOrUpdateCondition() throws {
         do {
-            let file = try OutlookRulesFile(data: Data([
+            let file = try OutlookRules(data: Data([
                 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x14, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
@@ -2209,7 +2241,7 @@ final class ImportConditionTests: XCTestCase {
             XCTAssertEqual(1, file.rules.count)
             XCTAssertEqual(1, file.rules[0].conditions.count)
             XCTAssertEqual(.whichIsAMeetingInvitationOrInviteCondition, file.rules[0].conditions[0].identifier)
-            XCTAssertTrue(file.rules[0].conditions[0].data is SimpleRuleElementData)
+            XCTAssertEqual(0, file.rules[0].conditions[0].parameters.count)
             XCTAssertEqual(0, file.rules[0].actions.count)
             XCTAssertEqual(0, file.rules[0].exceptions.count)
         }
@@ -2217,7 +2249,7 @@ final class ImportConditionTests: XCTestCase {
 
     func testFromRSSFeedsWithSpecifiedTextInTitleCondition() throws {
         do {
-            let file = try OutlookRulesFile(data: Data([
+            let file = try OutlookRules(data: Data([
                 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x14, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
@@ -2237,15 +2269,16 @@ final class ImportConditionTests: XCTestCase {
             XCTAssertEqual(1, file.rules.count)
             XCTAssertEqual(1, file.rules[0].conditions.count)
             XCTAssertEqual(.fromRSSFeedsWithSpecifiedTextInTitleCondition, file.rules[0].conditions[0].identifier)
-            XCTAssertTrue(file.rules[0].conditions[0].data is StringsListRuleElementData)
+            XCTAssertEqual(1, file.rules[0].conditions[0].parameters.count)
+            XCTAssertTrue(file.rules[0].conditions[0].parameter is StringParameter)
             XCTAssertEqual(0, file.rules[0].actions.count)
             XCTAssertEqual(0, file.rules[0].exceptions.count)
-            
-            let condition = file.rules[0].conditions[0].data as! StringsListRuleElementData
-            XCTAssertEqual(["ISS On-Orbit Status Report"], condition.entries)
+
+            let condition = file.rules[0].conditions[0].parameter as! StringParameter
+            XCTAssertEqual("ISS On-Orbit Status Report", condition.value)
         }
         do {
-            let file = try OutlookRulesFile(data: Data([
+            let file = try OutlookRules(data: Data([
                 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x14, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
@@ -2268,18 +2301,22 @@ final class ImportConditionTests: XCTestCase {
             XCTAssertEqual(1, file.rules.count)
             XCTAssertEqual(1, file.rules[0].conditions.count)
             XCTAssertEqual(.fromRSSFeedsWithSpecifiedTextInTitleCondition, file.rules[0].conditions[0].identifier)
-            XCTAssertTrue(file.rules[0].conditions[0].data is StringsListRuleElementData)
+            XCTAssertEqual(2, file.rules[0].conditions[0].parameters.count)
+            XCTAssertTrue(file.rules[0].conditions[0].parameters[0] is StringParameter)
+            XCTAssertTrue(file.rules[0].conditions[0].parameters[1] is StringParameter)
             XCTAssertEqual(0, file.rules[0].actions.count)
             XCTAssertEqual(0, file.rules[0].exceptions.count)
-            
-            let condition = file.rules[0].conditions[0].data as! StringsListRuleElementData
-            XCTAssertEqual(["ISS On-Orbit Status Report", "NASA Breaking News"], condition.entries)
+
+            let condition1 = file.rules[0].conditions[0].parameters[0] as! StringParameter
+            XCTAssertEqual("ISS On-Orbit Status Report", condition1.value)
+            let condition2 = file.rules[0].conditions[0].parameters[1] as! StringParameter
+            XCTAssertEqual("NASA Breaking News", condition2.value)
         }
     }
-    
+
     func testSpecificInfoPathFormCondition() throws {
         do {
-            let file = try OutlookRulesFile(data: Data([
+            let file = try OutlookRules(data: Data([
                 0x80, 0x4f, 0x12, 0x00, 0x80, 0x4f, 0x12, 0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x80, 0x4f,
@@ -2300,20 +2337,20 @@ final class ImportConditionTests: XCTestCase {
             XCTAssertEqual(1, file.rules.count)
             XCTAssertEqual(1, file.rules[0].conditions.count)
             XCTAssertEqual(.specificInfoPathFormCondition, file.rules[0].conditions[0].identifier)
-            XCTAssertTrue(file.rules[0].conditions[0].data is FormTypeRuleElementData)
+            XCTAssertEqual(1, file.rules[0].conditions[0].parameters.count)
+            XCTAssertTrue(file.rules[0].conditions[0].parameter is FormTypeParameter)
             XCTAssertEqual(0, file.rules[0].actions.count)
             XCTAssertEqual(0, file.rules[0].exceptions.count)
-            
-            let condition = file.rules[0].conditions[0].data as! FormTypeRuleElementData
-            XCTAssertEqual(1, condition.numberOfForms)
-            XCTAssertEqual("Template3", condition.forms[0].name)
-            XCTAssertEqual("IPM.InfoPathForm.25bcd4d0a0953612$759f7503f0746cc1", condition.forms[0].className)
+
+            let condition = file.rules[0].conditions[0].parameter as! FormTypeParameter
+            XCTAssertEqual("Template3", condition.name)
+            XCTAssertEqual("IPM.InfoPathForm.25bcd4d0a0953612$759f7503f0746cc1", condition.className)
         }
     }
 
     func testFromAnyRSSFeedCondition() throws {
         do {
-            let file = try OutlookRulesFile(data: Data([
+            let file = try OutlookRules(data: Data([
                 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x14, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
@@ -2329,15 +2366,15 @@ final class ImportConditionTests: XCTestCase {
             XCTAssertEqual(1, file.rules.count)
             XCTAssertEqual(1, file.rules[0].conditions.count)
             XCTAssertEqual(.fromAnyRSSFeedCondition, file.rules[0].conditions[0].identifier)
-            XCTAssertTrue(file.rules[0].conditions[0].data is SimpleRuleElementData)
+            XCTAssertEqual(0, file.rules[0].conditions[0].parameters.count)
             XCTAssertEqual(0, file.rules[0].actions.count)
             XCTAssertEqual(0, file.rules[0].exceptions.count)
         }
     }
-    
+
     func testJunkCondition() throws {
         do {
-            let file = try OutlookRulesFile(data: Data([
+            let file = try OutlookRules(data: Data([
                 0x3c, 0xd0, 0x0e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
                 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x0c, 0x4a, 0x75, 0x6e, 0x6b, 0x20, 0x53, 0x65, 0x6e, 0x64,
@@ -2353,16 +2390,16 @@ final class ImportConditionTests: XCTestCase {
             XCTAssertEqual(1, file.rules.count)
             XCTAssertEqual(1, file.rules[0].conditions.count)
             XCTAssertEqual(.junkCondition, file.rules[0].conditions[0].identifier)
-            XCTAssertTrue(file.rules[0].conditions[0].data is SendersListRuleElementData)
-            XCTAssertEqual("Junk Senders", (file.rules[0].conditions[0].data as! SendersListRuleElementData).name)
+            XCTAssertTrue(file.rules[0].conditions[0].parameter is SendersListParameter)
+            XCTAssertEqual("Junk Senders", (file.rules[0].conditions[0].parameter as! SendersListParameter).name)
             XCTAssertEqual(0, file.rules[0].actions.count)
             XCTAssertEqual(0, file.rules[0].exceptions.count)
         }
     }
-    
+
     func testAdultCondition() throws {
         do {
-            let file = try OutlookRulesFile(data: Data([
+            let file = try OutlookRules(data: Data([
                 0x3c, 0xd0, 0x0e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
                 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x15, 0x41, 0x64, 0x75, 0x6c, 0x74, 0x20, 0x43, 0x6f, 0x6e,
@@ -2379,16 +2416,16 @@ final class ImportConditionTests: XCTestCase {
             XCTAssertEqual(1, file.rules.count)
             XCTAssertEqual(1, file.rules[0].conditions.count)
             XCTAssertEqual(.adultCondition, file.rules[0].conditions[0].identifier)
-            XCTAssertTrue(file.rules[0].conditions[0].data is SendersListRuleElementData)
-            XCTAssertEqual("Adult Content Senders", (file.rules[0].conditions[0].data as! SendersListRuleElementData).name)
+            XCTAssertTrue(file.rules[0].conditions[0].parameter is SendersListParameter)
+            XCTAssertEqual("Adult Content Senders", (file.rules[0].conditions[0].parameter as! SendersListParameter).name)
             XCTAssertEqual(0, file.rules[0].actions.count)
             XCTAssertEqual(0, file.rules[0].exceptions.count)
         }
     }
-    
+
     func testExceptionListCondition() throws {
         do {
-            let file = try OutlookRulesFile(data: Data([
+            let file = try OutlookRules(data: Data([
                 0x3c, 0xd0, 0x0e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
                 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x0e, 0x45, 0x78, 0x63, 0x65, 0x70, 0x74, 0x69, 0x6f, 0x6e,
@@ -2405,18 +2442,18 @@ final class ImportConditionTests: XCTestCase {
             XCTAssertEqual(1, file.rules.count)
             XCTAssertEqual(1, file.rules[0].conditions.count)
             XCTAssertEqual(.exceptionListCondition, file.rules[0].conditions[0].identifier)
-            XCTAssertTrue(file.rules[0].conditions[0].data is SendersListRuleElementData)
-            XCTAssertEqual("Exception List", (file.rules[0].conditions[0].data as! SendersListRuleElementData).name)
+            XCTAssertTrue(file.rules[0].conditions[0].parameter is SendersListParameter)
+            XCTAssertEqual("Exception List", (file.rules[0].conditions[0].parameter as! SendersListParameter).name)
             XCTAssertEqual(1, file.rules[0].actions.count)
             XCTAssertEqual(.doNotSearchForCommercialOrAdultContentAction, file.rules[0].actions[0].identifier)
-            XCTAssertTrue(file.rules[0].actions[0].data is SimpleRuleElementData)
+            XCTAssertEqual(0, file.rules[0].actions[0].parameters.count)
             XCTAssertEqual(0, file.rules[0].exceptions.count)
         }
     }
-    
+
     func testAlertCondition() throws {
         do {
-            let file = try OutlookRulesFile(data: Data([
+            let file = try OutlookRules(data: Data([
                 0x80, 0x4f, 0x12, 0x00, 0x80, 0x4f, 0x12, 0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x80, 0x4f,
@@ -2449,8 +2486,8 @@ final class ImportConditionTests: XCTestCase {
             XCTAssertEqual(1, file.rules.count)
             XCTAssertEqual(1, file.rules[0].conditions.count)
             XCTAssertEqual(.alertCondition, file.rules[0].conditions[0].identifier)
-            XCTAssertTrue(file.rules[0].conditions[0].data is AlertRuleElementData)
-            XCTAssertEqual("Alert from \"Home\" about \"Documents (All Changes)\"\u{1}{1D7EAA7A-B10A-485D-A8E9-5B3D611597E1}", (file.rules[0].conditions[0].data as! AlertRuleElementData).name)
+            XCTAssertTrue(file.rules[0].conditions[0].parameter is AlertParameter)
+            XCTAssertEqual("Alert from \"Home\" about \"Documents (All Changes)\"\u{1}{1D7EAA7A-B10A-485D-A8E9-5B3D611597E1}", (file.rules[0].conditions[0].parameter as!AlertParameter).name)
             XCTAssertEqual(0, file.rules[0].actions.count)
             XCTAssertEqual(0, file.rules[0].exceptions.count)
         }
@@ -2458,7 +2495,7 @@ final class ImportConditionTests: XCTestCase {
 
     func testMultipleConditions() throws {
         do {
-            let file = try OutlookRulesFile(data: Data([
+            let file = try OutlookRules(data: Data([
                 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x14, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
@@ -2482,14 +2519,14 @@ final class ImportConditionTests: XCTestCase {
             XCTAssertEqual(1, file.rules.count)
             XCTAssertEqual(2, file.rules[0].conditions.count)
             XCTAssertEqual(.nameInToBoxCondition, file.rules[0].conditions[0].identifier)
-            XCTAssertTrue(file.rules[0].conditions[0].data is SimpleRuleElementData)
+            XCTAssertEqual(0, file.rules[0].conditions[0].parameters.count)
             XCTAssertEqual(.sentOnlyToMeCondition, file.rules[0].conditions[1].identifier)
-            XCTAssertTrue(file.rules[0].conditions[1].data is SimpleRuleElementData)
+            XCTAssertEqual(0, file.rules[0].conditions[1].parameters.count)
             XCTAssertEqual(0, file.rules[0].actions.count)
             XCTAssertEqual(0, file.rules[0].exceptions.count)
         }
     }
-    
+
     static var allTests = [
         ("testFromCondition", testFromCondition),
         ("testSpecificWordsInSubjectCondition", testSpecificWordsInSubjectCondition),
diff --git a/Tests/OutlookRulesReaderTests/Import/ImportExceptionTests.swift b/Tests/OutlookRulesReaderTests/Import/ImportExceptionTests.swift
index b6ef424..7690669 100644
--- a/Tests/OutlookRulesReaderTests/Import/ImportExceptionTests.swift
+++ b/Tests/OutlookRulesReaderTests/Import/ImportExceptionTests.swift
@@ -5,7 +5,7 @@ import MAPI
 final class ImportExceptionTests: XCTestCase {
     func testFromException() throws {
         do {
-            let file = try OutlookRulesFile(data: Data([
+            let file = try OutlookRules(data: Data([
                 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x14, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
@@ -38,9 +38,9 @@ final class ImportExceptionTests: XCTestCase {
             XCTAssertEqual(0, file.rules[0].actions.count)
             XCTAssertEqual(1, file.rules[0].exceptions.count)
             XCTAssertEqual(.fromException, file.rules[0].exceptions[0].identifier)
-            XCTAssertTrue(file.rules[0].exceptions[0].data is PeopleOrPublicGroupListRuleElementData)
+            XCTAssertTrue(file.rules[0].exceptions[0].parameter is AddressParameter)
 
-            let exception = file.rules[0].exceptions[0].data as! PeopleOrPublicGroupListRuleElementData
+            let exception = file.rules[0].exceptions[0].parameter as!AddressParameter
             XCTAssertEqual(1, exception.values.count)
             XCTAssertEqual(6, exception.values[0].count)
             XCTAssertEqual(MAPI_E.NOT_FOUND.rawValue, exception.values[0][PropertyId.tagSmtpAddress.rawValue] as! UInt32)
@@ -51,7 +51,7 @@ final class ImportExceptionTests: XCTestCase {
             XCTAssertEqual(1, exception.values[0][PropertyId.tagRecipientType.rawValue] as! UInt32)
         }
         do {
-            let file = try OutlookRulesFile(data: Data([
+            let file = try OutlookRules(data: Data([
                 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x14, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
@@ -121,9 +121,9 @@ final class ImportExceptionTests: XCTestCase {
             XCTAssertEqual(0, file.rules[0].actions.count)
             XCTAssertEqual(1, file.rules[0].exceptions.count)
             XCTAssertEqual(.fromException, file.rules[0].exceptions[0].identifier)
-            XCTAssertTrue(file.rules[0].exceptions[0].data is PeopleOrPublicGroupListRuleElementData)
+            XCTAssertTrue(file.rules[0].exceptions[0].parameter is AddressParameter)
 
-            let exception = file.rules[0].exceptions[0].data as! PeopleOrPublicGroupListRuleElementData
+            let exception = file.rules[0].exceptions[0].parameter as!AddressParameter
             XCTAssertEqual(2, exception.values.count)
             XCTAssertEqual(11, exception.values[0].count)
             XCTAssertEqual(MAPI_E.NOT_FOUND.rawValue, exception.values[0][PropertyId.tagSmtpAddress.rawValue] as! UInt32)
@@ -145,7 +145,7 @@ final class ImportExceptionTests: XCTestCase {
 
     func testSpecificWordsInSubjectException() throws {
         do {
-            let file = try OutlookRulesFile(data: Data([
+            let file = try OutlookRules(data: Data([
                 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x14, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
@@ -164,13 +164,13 @@ final class ImportExceptionTests: XCTestCase {
             XCTAssertEqual(0, file.rules[0].actions.count)
             XCTAssertEqual(1, file.rules[0].exceptions.count)
             XCTAssertEqual(.specificWordsInSubjectException, file.rules[0].exceptions[0].identifier)
-            XCTAssertTrue(file.rules[0].exceptions[0].data is StringsListRuleElementData)
+            XCTAssertTrue(file.rules[0].exceptions[0].parameter is StringParameter)
 
-            let exception = file.rules[0].exceptions[0].data as! StringsListRuleElementData
-            XCTAssertEqual(["phrase"], exception.entries)
+            let exception = file.rules[0].exceptions[0].parameter as! StringParameter
+            XCTAssertEqual("phrase", exception.value)
         }
         do {
-            let file = try OutlookRulesFile(data: Data([
+            let file = try OutlookRules(data: Data([
                 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x14, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
@@ -190,16 +190,20 @@ final class ImportExceptionTests: XCTestCase {
             XCTAssertEqual(0, file.rules[0].actions.count)
             XCTAssertEqual(1, file.rules[0].exceptions.count)
             XCTAssertEqual(.specificWordsInSubjectException, file.rules[0].exceptions[0].identifier)
-            XCTAssertTrue(file.rules[0].exceptions[0].data is StringsListRuleElementData)
-            
-            let exception = file.rules[0].exceptions[0].data as! StringsListRuleElementData
-            XCTAssertEqual(["phrase", "other"], exception.entries)
+            XCTAssertEqual(2, file.rules[0].exceptions[0].parameters.count)
+            XCTAssertTrue(file.rules[0].exceptions[0].parameters[0] is StringParameter)
+            XCTAssertTrue(file.rules[0].exceptions[0].parameters[1] is StringParameter)
+
+            let exception1 = file.rules[0].exceptions[0].parameters[0] as! StringParameter
+            XCTAssertEqual("phrase", exception1.value)
+            let exception2 = file.rules[0].exceptions[0].parameters[1] as! StringParameter
+            XCTAssertEqual("other", exception2.value)
         }
     }
 
     func testThroughAccountException() throws {
         do {
-            let file = try OutlookRulesFile(data: Data([
+            let file = try OutlookRules(data: Data([
                 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x14, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
@@ -228,14 +232,14 @@ final class ImportExceptionTests: XCTestCase {
             XCTAssertEqual(0, file.rules[0].actions.count)
             XCTAssertEqual(1, file.rules[0].exceptions.count)
             XCTAssertEqual(.throughSpecifiedAccountException, file.rules[0].exceptions[0].identifier)
-            XCTAssertTrue(file.rules[0].exceptions[0].data is ThroughAccountRuleElementData)
+            XCTAssertTrue(file.rules[0].exceptions[0].parameter is AccountParameter)
 
-            let exception = file.rules[0].exceptions[0].data as! ThroughAccountRuleElementData
+            let exception = file.rules[0].exceptions[0].parameter as! AccountParameter
             XCTAssertEqual("hughbellars@gmail.com", exception.accountName)
             XCTAssertEqual("-190692068", exception.unknown)
         }
         do {
-            let file = try OutlookRulesFile(data: Data([
+            let file = try OutlookRules(data: Data([
                 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x14, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
@@ -257,13 +261,13 @@ final class ImportExceptionTests: XCTestCase {
             XCTAssertEqual(1, file.rules.count)
             XCTAssertEqual(1, file.rules[0].conditions.count)
             XCTAssertEqual(.onThisComputerOnlyCondition, file.rules[0].conditions[0].identifier)
-            XCTAssertTrue(file.rules[0].conditions[0].data is OnThisComputerOnlyRuleElementData)
+            XCTAssertTrue(file.rules[0].conditions[0].parameter is ProfileStampParameter)
             XCTAssertEqual(0, file.rules[0].actions.count)
             XCTAssertEqual(1, file.rules[0].exceptions.count)
             XCTAssertEqual(.throughSpecifiedAccountException, file.rules[0].exceptions[0].identifier)
-            XCTAssertTrue(file.rules[0].exceptions[0].data is ThroughAccountRuleElementData)
+            XCTAssertTrue(file.rules[0].exceptions[0].parameter is AccountParameter)
 
-            let exception = file.rules[0].exceptions[0].data as! ThroughAccountRuleElementData
+            let exception = file.rules[0].exceptions[0].parameter as! AccountParameter
             XCTAssertEqual("hughbellars@gmail.com", exception.accountName)
             XCTAssertEqual("-190692068", exception.unknown)
         }
@@ -271,7 +275,7 @@ final class ImportExceptionTests: XCTestCase {
 
     func testSentOnlyToMeException() throws {
         do {
-            let file = try OutlookRulesFile(data: Data([
+            let file = try OutlookRules(data: Data([
                 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x14, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
@@ -289,13 +293,13 @@ final class ImportExceptionTests: XCTestCase {
             XCTAssertEqual(0, file.rules[0].actions.count)
             XCTAssertEqual(1, file.rules[0].exceptions.count)
             XCTAssertEqual(.sentOnlyToMeException, file.rules[0].exceptions[0].identifier)
-            XCTAssertTrue(file.rules[0].exceptions[0].data is SimpleRuleElementData)
+            XCTAssertEqual(0, file.rules[0].exceptions[0].parameters.count)
         }
     }
 
     func testNameInToBoxException() throws {
         do {
-            let file = try OutlookRulesFile(data: Data([
+            let file = try OutlookRules(data: Data([
                 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x14, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
@@ -313,13 +317,13 @@ final class ImportExceptionTests: XCTestCase {
             XCTAssertEqual(0, file.rules[0].actions.count)
             XCTAssertEqual(1, file.rules[0].exceptions.count)
             XCTAssertEqual(.nameInToBoxException, file.rules[0].exceptions[0].identifier)
-            XCTAssertTrue(file.rules[0].exceptions[0].data is SimpleRuleElementData)
+            XCTAssertEqual(0, file.rules[0].exceptions[0].parameters.count)
         }
     }
 
     func testImportanceException() throws {
         do {
-            let file = try OutlookRulesFile(data: Data([
+            let file = try OutlookRules(data: Data([
                 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x14, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
@@ -338,13 +342,13 @@ final class ImportExceptionTests: XCTestCase {
             XCTAssertEqual(0, file.rules[0].actions.count)
             XCTAssertEqual(1, file.rules[0].exceptions.count)
             XCTAssertEqual(.importanceException, file.rules[0].exceptions[0].identifier)
-            XCTAssertTrue(file.rules[0].exceptions[0].data is ImportanceRuleElementData)
-            
-            let exception = file.rules[0].exceptions[0].data as! ImportanceRuleElementData
+            XCTAssertTrue(file.rules[0].exceptions[0].parameter is ImportanceParameter)
+
+            let exception = file.rules[0].exceptions[0].parameter as! ImportanceParameter
             XCTAssertEqual(MessageImportance.low, exception.importance)
         }
         do {
-            let file = try OutlookRulesFile(data: Data([
+            let file = try OutlookRules(data: Data([
                 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x14, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
@@ -363,13 +367,13 @@ final class ImportExceptionTests: XCTestCase {
             XCTAssertEqual(0, file.rules[0].actions.count)
             XCTAssertEqual(1, file.rules[0].exceptions.count)
             XCTAssertEqual(.importanceException, file.rules[0].exceptions[0].identifier)
-            XCTAssertTrue(file.rules[0].exceptions[0].data is ImportanceRuleElementData)
-            
-            let exception = file.rules[0].exceptions[0].data as! ImportanceRuleElementData
+            XCTAssertTrue(file.rules[0].exceptions[0].parameter is ImportanceParameter)
+
+            let exception = file.rules[0].exceptions[0].parameter as! ImportanceParameter
             XCTAssertEqual(MessageImportance.normal, exception.importance)
         }
         do {
-            let file = try OutlookRulesFile(data: Data([
+            let file = try OutlookRules(data: Data([
                 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x14, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
@@ -388,13 +392,13 @@ final class ImportExceptionTests: XCTestCase {
             XCTAssertEqual(0, file.rules[0].actions.count)
             XCTAssertEqual(1, file.rules[0].exceptions.count)
             XCTAssertEqual(.importanceException, file.rules[0].exceptions[0].identifier)
-            XCTAssertTrue(file.rules[0].exceptions[0].data is ImportanceRuleElementData)
-            
-            let exception = file.rules[0].exceptions[0].data as! ImportanceRuleElementData
+            XCTAssertTrue(file.rules[0].exceptions[0].parameter is ImportanceParameter)
+
+            let exception = file.rules[0].exceptions[0].parameter as! ImportanceParameter
             XCTAssertEqual(MessageImportance.high, exception.importance)
         }
         do {
-            let file = try OutlookRulesFile(data: Data([
+            let file = try OutlookRules(data: Data([
                 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x14, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
@@ -413,16 +417,16 @@ final class ImportExceptionTests: XCTestCase {
             XCTAssertEqual(0, file.rules[0].actions.count)
             XCTAssertEqual(1, file.rules[0].exceptions.count)
             XCTAssertEqual(.importanceException, file.rules[0].exceptions[0].identifier)
-            XCTAssertTrue(file.rules[0].exceptions[0].data is ImportanceRuleElementData)
-            
-            let exception = file.rules[0].exceptions[0].data as! ImportanceRuleElementData
+            XCTAssertTrue(file.rules[0].exceptions[0].parameter is ImportanceParameter)
+
+            let exception = file.rules[0].exceptions[0].parameter as! ImportanceParameter
             XCTAssertEqual(0x03, exception.rawImportance)
         }
     }
 
     func testsensitivityCondition() throws {
         do {
-            let file = try OutlookRulesFile(data: Data([
+            let file = try OutlookRules(data: Data([
                 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x14, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
@@ -441,13 +445,13 @@ final class ImportExceptionTests: XCTestCase {
             XCTAssertEqual(0, file.rules[0].actions.count)
             XCTAssertEqual(1, file.rules[0].exceptions.count)
             XCTAssertEqual(.sensitivityConditionException, file.rules[0].exceptions[0].identifier)
-            XCTAssertTrue(file.rules[0].exceptions[0].data is SensitivityRuleElementData)
-            
-            let exception = file.rules[0].exceptions[0].data as! SensitivityRuleElementData
+            XCTAssertTrue(file.rules[0].exceptions[0].parameter is SensitivityParameter)
+
+            let exception = file.rules[0].exceptions[0].parameter as! SensitivityParameter
             XCTAssertEqual(MessageSensitivity.normal, exception.sensitivity)
         }
         do {
-            let file = try OutlookRulesFile(data: Data([
+            let file = try OutlookRules(data: Data([
                 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x14, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
@@ -466,13 +470,13 @@ final class ImportExceptionTests: XCTestCase {
             XCTAssertEqual(0, file.rules[0].actions.count)
             XCTAssertEqual(1, file.rules[0].exceptions.count)
             XCTAssertEqual(.sensitivityConditionException, file.rules[0].exceptions[0].identifier)
-            XCTAssertTrue(file.rules[0].exceptions[0].data is SensitivityRuleElementData)
-            
-            let exception = file.rules[0].exceptions[0].data as! SensitivityRuleElementData
+            XCTAssertTrue(file.rules[0].exceptions[0].parameter is SensitivityParameter)
+
+            let exception = file.rules[0].exceptions[0].parameter as! SensitivityParameter
             XCTAssertEqual(MessageSensitivity.personal, exception.sensitivity)
         }
         do {
-            let file = try OutlookRulesFile(data: Data([
+            let file = try OutlookRules(data: Data([
                 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x14, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
@@ -491,13 +495,13 @@ final class ImportExceptionTests: XCTestCase {
             XCTAssertEqual(0, file.rules[0].actions.count)
             XCTAssertEqual(1, file.rules[0].exceptions.count)
             XCTAssertEqual(.sensitivityConditionException, file.rules[0].exceptions[0].identifier)
-            XCTAssertTrue(file.rules[0].exceptions[0].data is SensitivityRuleElementData)
-            
-            let exception = file.rules[0].exceptions[0].data as! SensitivityRuleElementData
+            XCTAssertTrue(file.rules[0].exceptions[0].parameter is SensitivityParameter)
+
+            let exception = file.rules[0].exceptions[0].parameter as! SensitivityParameter
             XCTAssertEqual(MessageSensitivity.`private`, exception.sensitivity)
         }
         do {
-            let file = try OutlookRulesFile(data: Data([
+            let file = try OutlookRules(data: Data([
                 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x14, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
@@ -516,13 +520,13 @@ final class ImportExceptionTests: XCTestCase {
             XCTAssertEqual(0, file.rules[0].actions.count)
             XCTAssertEqual(1, file.rules[0].exceptions.count)
             XCTAssertEqual(.sensitivityConditionException, file.rules[0].exceptions[0].identifier)
-            XCTAssertTrue(file.rules[0].exceptions[0].data is SensitivityRuleElementData)
-            
-            let exception = file.rules[0].exceptions[0].data as! SensitivityRuleElementData
+            XCTAssertTrue(file.rules[0].exceptions[0].parameter is SensitivityParameter)
+
+            let exception = file.rules[0].exceptions[0].parameter as! SensitivityParameter
             XCTAssertEqual(MessageSensitivity.confidential, exception.sensitivity)
         }
         do {
-            let file = try OutlookRulesFile(data: Data([
+            let file = try OutlookRules(data: Data([
                 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x14, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
@@ -541,16 +545,16 @@ final class ImportExceptionTests: XCTestCase {
             XCTAssertEqual(0, file.rules[0].actions.count)
             XCTAssertEqual(1, file.rules[0].exceptions.count)
             XCTAssertEqual(.sensitivityConditionException, file.rules[0].exceptions[0].identifier)
-            XCTAssertTrue(file.rules[0].exceptions[0].data is SensitivityRuleElementData)
-            
-            let exception = file.rules[0].exceptions[0].data as! SensitivityRuleElementData
+            XCTAssertTrue(file.rules[0].exceptions[0].parameter is SensitivityParameter)
+
+            let exception = file.rules[0].exceptions[0].parameter as! SensitivityParameter
             XCTAssertEqual(0x04, exception.rawSensitivity)
         }
     }
 
     func testFlaggedForActionException() throws {
         do {
-            let file = try OutlookRulesFile(data: Data([
+            let file = try OutlookRules(data: Data([
                 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x14, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
@@ -570,16 +574,16 @@ final class ImportExceptionTests: XCTestCase {
             XCTAssertEqual(0, file.rules[0].actions.count)
             XCTAssertEqual(1, file.rules[0].exceptions.count)
             XCTAssertEqual(.flaggedForActionException, file.rules[0].exceptions[0].identifier)
-            XCTAssertTrue(file.rules[0].exceptions[0].data is FlaggedForActionRuleElementData)
-            
-            let exception = file.rules[0].exceptions[0].data as! FlaggedForActionRuleElementData
+            XCTAssertTrue(file.rules[0].exceptions[0].parameter is FlaggedForActionParameter)
+
+            let exception = file.rules[0].exceptions[0].parameter as! FlaggedForActionParameter
             XCTAssertEqual("Follow up", exception.action)
         }
     }
-    
+
     func testNameInCcBoxException() throws {
         do {
-            let file = try OutlookRulesFile(data: Data([
+            let file = try OutlookRules(data: Data([
                 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x14, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
@@ -597,13 +601,13 @@ final class ImportExceptionTests: XCTestCase {
             XCTAssertEqual(0, file.rules[0].actions.count)
             XCTAssertEqual(1, file.rules[0].exceptions.count)
             XCTAssertEqual(.nameInCcBoxException, file.rules[0].exceptions[0].identifier)
-            XCTAssertTrue(file.rules[0].exceptions[0].data is SimpleRuleElementData)
+            XCTAssertEqual(0, file.rules[0].exceptions[0].parameters.count)
         }
     }
 
     func testNameInToOrCcBoxException() throws {
         do {
-            let file = try OutlookRulesFile(data: Data([
+            let file = try OutlookRules(data: Data([
                 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x14, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
@@ -621,13 +625,13 @@ final class ImportExceptionTests: XCTestCase {
             XCTAssertEqual(0, file.rules[0].actions.count)
             XCTAssertEqual(1, file.rules[0].exceptions.count)
             XCTAssertEqual(.nameInToOrCcBoxException, file.rules[0].exceptions[0].identifier)
-            XCTAssertTrue(file.rules[0].exceptions[0].data is SimpleRuleElementData)
+            XCTAssertEqual(0, file.rules[0].exceptions[0].parameters.count)
         }
     }
 
     func testNameNotInToBoxException() throws {
         do {
-            let file = try OutlookRulesFile(data: Data([
+            let file = try OutlookRules(data: Data([
                 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x14, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
@@ -643,7 +647,7 @@ final class ImportExceptionTests: XCTestCase {
             XCTAssertEqual(1, file.rules.count)
             XCTAssertEqual(0, file.rules[0].conditions.count)
             XCTAssertEqual(.nameNotInToBoxException, file.rules[0].exceptions[0].identifier)
-            XCTAssertTrue(file.rules[0].exceptions[0].data is SimpleRuleElementData)
+            XCTAssertEqual(0, file.rules[0].exceptions[0].parameters.count)
             XCTAssertEqual(0, file.rules[0].actions.count)
             XCTAssertEqual(1, file.rules[0].exceptions.count)
         }
@@ -651,7 +655,7 @@ final class ImportExceptionTests: XCTestCase {
 
     func testToException() throws {
         do {
-            let file = try OutlookRulesFile(data: Data([
+            let file = try OutlookRules(data: Data([
                 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x14, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
@@ -678,9 +682,9 @@ final class ImportExceptionTests: XCTestCase {
             XCTAssertEqual(0, file.rules[0].actions.count)
             XCTAssertEqual(1, file.rules[0].exceptions.count)
             XCTAssertEqual(.toException, file.rules[0].exceptions[0].identifier)
-            XCTAssertTrue(file.rules[0].exceptions[0].data is PeopleOrPublicGroupListRuleElementData)
-            
-            let exception = file.rules[0].exceptions[0].data as! PeopleOrPublicGroupListRuleElementData
+            XCTAssertTrue(file.rules[0].exceptions[0].parameter is AddressParameter)
+
+            let exception = file.rules[0].exceptions[0].parameter as!AddressParameter
             XCTAssertEqual(1, exception.values.count)
             XCTAssertEqual(6, exception.values[0].count)
             XCTAssertEqual(MAPI_E.NOT_FOUND.rawValue, exception.values[0][PropertyId.tagSmtpAddress.rawValue] as! UInt32)
@@ -691,7 +695,7 @@ final class ImportExceptionTests: XCTestCase {
             XCTAssertEqual(1, exception.values[0][PropertyId.tagRecipientType.rawValue] as! UInt32)
         }
         do {
-            let file = try OutlookRulesFile(data: Data([
+            let file = try OutlookRules(data: Data([
                 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x14, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
@@ -761,9 +765,9 @@ final class ImportExceptionTests: XCTestCase {
             XCTAssertEqual(0, file.rules[0].actions.count)
             XCTAssertEqual(1, file.rules[0].exceptions.count)
             XCTAssertEqual(.toException, file.rules[0].exceptions[0].identifier)
-            XCTAssertTrue(file.rules[0].exceptions[0].data is PeopleOrPublicGroupListRuleElementData)
-            
-            let exception = file.rules[0].exceptions[0].data as! PeopleOrPublicGroupListRuleElementData
+            XCTAssertTrue(file.rules[0].exceptions[0].parameter is AddressParameter)
+
+            let exception = file.rules[0].exceptions[0].parameter as!AddressParameter
             XCTAssertEqual(2, exception.values.count)
             XCTAssertEqual(11, exception.values[0].count)
             XCTAssertEqual(MAPI_E.NOT_FOUND.rawValue, exception.values[0][PropertyId.tagSmtpAddress.rawValue] as! UInt32)
@@ -785,7 +789,7 @@ final class ImportExceptionTests: XCTestCase {
 
     func testSpecificWordsInBodyException() throws {
         do {
-            let file = try OutlookRulesFile(data: Data([
+            let file = try OutlookRules(data: Data([
                 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x14, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
@@ -804,13 +808,13 @@ final class ImportExceptionTests: XCTestCase {
             XCTAssertEqual(0, file.rules[0].actions.count)
             XCTAssertEqual(1, file.rules[0].exceptions.count)
             XCTAssertEqual(.specificWordsInBodyException, file.rules[0].exceptions[0].identifier)
-            XCTAssertTrue(file.rules[0].exceptions[0].data is StringsListRuleElementData)
-            
-            let exception = file.rules[0].exceptions[0].data as! StringsListRuleElementData
-            XCTAssertEqual(["phrase"], exception.entries)
+            XCTAssertTrue(file.rules[0].exceptions[0].parameter is StringParameter)
+
+            let exception = file.rules[0].exceptions[0].parameter as! StringParameter
+            XCTAssertEqual("phrase", exception.value)
         }
         do {
-            let file = try OutlookRulesFile(data: Data([
+            let file = try OutlookRules(data: Data([
                 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x14, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
@@ -830,16 +834,20 @@ final class ImportExceptionTests: XCTestCase {
             XCTAssertEqual(0, file.rules[0].actions.count)
             XCTAssertEqual(1, file.rules[0].exceptions.count)
             XCTAssertEqual(.specificWordsInBodyException, file.rules[0].exceptions[0].identifier)
-            XCTAssertTrue(file.rules[0].exceptions[0].data is StringsListRuleElementData)
-            
-            let exception = file.rules[0].exceptions[0].data as! StringsListRuleElementData
-            XCTAssertEqual(["phrase", "other"], exception.entries)
+            XCTAssertEqual(2, file.rules[0].exceptions[0].parameters.count)
+            XCTAssertTrue(file.rules[0].exceptions[0].parameters[0] is StringParameter)
+            XCTAssertTrue(file.rules[0].exceptions[0].parameters[1] is StringParameter)
+
+            let exception1 = file.rules[0].exceptions[0].parameters[0] as! StringParameter
+            XCTAssertEqual("phrase", exception1.value)
+            let exception2 = file.rules[0].exceptions[0].parameters[1] as! StringParameter
+            XCTAssertEqual("other", exception2.value)
         }
     }
 
     func testSpecificWordsInSubjectOrBodyException() throws {
         do {
-            let file = try OutlookRulesFile(data: Data([
+            let file = try OutlookRules(data: Data([
                 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x14, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
@@ -858,13 +866,13 @@ final class ImportExceptionTests: XCTestCase {
             XCTAssertEqual(0, file.rules[0].actions.count)
             XCTAssertEqual(1, file.rules[0].exceptions.count)
             XCTAssertEqual(.specificWordsInSubjectOrBodyException, file.rules[0].exceptions[0].identifier)
-            XCTAssertTrue(file.rules[0].exceptions[0].data is StringsListRuleElementData)
-            
-            let exception = file.rules[0].exceptions[0].data as! StringsListRuleElementData
-            XCTAssertEqual(["phrase"], exception.entries)
+            XCTAssertTrue(file.rules[0].exceptions[0].parameter is StringParameter)
+
+            let exception = file.rules[0].exceptions[0].parameter as! StringParameter
+            XCTAssertEqual("phrase", exception.value)
         }
         do {
-            let file = try OutlookRulesFile(data: Data([
+            let file = try OutlookRules(data: Data([
                 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x14, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
@@ -884,16 +892,20 @@ final class ImportExceptionTests: XCTestCase {
             XCTAssertEqual(0, file.rules[0].actions.count)
             XCTAssertEqual(1, file.rules[0].exceptions.count)
             XCTAssertEqual(.specificWordsInSubjectOrBodyException, file.rules[0].exceptions[0].identifier)
-            XCTAssertTrue(file.rules[0].exceptions[0].data is StringsListRuleElementData)
-            
-            let exception = file.rules[0].exceptions[0].data as! StringsListRuleElementData
-            XCTAssertEqual(["phrase", "other"], exception.entries)
+            XCTAssertEqual(2, file.rules[0].exceptions[0].parameters.count)
+            XCTAssertTrue(file.rules[0].exceptions[0].parameters[0] is StringParameter)
+            XCTAssertTrue(file.rules[0].exceptions[0].parameters[1] is StringParameter)
+
+            let exception1 = file.rules[0].exceptions[0].parameters[0] as! StringParameter
+            XCTAssertEqual("phrase", exception1.value)
+            let exception2 = file.rules[0].exceptions[0].parameters[1] as! StringParameter
+            XCTAssertEqual("other", exception2.value)
         }
     }
 
     func testSpecificWordsInMessageHeaderException() throws {
         do {
-            let file = try OutlookRulesFile(data: Data([
+            let file = try OutlookRules(data: Data([
                 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x14, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
@@ -912,13 +924,13 @@ final class ImportExceptionTests: XCTestCase {
             XCTAssertEqual(0, file.rules[0].actions.count)
             XCTAssertEqual(1, file.rules[0].exceptions.count)
             XCTAssertEqual(.specificWordsInMessageHeaderException, file.rules[0].exceptions[0].identifier)
-            XCTAssertTrue(file.rules[0].exceptions[0].data is StringsListRuleElementData)
-            
-            let exception = file.rules[0].exceptions[0].data as! StringsListRuleElementData
-            XCTAssertEqual(["phrase"], exception.entries)
+            XCTAssertTrue(file.rules[0].exceptions[0].parameter is StringParameter)
+
+            let exception = file.rules[0].exceptions[0].parameter as! StringParameter
+            XCTAssertEqual("phrase", exception.value)
         }
         do {
-            let file = try OutlookRulesFile(data: Data([
+            let file = try OutlookRules(data: Data([
                 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x14, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
@@ -938,16 +950,20 @@ final class ImportExceptionTests: XCTestCase {
             XCTAssertEqual(0, file.rules[0].actions.count)
             XCTAssertEqual(1, file.rules[0].exceptions.count)
             XCTAssertEqual(.specificWordsInMessageHeaderException, file.rules[0].exceptions[0].identifier)
-            XCTAssertTrue(file.rules[0].exceptions[0].data is StringsListRuleElementData)
-            
-            let exception = file.rules[0].exceptions[0].data as! StringsListRuleElementData
-            XCTAssertEqual(["phrase", "other"], exception.entries)
+            XCTAssertEqual(2, file.rules[0].exceptions[0].parameters.count)
+            XCTAssertTrue(file.rules[0].exceptions[0].parameters[0] is StringParameter)
+            XCTAssertTrue(file.rules[0].exceptions[0].parameters[1] is StringParameter)
+
+            let exception1 = file.rules[0].exceptions[0].parameters[0] as! StringParameter
+            XCTAssertEqual("phrase", exception1.value)
+            let exception2 = file.rules[0].exceptions[0].parameters[1] as! StringParameter
+            XCTAssertEqual("other", exception2.value)
         }
     }
 
     func testSpecificWordsInSendersAddressException() throws {
         do {
-            let file = try OutlookRulesFile(data: Data([
+            let file = try OutlookRules(data: Data([
                 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x14, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
@@ -966,13 +982,13 @@ final class ImportExceptionTests: XCTestCase {
             XCTAssertEqual(0, file.rules[0].actions.count)
             XCTAssertEqual(1, file.rules[0].exceptions.count)
             XCTAssertEqual(.specificWordsInSendersAddressException, file.rules[0].exceptions[0].identifier)
-            XCTAssertTrue(file.rules[0].exceptions[0].data is StringsListRuleElementData)
-            
-            let exception = file.rules[0].exceptions[0].data as! StringsListRuleElementData
-            XCTAssertEqual(["phrase"], exception.entries)
+            XCTAssertTrue(file.rules[0].exceptions[0].parameter is StringParameter)
+
+            let exception = file.rules[0].exceptions[0].parameter as! StringParameter
+            XCTAssertEqual("phrase", exception.value)
         }
         do {
-            let file = try OutlookRulesFile(data: Data([
+            let file = try OutlookRules(data: Data([
                 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x14, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
@@ -992,16 +1008,20 @@ final class ImportExceptionTests: XCTestCase {
             XCTAssertEqual(0, file.rules[0].actions.count)
             XCTAssertEqual(1, file.rules[0].exceptions.count)
             XCTAssertEqual(.specificWordsInSendersAddressException, file.rules[0].exceptions[0].identifier)
-            XCTAssertTrue(file.rules[0].exceptions[0].data is StringsListRuleElementData)
-            
-            let exception = file.rules[0].exceptions[0].data as! StringsListRuleElementData
-            XCTAssertEqual(["phrase", "other"], exception.entries)
+            XCTAssertEqual(2, file.rules[0].exceptions[0].parameters.count)
+            XCTAssertTrue(file.rules[0].exceptions[0].parameters[0] is StringParameter)
+            XCTAssertTrue(file.rules[0].exceptions[0].parameters[1] is StringParameter)
+
+            let exception1 = file.rules[0].exceptions[0].parameters[0] as! StringParameter
+            XCTAssertEqual("phrase", exception1.value)
+            let exception2 = file.rules[0].exceptions[0].parameters[1] as! StringParameter
+            XCTAssertEqual("other", exception2.value)
         }
     }
 
     func testSpecificWordsInRecipientsAddressException() throws {
         do {
-            let file = try OutlookRulesFile(data: Data([
+            let file = try OutlookRules(data: Data([
                 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x14, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
@@ -1020,13 +1040,13 @@ final class ImportExceptionTests: XCTestCase {
             XCTAssertEqual(0, file.rules[0].actions.count)
             XCTAssertEqual(1, file.rules[0].exceptions.count)
             XCTAssertEqual(.specificWordsInRecipientsAddressException, file.rules[0].exceptions[0].identifier)
-            XCTAssertTrue(file.rules[0].exceptions[0].data is StringsListRuleElementData)
-            
-            let exception = file.rules[0].exceptions[0].data as! StringsListRuleElementData
-            XCTAssertEqual(["phrase"], exception.entries)
+            XCTAssertTrue(file.rules[0].exceptions[0].parameter is StringParameter)
+
+            let exception = file.rules[0].exceptions[0].parameter as! StringParameter
+            XCTAssertEqual("phrase", exception.value)
         }
         do {
-            let file = try OutlookRulesFile(data: Data([
+            let file = try OutlookRules(data: Data([
                 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x14, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
@@ -1046,16 +1066,20 @@ final class ImportExceptionTests: XCTestCase {
             XCTAssertEqual(0, file.rules[0].actions.count)
             XCTAssertEqual(1, file.rules[0].exceptions.count)
             XCTAssertEqual(.specificWordsInRecipientsAddressException, file.rules[0].exceptions[0].identifier)
-            XCTAssertTrue(file.rules[0].exceptions[0].data is StringsListRuleElementData)
-            
-            let exception = file.rules[0].exceptions[0].data as! StringsListRuleElementData
-            XCTAssertEqual(["phrase", "other"], exception.entries)
+            XCTAssertEqual(2, file.rules[0].exceptions[0].parameters.count)
+            XCTAssertTrue(file.rules[0].exceptions[0].parameters[0] is StringParameter)
+            XCTAssertTrue(file.rules[0].exceptions[0].parameters[1] is StringParameter)
+
+            let exception1 = file.rules[0].exceptions[0].parameters[0] as! StringParameter
+            XCTAssertEqual("phrase", exception1.value)
+            let exception2 = file.rules[0].exceptions[0].parameters[1] as! StringParameter
+            XCTAssertEqual("other", exception2.value)
         }
     }
 
     func testAssignedToCategoryException() throws {
         do {
-            let file = try OutlookRulesFile(data: Data([
+            let file = try OutlookRules(data: Data([
                 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x14, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
@@ -1075,13 +1099,13 @@ final class ImportExceptionTests: XCTestCase {
             XCTAssertEqual(0, file.rules[0].actions.count)
             XCTAssertEqual(1, file.rules[0].exceptions.count)
             XCTAssertEqual(.assignedToCategoryException, file.rules[0].exceptions[0].identifier)
-            XCTAssertTrue(file.rules[0].exceptions[0].data is CategoriesListRuleElementData)
-            
-            let exception = file.rules[0].exceptions[0].data as! CategoriesListRuleElementData
+            XCTAssertTrue(file.rules[0].exceptions[0].parameter is CategoryParameter)
+
+            let exception = file.rules[0].exceptions[0].parameter as!CategoryParameter
             XCTAssertEqual(["Blue Category"], exception.categories)
         }
         do {
-            let file = try OutlookRulesFile(data: Data([
+            let file = try OutlookRules(data: Data([
                 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x14, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
@@ -1102,16 +1126,16 @@ final class ImportExceptionTests: XCTestCase {
             XCTAssertEqual(0, file.rules[0].actions.count)
             XCTAssertEqual(1, file.rules[0].exceptions.count)
             XCTAssertEqual(.assignedToCategoryException, file.rules[0].exceptions[0].identifier)
-            XCTAssertTrue(file.rules[0].exceptions[0].data is CategoriesListRuleElementData)
-            
-            let exception = file.rules[0].exceptions[0].data as! CategoriesListRuleElementData
+            XCTAssertTrue(file.rules[0].exceptions[0].parameter is CategoryParameter)
+
+            let exception = file.rules[0].exceptions[0].parameter as!CategoryParameter
             XCTAssertEqual(["Blue Category", "Other"], exception.categories)
         }
     }
 
     func testAssignedToAnyCategoryException() throws {
         do {
-            let file = try OutlookRulesFile(data: Data([
+            let file = try OutlookRules(data: Data([
                 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x14, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
@@ -1129,13 +1153,13 @@ final class ImportExceptionTests: XCTestCase {
             XCTAssertEqual(0, file.rules[0].actions.count)
             XCTAssertEqual(1, file.rules[0].exceptions.count)
             XCTAssertEqual(.assignedToAnyCategoryException, file.rules[0].exceptions[0].identifier)
-            XCTAssertTrue(file.rules[0].exceptions[0].data is SimpleRuleElementData)
+            XCTAssertEqual(0, file.rules[0].exceptions[0].parameters.count)
         }
     }
 
     func testWhichIsAnAutomaticReplyException() throws {
         do {
-            let file = try OutlookRulesFile(data: Data([
+            let file = try OutlookRules(data: Data([
                 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x14, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
@@ -1153,13 +1177,13 @@ final class ImportExceptionTests: XCTestCase {
             XCTAssertEqual(0, file.rules[0].actions.count)
             XCTAssertEqual(1, file.rules[0].exceptions.count)
             XCTAssertEqual(.automaticReplyException, file.rules[0].exceptions[0].identifier)
-            XCTAssertTrue(file.rules[0].exceptions[0].data is SimpleRuleElementData)
+            XCTAssertEqual(0, file.rules[0].exceptions[0].parameters.count)
         }
     }
 
     func testHasAttachmentException() throws {
         do {
-            let file = try OutlookRulesFile(data: Data([
+            let file = try OutlookRules(data: Data([
                 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x14, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
@@ -1177,13 +1201,13 @@ final class ImportExceptionTests: XCTestCase {
             XCTAssertEqual(0, file.rules[0].actions.count)
             XCTAssertEqual(1, file.rules[0].exceptions.count)
             XCTAssertEqual(.hasAttachmentException, file.rules[0].exceptions[0].identifier)
-            XCTAssertTrue(file.rules[0].exceptions[0].data is SimpleRuleElementData)
+            XCTAssertEqual(0, file.rules[0].exceptions[0].parameters.count)
         }
     }
 
     func testSizeInSpecificRangeException() throws {
         do {
-            let file = try OutlookRulesFile(data: Data([
+            let file = try OutlookRules(data: Data([
                 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x14, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
@@ -1202,14 +1226,14 @@ final class ImportExceptionTests: XCTestCase {
             XCTAssertEqual(0, file.rules[0].actions.count)
             XCTAssertEqual(1, file.rules[0].exceptions.count)
             XCTAssertEqual(.sizeInSpecificRangeException, file.rules[0].exceptions[0].identifier)
-            XCTAssertTrue(file.rules[0].exceptions[0].data is SizeInSpecificRangeRuleElementData)
-            
-            let exception = file.rules[0].exceptions[0].data as! SizeInSpecificRangeRuleElementData
+            XCTAssertTrue(file.rules[0].exceptions[0].parameter is SizeParameter)
+
+            let exception = file.rules[0].exceptions[0].parameter as! SizeParameter
             XCTAssertEqual(0, exception.minSizeInKilobytes)
             XCTAssertEqual(0, exception.maxSizeInKilobytes)
         }
         do {
-            let file = try OutlookRulesFile(data: Data([
+            let file = try OutlookRules(data: Data([
                 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x14, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
@@ -1228,14 +1252,14 @@ final class ImportExceptionTests: XCTestCase {
             XCTAssertEqual(0, file.rules[0].actions.count)
             XCTAssertEqual(1, file.rules[0].exceptions.count)
             XCTAssertEqual(.sizeInSpecificRangeException, file.rules[0].exceptions[0].identifier)
-            XCTAssertTrue(file.rules[0].exceptions[0].data is SizeInSpecificRangeRuleElementData)
-            
-            let exception = file.rules[0].exceptions[0].data as! SizeInSpecificRangeRuleElementData
+            XCTAssertTrue(file.rules[0].exceptions[0].parameter is SizeParameter)
+
+            let exception = file.rules[0].exceptions[0].parameter as! SizeParameter
             XCTAssertEqual(1, exception.minSizeInKilobytes)
             XCTAssertEqual(0, exception.maxSizeInKilobytes)
         }
         do {
-            let file = try OutlookRulesFile(data: Data([
+            let file = try OutlookRules(data: Data([
                 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x14, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
@@ -1254,14 +1278,14 @@ final class ImportExceptionTests: XCTestCase {
             XCTAssertEqual(0, file.rules[0].actions.count)
             XCTAssertEqual(1, file.rules[0].exceptions.count)
             XCTAssertEqual(.sizeInSpecificRangeException, file.rules[0].exceptions[0].identifier)
-            XCTAssertTrue(file.rules[0].exceptions[0].data is SizeInSpecificRangeRuleElementData)
-            
-            let exception = file.rules[0].exceptions[0].data as! SizeInSpecificRangeRuleElementData
+            XCTAssertTrue(file.rules[0].exceptions[0].parameter is SizeParameter)
+
+            let exception = file.rules[0].exceptions[0].parameter as! SizeParameter
             XCTAssertEqual(0, exception.minSizeInKilobytes)
             XCTAssertEqual(1, exception.maxSizeInKilobytes)
         }
         do {
-            let file = try OutlookRulesFile(data: Data([
+            let file = try OutlookRules(data: Data([
                 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x14, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
@@ -1280,14 +1304,14 @@ final class ImportExceptionTests: XCTestCase {
             XCTAssertEqual(0, file.rules[0].actions.count)
             XCTAssertEqual(1, file.rules[0].exceptions.count)
             XCTAssertEqual(.sizeInSpecificRangeException, file.rules[0].exceptions[0].identifier)
-            XCTAssertTrue(file.rules[0].exceptions[0].data is SizeInSpecificRangeRuleElementData)
-            
-            let exception = file.rules[0].exceptions[0].data as! SizeInSpecificRangeRuleElementData
+            XCTAssertTrue(file.rules[0].exceptions[0].parameter is SizeParameter)
+
+            let exception = file.rules[0].exceptions[0].parameter as! SizeParameter
             XCTAssertEqual(1, exception.minSizeInKilobytes)
             XCTAssertEqual(1, exception.maxSizeInKilobytes)
         }
         do {
-            let file = try OutlookRulesFile(data: Data([
+            let file = try OutlookRules(data: Data([
                 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x14, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
@@ -1306,9 +1330,9 @@ final class ImportExceptionTests: XCTestCase {
             XCTAssertEqual(0, file.rules[0].actions.count)
             XCTAssertEqual(1, file.rules[0].exceptions.count)
             XCTAssertEqual(.sizeInSpecificRangeException, file.rules[0].exceptions[0].identifier)
-            XCTAssertTrue(file.rules[0].exceptions[0].data is SizeInSpecificRangeRuleElementData)
-            
-            let exception = file.rules[0].exceptions[0].data as! SizeInSpecificRangeRuleElementData
+            XCTAssertTrue(file.rules[0].exceptions[0].parameter is SizeParameter)
+
+            let exception = file.rules[0].exceptions[0].parameter as! SizeParameter
             XCTAssertEqual(1, exception.minSizeInKilobytes)
             XCTAssertEqual(999999, exception.maxSizeInKilobytes)
         }
@@ -1319,7 +1343,7 @@ final class ImportExceptionTests: XCTestCase {
         var calendar = Calendar(identifier: .gregorian)
         calendar.timeZone = timeZone
         do {
-            let file = try OutlookRulesFile(data: Data([
+            let file = try OutlookRules(data: Data([
                 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x14, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
@@ -1340,16 +1364,16 @@ final class ImportExceptionTests: XCTestCase {
             XCTAssertEqual(0, file.rules[0].actions.count)
             XCTAssertEqual(1, file.rules[0].exceptions.count)
             XCTAssertEqual(.receivedInSpecificDateSpanException, file.rules[0].exceptions[0].identifier)
-            XCTAssertTrue(file.rules[0].exceptions[0].data is ReceivedInSpecificDateSpanRuleElementData)
-            
-            let exception = file.rules[0].exceptions[0].data as! ReceivedInSpecificDateSpanRuleElementData
+            XCTAssertTrue(file.rules[0].exceptions[0].parameter is TimeParameter)
+
+            let exception = file.rules[0].exceptions[0].parameter as! TimeParameter
             XCTAssertTrue(exception.includeAfterDate)
             XCTAssertEqual(calendar.date(from: DateComponents(timeZone: timeZone, year: 2020, month: 08, day: 08, hour: 23, minute: 59, second: 0)), exception.afterDate.date)
             XCTAssertFalse(exception.includeBeforeDate)
                 XCTAssertEqual(calendar.date(from: DateComponents(timeZone: timeZone, year: 2020, month: 08, day: 09)), exception.beforeDate.date)
         }
         do {
-            let file = try OutlookRulesFile(data: Data([
+            let file = try OutlookRules(data: Data([
                 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x14, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
@@ -1370,16 +1394,16 @@ final class ImportExceptionTests: XCTestCase {
             XCTAssertEqual(0, file.rules[0].actions.count)
             XCTAssertEqual(1, file.rules[0].exceptions.count)
             XCTAssertEqual(.receivedInSpecificDateSpanException, file.rules[0].exceptions[0].identifier)
-            XCTAssertTrue(file.rules[0].exceptions[0].data is ReceivedInSpecificDateSpanRuleElementData)
-            
-            let exception = file.rules[0].exceptions[0].data as! ReceivedInSpecificDateSpanRuleElementData
+            XCTAssertTrue(file.rules[0].exceptions[0].parameter is TimeParameter)
+
+            let exception = file.rules[0].exceptions[0].parameter as! TimeParameter
             XCTAssertFalse(exception.includeAfterDate)
             XCTAssertEqual(calendar.date(from: DateComponents(timeZone: timeZone, year: 2020, month: 08, day: 09, hour: 23, minute: 59, second: 0)), exception.afterDate.date)
             XCTAssertTrue(exception.includeBeforeDate)
             XCTAssertEqual(calendar.date(from: DateComponents(timeZone: timeZone, year: 2020, month: 08, day: 02)), exception.beforeDate.date)
         }
         do {
-            let file = try OutlookRulesFile(data: Data([
+            let file = try OutlookRules(data: Data([
                 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x14, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
@@ -1400,10 +1424,10 @@ final class ImportExceptionTests: XCTestCase {
             XCTAssertEqual(0, file.rules[0].actions.count)
             XCTAssertEqual(1, file.rules[0].exceptions.count)
             XCTAssertEqual(.receivedInSpecificDateSpanException, file.rules[0].exceptions[0].identifier)
-            XCTAssertTrue(file.rules[0].exceptions[0].data is ReceivedInSpecificDateSpanRuleElementData)
-            
+            XCTAssertTrue(file.rules[0].exceptions[0].parameter is TimeParameter)
+
             let calendar = Calendar(identifier: .gregorian)
-            let exception = file.rules[0].exceptions[0].data as! ReceivedInSpecificDateSpanRuleElementData
+            let exception = file.rules[0].exceptions[0].parameter as! TimeParameter
             XCTAssertTrue(exception.includeAfterDate)
             XCTAssertEqual(calendar.date(from: DateComponents(timeZone: timeZone, year: 2020, month: 08, day: 02, hour: 23, minute: 59, second: 0)), exception.afterDate.date)
             XCTAssertTrue(exception.includeBeforeDate)
@@ -1413,7 +1437,7 @@ final class ImportExceptionTests: XCTestCase {
 
     func testUsesFormException() throws {
         do {
-            let file = try OutlookRulesFile(data: Data([
+            let file = try OutlookRules(data: Data([
                 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x14, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
@@ -1436,15 +1460,15 @@ final class ImportExceptionTests: XCTestCase {
             XCTAssertEqual(0, file.rules[0].actions.count)
             XCTAssertEqual(1, file.rules[0].exceptions.count)
             XCTAssertEqual(.usesFormException, file.rules[0].exceptions[0].identifier)
-            XCTAssertTrue(file.rules[0].exceptions[0].data is FormTypeRuleElementData)
-            
-            let exception = file.rules[0].exceptions[0].data as! FormTypeRuleElementData
-            XCTAssertEqual(1, exception.numberOfForms)
-            XCTAssertEqual("Accept Meeting Response", exception.forms[0].name)
-            XCTAssertEqual("IPM.Schedule.Meeting.Resp.Pos", exception.forms[0].className)
+            XCTAssertEqual(1, file.rules[0].exceptions[0].parameters.count)
+            XCTAssertTrue(file.rules[0].exceptions[0].parameter is FormTypeParameter)
+
+            let exception = file.rules[0].exceptions[0].parameter as! FormTypeParameter
+            XCTAssertEqual("Accept Meeting Response", exception.name)
+            XCTAssertEqual("IPM.Schedule.Meeting.Resp.Pos", exception.className)
         }
         do {
-            let file = try OutlookRulesFile(data: Data([
+            let file = try OutlookRules(data: Data([
                 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x14, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
@@ -1471,21 +1495,23 @@ final class ImportExceptionTests: XCTestCase {
             XCTAssertEqual(0, file.rules[0].actions.count)
             XCTAssertEqual(1, file.rules[0].exceptions.count)
             XCTAssertEqual(.usesFormException, file.rules[0].exceptions[0].identifier)
-            XCTAssertTrue(file.rules[0].exceptions[0].data is FormTypeRuleElementData)
-            
-            let exception = file.rules[0].exceptions[0].data as! FormTypeRuleElementData
-            XCTAssertEqual(2, exception.numberOfForms)
-            XCTAssertEqual("Accept Meeting Response", exception.forms[0].name)
-            XCTAssertEqual("IPM.Schedule.Meeting.Resp.Pos", exception.forms[0].className)
-            XCTAssertEqual("Text Message", exception.forms[1].name)
-            XCTAssertEqual("IPM.Note.Mobile.SMS", exception.forms[1].className)
+            XCTAssertEqual(2, file.rules[0].exceptions[0].parameters.count)
+            XCTAssertTrue(file.rules[0].exceptions[0].parameters[0] is FormTypeParameter)
+            XCTAssertTrue(file.rules[0].exceptions[0].parameters[1] is FormTypeParameter)
+
+            let exception1 = file.rules[0].exceptions[0].parameters[0] as! FormTypeParameter
+            XCTAssertEqual("Accept Meeting Response", exception1.name)
+            XCTAssertEqual("IPM.Schedule.Meeting.Resp.Pos", exception1.className)
+            let exception2 = file.rules[0].exceptions[0].parameters[1] as! FormTypeParameter
+            XCTAssertEqual("Text Message", exception2.name)
+            XCTAssertEqual("IPM.Note.Mobile.SMS", exception2.className)
         }
     }
 
     func testWithSelectedPropertiesOfDocumentOrFormsException() throws {
         // String, contains
         do {
-            let file = try OutlookRulesFile(data: Data([
+            let file = try OutlookRules(data: Data([
                 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x14, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
@@ -1511,9 +1537,9 @@ final class ImportExceptionTests: XCTestCase {
             XCTAssertEqual(0, file.rules[0].actions.count)
             XCTAssertEqual(1, file.rules[0].exceptions.count)
             XCTAssertEqual(.withSelectedPropertiesOfDocumentOrFormsException, file.rules[0].exceptions[0].identifier)
-            XCTAssertTrue(file.rules[0].exceptions[0].data is WithSelectedPropertiesOfDocumentOrFormsRuleElementData)
-            
-            let exception = file.rules[0].exceptions[0].data as! WithSelectedPropertiesOfDocumentOrFormsRuleElementData
+            XCTAssertTrue(file.rules[0].exceptions[0].parameter is FormParameter)
+
+            let exception = file.rules[0].exceptions[0].parameter as! FormParameter
             XCTAssertEqual(["Accept Meeting Response"], exception.forms)
             XCTAssertEqual(1, exception.documentProperties.count)
             XCTAssertEqual("Author", exception.documentProperties[0].field)
@@ -1529,7 +1555,7 @@ final class ImportExceptionTests: XCTestCase {
         }
         // String, isEqual
         do {
-            let file = try OutlookRulesFile(data: Data([
+            let file = try OutlookRules(data: Data([
                 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x14, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
@@ -1553,9 +1579,9 @@ final class ImportExceptionTests: XCTestCase {
             XCTAssertEqual(0, file.rules[0].actions.count)
             XCTAssertEqual(1, file.rules[0].exceptions.count)
             XCTAssertEqual(.withSelectedPropertiesOfDocumentOrFormsException, file.rules[0].exceptions[0].identifier)
-            XCTAssertTrue(file.rules[0].exceptions[0].data is WithSelectedPropertiesOfDocumentOrFormsRuleElementData)
-            
-            let exception = file.rules[0].exceptions[0].data as! WithSelectedPropertiesOfDocumentOrFormsRuleElementData
+            XCTAssertTrue(file.rules[0].exceptions[0].parameter is FormParameter)
+
+            let exception = file.rules[0].exceptions[0].parameter as! FormParameter
             XCTAssertEqual([], exception.forms)
             XCTAssertEqual(1, exception.documentProperties.count)
             XCTAssertEqual("Author", exception.documentProperties[0].field)
@@ -1571,7 +1597,7 @@ final class ImportExceptionTests: XCTestCase {
         }
         // String, doesNotContain
         do {
-            let file = try OutlookRulesFile(data: Data([
+            let file = try OutlookRules(data: Data([
                 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x14, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
@@ -1595,9 +1621,9 @@ final class ImportExceptionTests: XCTestCase {
             XCTAssertEqual(0, file.rules[0].actions.count)
             XCTAssertEqual(1, file.rules[0].exceptions.count)
             XCTAssertEqual(.withSelectedPropertiesOfDocumentOrFormsException, file.rules[0].exceptions[0].identifier)
-            XCTAssertTrue(file.rules[0].exceptions[0].data is WithSelectedPropertiesOfDocumentOrFormsRuleElementData)
-            
-            let exception = file.rules[0].exceptions[0].data as! WithSelectedPropertiesOfDocumentOrFormsRuleElementData
+            XCTAssertTrue(file.rules[0].exceptions[0].parameter is FormParameter)
+
+            let exception = file.rules[0].exceptions[0].parameter as! FormParameter
             XCTAssertEqual([], exception.forms)
             XCTAssertEqual(1, exception.documentProperties.count)
             XCTAssertEqual("Author", exception.documentProperties[0].field)
@@ -1613,7 +1639,7 @@ final class ImportExceptionTests: XCTestCase {
         }
         // Number, equals (positive)
         do {
-            let file = try OutlookRulesFile(data: Data([
+            let file = try OutlookRules(data: Data([
                 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x14, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
@@ -1636,9 +1662,9 @@ final class ImportExceptionTests: XCTestCase {
             XCTAssertEqual(0, file.rules[0].actions.count)
             XCTAssertEqual(1, file.rules[0].exceptions.count)
             XCTAssertEqual(.withSelectedPropertiesOfDocumentOrFormsException, file.rules[0].exceptions[0].identifier)
-            XCTAssertTrue(file.rules[0].exceptions[0].data is WithSelectedPropertiesOfDocumentOrFormsRuleElementData)
-            
-            let exception = file.rules[0].exceptions[0].data as! WithSelectedPropertiesOfDocumentOrFormsRuleElementData
+            XCTAssertTrue(file.rules[0].exceptions[0].parameter is FormParameter)
+
+            let exception = file.rules[0].exceptions[0].parameter as! FormParameter
             XCTAssertEqual([], exception.forms)
             XCTAssertEqual(1, exception.documentProperties.count)
             XCTAssertEqual("Bytes", exception.documentProperties[0].field)
@@ -1654,7 +1680,7 @@ final class ImportExceptionTests: XCTestCase {
         }
         // Number, equals (negative)
         do {
-            let file = try OutlookRulesFile(data: Data([
+            let file = try OutlookRules(data: Data([
                 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x14, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
@@ -1677,9 +1703,9 @@ final class ImportExceptionTests: XCTestCase {
             XCTAssertEqual(0, file.rules[0].actions.count)
             XCTAssertEqual(1, file.rules[0].exceptions.count)
             XCTAssertEqual(.withSelectedPropertiesOfDocumentOrFormsException, file.rules[0].exceptions[0].identifier)
-            XCTAssertTrue(file.rules[0].exceptions[0].data is WithSelectedPropertiesOfDocumentOrFormsRuleElementData)
-            
-            let exception = file.rules[0].exceptions[0].data as! WithSelectedPropertiesOfDocumentOrFormsRuleElementData
+            XCTAssertTrue(file.rules[0].exceptions[0].parameter is FormParameter)
+
+            let exception = file.rules[0].exceptions[0].parameter as! FormParameter
             XCTAssertEqual([], exception.forms)
             XCTAssertEqual(1, exception.documentProperties.count)
             XCTAssertEqual("Bytes", exception.documentProperties[0].field)
@@ -1695,7 +1721,7 @@ final class ImportExceptionTests: XCTestCase {
         }
         // Number, not equal to
         do {
-            let file = try OutlookRulesFile(data: Data([
+            let file = try OutlookRules(data: Data([
                 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x14, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
@@ -1718,9 +1744,9 @@ final class ImportExceptionTests: XCTestCase {
             XCTAssertEqual(0, file.rules[0].actions.count)
             XCTAssertEqual(1, file.rules[0].exceptions.count)
             XCTAssertEqual(.withSelectedPropertiesOfDocumentOrFormsException, file.rules[0].exceptions[0].identifier)
-            XCTAssertTrue(file.rules[0].exceptions[0].data is WithSelectedPropertiesOfDocumentOrFormsRuleElementData)
-            
-            let exception = file.rules[0].exceptions[0].data as! WithSelectedPropertiesOfDocumentOrFormsRuleElementData
+            XCTAssertTrue(file.rules[0].exceptions[0].parameter is FormParameter)
+
+            let exception = file.rules[0].exceptions[0].parameter as! FormParameter
             XCTAssertEqual([], exception.forms)
             XCTAssertEqual(1, exception.documentProperties.count)
             XCTAssertEqual("Bytes", exception.documentProperties[0].field)
@@ -1736,7 +1762,7 @@ final class ImportExceptionTests: XCTestCase {
         }
         // Number, is at most
         do {
-            let file = try OutlookRulesFile(data: Data([
+            let file = try OutlookRules(data: Data([
                 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x14, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
@@ -1759,9 +1785,9 @@ final class ImportExceptionTests: XCTestCase {
             XCTAssertEqual(0, file.rules[0].actions.count)
             XCTAssertEqual(1, file.rules[0].exceptions.count)
             XCTAssertEqual(.withSelectedPropertiesOfDocumentOrFormsException, file.rules[0].exceptions[0].identifier)
-            XCTAssertTrue(file.rules[0].exceptions[0].data is WithSelectedPropertiesOfDocumentOrFormsRuleElementData)
-            
-            let exception = file.rules[0].exceptions[0].data as! WithSelectedPropertiesOfDocumentOrFormsRuleElementData
+            XCTAssertTrue(file.rules[0].exceptions[0].parameter is FormParameter)
+
+            let exception = file.rules[0].exceptions[0].parameter as! FormParameter
             XCTAssertEqual([], exception.forms)
             XCTAssertEqual(1, exception.documentProperties.count)
             XCTAssertEqual("Bytes", exception.documentProperties[0].field)
@@ -1777,7 +1803,7 @@ final class ImportExceptionTests: XCTestCase {
         }
         // Number, is at least
         do {
-            let file = try OutlookRulesFile(data: Data([
+            let file = try OutlookRules(data: Data([
                 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x14, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
@@ -1800,9 +1826,9 @@ final class ImportExceptionTests: XCTestCase {
             XCTAssertEqual(0, file.rules[0].actions.count)
             XCTAssertEqual(1, file.rules[0].exceptions.count)
             XCTAssertEqual(.withSelectedPropertiesOfDocumentOrFormsException, file.rules[0].exceptions[0].identifier)
-            XCTAssertTrue(file.rules[0].exceptions[0].data is WithSelectedPropertiesOfDocumentOrFormsRuleElementData)
-            
-            let exception = file.rules[0].exceptions[0].data as! WithSelectedPropertiesOfDocumentOrFormsRuleElementData
+            XCTAssertTrue(file.rules[0].exceptions[0].parameter is FormParameter)
+
+            let exception = file.rules[0].exceptions[0].parameter as! FormParameter
             XCTAssertEqual([], exception.forms)
             XCTAssertEqual(1, exception.documentProperties.count)
             XCTAssertEqual("Bytes", exception.documentProperties[0].field)
@@ -1818,7 +1844,7 @@ final class ImportExceptionTests: XCTestCase {
         }
         // Number, is more than
         do {
-            let file = try OutlookRulesFile(data: Data([
+            let file = try OutlookRules(data: Data([
                 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x14, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
@@ -1841,9 +1867,9 @@ final class ImportExceptionTests: XCTestCase {
             XCTAssertEqual(0, file.rules[0].actions.count)
             XCTAssertEqual(1, file.rules[0].exceptions.count)
             XCTAssertEqual(.withSelectedPropertiesOfDocumentOrFormsException, file.rules[0].exceptions[0].identifier)
-            XCTAssertTrue(file.rules[0].exceptions[0].data is WithSelectedPropertiesOfDocumentOrFormsRuleElementData)
-            
-            let exception = file.rules[0].exceptions[0].data as! WithSelectedPropertiesOfDocumentOrFormsRuleElementData
+            XCTAssertTrue(file.rules[0].exceptions[0].parameter is FormParameter)
+
+            let exception = file.rules[0].exceptions[0].parameter as! FormParameter
             XCTAssertEqual([], exception.forms)
             XCTAssertEqual(1, exception.documentProperties.count)
             XCTAssertEqual("Bytes", exception.documentProperties[0].field)
@@ -1859,7 +1885,7 @@ final class ImportExceptionTests: XCTestCase {
         }
         // Number, is less than
         do {
-            let file = try OutlookRulesFile(data: Data([
+            let file = try OutlookRules(data: Data([
                 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x14, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
@@ -1882,9 +1908,9 @@ final class ImportExceptionTests: XCTestCase {
             XCTAssertEqual(0, file.rules[0].actions.count)
             XCTAssertEqual(1, file.rules[0].exceptions.count)
             XCTAssertEqual(.withSelectedPropertiesOfDocumentOrFormsException, file.rules[0].exceptions[0].identifier)
-            XCTAssertTrue(file.rules[0].exceptions[0].data is WithSelectedPropertiesOfDocumentOrFormsRuleElementData)
-            
-            let exception = file.rules[0].exceptions[0].data as! WithSelectedPropertiesOfDocumentOrFormsRuleElementData
+            XCTAssertTrue(file.rules[0].exceptions[0].parameter is FormParameter)
+
+            let exception = file.rules[0].exceptions[0].parameter as! FormParameter
             XCTAssertEqual([], exception.forms)
             XCTAssertEqual(1, exception.documentProperties.count)
             XCTAssertEqual("Bytes", exception.documentProperties[0].field)
@@ -1903,7 +1929,7 @@ final class ImportExceptionTests: XCTestCase {
         calendar.timeZone = timeZone
         // Date, before
         do {
-            let file = try OutlookRulesFile(data: Data([
+            let file = try OutlookRules(data: Data([
                 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x14, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
@@ -1927,9 +1953,9 @@ final class ImportExceptionTests: XCTestCase {
             XCTAssertEqual(0, file.rules[0].actions.count)
             XCTAssertEqual(1, file.rules[0].exceptions.count)
             XCTAssertEqual(.withSelectedPropertiesOfDocumentOrFormsException, file.rules[0].exceptions[0].identifier)
-            XCTAssertTrue(file.rules[0].exceptions[0].data is WithSelectedPropertiesOfDocumentOrFormsRuleElementData)
-            
-            let exception = file.rules[0].exceptions[0].data as! WithSelectedPropertiesOfDocumentOrFormsRuleElementData
+            XCTAssertTrue(file.rules[0].exceptions[0].parameter is FormParameter)
+
+            let exception = file.rules[0].exceptions[0].parameter as! FormParameter
             XCTAssertEqual([], exception.forms)
             XCTAssertEqual(1, exception.documentProperties.count)
             XCTAssertEqual("Creation Time", exception.documentProperties[0].field)
@@ -1946,7 +1972,7 @@ final class ImportExceptionTests: XCTestCase {
         }
         // Date, after
         do {
-            let file = try OutlookRulesFile(data: Data([
+            let file = try OutlookRules(data: Data([
                 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x14, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
@@ -1970,9 +1996,9 @@ final class ImportExceptionTests: XCTestCase {
             XCTAssertEqual(0, file.rules[0].actions.count)
             XCTAssertEqual(1, file.rules[0].exceptions.count)
             XCTAssertEqual(.withSelectedPropertiesOfDocumentOrFormsException, file.rules[0].exceptions[0].identifier)
-            XCTAssertTrue(file.rules[0].exceptions[0].data is WithSelectedPropertiesOfDocumentOrFormsRuleElementData)
-            
-            let exception = file.rules[0].exceptions[0].data as! WithSelectedPropertiesOfDocumentOrFormsRuleElementData
+            XCTAssertTrue(file.rules[0].exceptions[0].parameter is FormParameter)
+
+            let exception = file.rules[0].exceptions[0].parameter as! FormParameter
             XCTAssertEqual([], exception.forms)
             XCTAssertEqual(1, exception.documentProperties.count)
             XCTAssertEqual("Creation Time", exception.documentProperties[0].field)
@@ -1989,7 +2015,7 @@ final class ImportExceptionTests: XCTestCase {
         }
         // Multiple
         do {
-            let file = try OutlookRulesFile(data: Data([
+            let file = try OutlookRules(data: Data([
                 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x14, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
@@ -2025,9 +2051,9 @@ final class ImportExceptionTests: XCTestCase {
             XCTAssertEqual(0, file.rules[0].actions.count)
             XCTAssertEqual(1, file.rules[0].exceptions.count)
             XCTAssertEqual(.withSelectedPropertiesOfDocumentOrFormsException, file.rules[0].exceptions[0].identifier)
-            XCTAssertTrue(file.rules[0].exceptions[0].data is WithSelectedPropertiesOfDocumentOrFormsRuleElementData)
-            
-            let exception = file.rules[0].exceptions[0].data as! WithSelectedPropertiesOfDocumentOrFormsRuleElementData
+            XCTAssertTrue(file.rules[0].exceptions[0].parameter is FormParameter)
+
+            let exception = file.rules[0].exceptions[0].parameter as! FormParameter
             XCTAssertEqual(["Accept Meeting Response", " Text Message", " Task"], exception.forms)
             XCTAssertEqual(2, exception.documentProperties.count)
             XCTAssertEqual("Bytes", exception.documentProperties[0].field)
@@ -2054,7 +2080,7 @@ final class ImportExceptionTests: XCTestCase {
 
     func testSenderInSpecifiedAddressBookException() throws {
         do {
-            let file = try OutlookRulesFile(data: Data([
+            let file = try OutlookRules(data: Data([
                 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x14, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
@@ -2086,20 +2112,20 @@ final class ImportExceptionTests: XCTestCase {
             XCTAssertEqual(1, file.rules.count)
             XCTAssertEqual(1, file.rules[0].conditions.count)
             XCTAssertEqual(.onThisComputerOnlyCondition, file.rules[0].conditions[0].identifier)
-            XCTAssertTrue(file.rules[0].conditions[0].data is OnThisComputerOnlyRuleElementData)
+            XCTAssertTrue(file.rules[0].conditions[0].parameter is ProfileStampParameter)
             XCTAssertEqual(0, file.rules[0].actions.count)
             XCTAssertEqual(1, file.rules[0].exceptions.count)
             XCTAssertEqual(.senderInSpecifiedAddressBookException, file.rules[0].exceptions[0].identifier)
-            XCTAssertTrue(file.rules[0].exceptions[0].data is SenderInSpecifiedAddressBookRuleElementData)
-            
-            let exception = file.rules[0].exceptions[0].data as! SenderInSpecifiedAddressBookRuleElementData
+            XCTAssertTrue(file.rules[0].exceptions[0].parameter is AddressBookParameter)
+
+            let exception = file.rules[0].exceptions[0].parameter as! AddressBookParameter
             XCTAssertEqual("Contacts (This computer only)", exception.name)
         }
     }
 
     func testWhichIsMeetingInvitationOrUpdateException() throws {
         do {
-            let file = try OutlookRulesFile(data: Data([
+            let file = try OutlookRules(data: Data([
                 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x14, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
@@ -2115,7 +2141,7 @@ final class ImportExceptionTests: XCTestCase {
             XCTAssertEqual(1, file.rules.count)
             XCTAssertEqual(0, file.rules[0].conditions.count)
             XCTAssertEqual(.whichIsAMeetingInvitationOrInviteException, file.rules[0].exceptions[0].identifier)
-            XCTAssertTrue(file.rules[0].exceptions[0].data is SimpleRuleElementData)
+            XCTAssertEqual(0, file.rules[0].exceptions[0].parameters.count)
             XCTAssertEqual(0, file.rules[0].actions.count)
             XCTAssertEqual(1, file.rules[0].exceptions.count)
         }
@@ -2123,7 +2149,7 @@ final class ImportExceptionTests: XCTestCase {
 
     func testFromRSSFeedsWithSpecifiedTextInTitleException() throws {
         do {
-            let file = try OutlookRulesFile(data: Data([
+            let file = try OutlookRules(data: Data([
                 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x14, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
@@ -2145,13 +2171,13 @@ final class ImportExceptionTests: XCTestCase {
             XCTAssertEqual(0, file.rules[0].actions.count)
             XCTAssertEqual(1, file.rules[0].exceptions.count)
             XCTAssertEqual(.fromRSSFeedsWithSpecifiedTextInTitleException, file.rules[0].exceptions[0].identifier)
-            XCTAssertTrue(file.rules[0].exceptions[0].data is StringsListRuleElementData)
-            
-            let exception = file.rules[0].exceptions[0].data as! StringsListRuleElementData
-            XCTAssertEqual(["ISS On-Orbit Status Report"], exception.entries)
+            XCTAssertTrue(file.rules[0].exceptions[0].parameter is StringParameter)
+
+            let exception = file.rules[0].exceptions[0].parameter as! StringParameter
+            XCTAssertEqual("ISS On-Orbit Status Report", exception.value)
         }
         do {
-            let file = try OutlookRulesFile(data: Data([
+            let file = try OutlookRules(data: Data([
                 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x14, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
@@ -2176,16 +2202,20 @@ final class ImportExceptionTests: XCTestCase {
             XCTAssertEqual(0, file.rules[0].actions.count)
             XCTAssertEqual(1, file.rules[0].exceptions.count)
             XCTAssertEqual(.fromRSSFeedsWithSpecifiedTextInTitleException, file.rules[0].exceptions[0].identifier)
-            XCTAssertTrue(file.rules[0].exceptions[0].data is StringsListRuleElementData)
-            
-            let exception = file.rules[0].exceptions[0].data as! StringsListRuleElementData
-            XCTAssertEqual(["ISS On-Orbit Status Report", "NASA Breaking News"], exception.entries)
+            XCTAssertEqual(2, file.rules[0].exceptions[0].parameters.count)
+            XCTAssertTrue(file.rules[0].exceptions[0].parameters[0] is StringParameter)
+            XCTAssertTrue(file.rules[0].exceptions[0].parameters[1] is StringParameter)
+
+            let exception1 = file.rules[0].exceptions[0].parameters[0] as! StringParameter
+            XCTAssertEqual("ISS On-Orbit Status Report", exception1.value)
+            let exception2 = file.rules[0].exceptions[0].parameters[1] as! StringParameter
+            XCTAssertEqual("NASA Breaking News", exception2.value)
         }
     }
 
     func testFromAnyRSSFeedException() throws {
         do {
-            let file = try OutlookRulesFile(data: Data([
+            let file = try OutlookRules(data: Data([
                 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x14, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
@@ -2203,13 +2233,13 @@ final class ImportExceptionTests: XCTestCase {
             XCTAssertEqual(0, file.rules[0].actions.count)
             XCTAssertEqual(1, file.rules[0].exceptions.count)
             XCTAssertEqual(.fromAnyRSSFeedException, file.rules[0].exceptions[0].identifier)
-            XCTAssertTrue(file.rules[0].exceptions[0].data is SimpleRuleElementData)
+            XCTAssertEqual(0, file.rules[0].exceptions[0].parameters.count)
         }
     }
-    
+
     func testSpecificInfoPathFormException() throws {
         do {
-            let file = try OutlookRulesFile(data: Data([
+            let file = try OutlookRules(data: Data([
                 0x80, 0x4f, 0x12, 0x00, 0x80, 0x4f, 0x12, 0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x80, 0x4f,
@@ -2232,18 +2262,18 @@ final class ImportExceptionTests: XCTestCase {
             XCTAssertEqual(0, file.rules[0].actions.count)
             XCTAssertEqual(1, file.rules[0].exceptions.count)
             XCTAssertEqual(.specificInfoPathFormException, file.rules[0].exceptions[0].identifier)
-            XCTAssertTrue(file.rules[0].exceptions[0].data is FormTypeRuleElementData)
-            
-            let condition = file.rules[0].exceptions[0].data as! FormTypeRuleElementData
-            XCTAssertEqual(1, condition.numberOfForms)
-            XCTAssertEqual("Template3", condition.forms[0].name)
-            XCTAssertEqual("IPM.InfoPathForm.25bcd4d0a0953612$759f7503f0746cc1", condition.forms[0].className)
+            XCTAssertEqual(1, file.rules[0].exceptions[0].parameters.count)
+            XCTAssertTrue(file.rules[0].exceptions[0].parameter is FormTypeParameter)
+
+            let condition = file.rules[0].exceptions[0].parameter as! FormTypeParameter
+            XCTAssertEqual("Template3", condition.name)
+            XCTAssertEqual("IPM.InfoPathForm.25bcd4d0a0953612$759f7503f0746cc1", condition.className)
         }
     }
 
     func testMultipleExceptions() throws {
         do {
-            let file = try OutlookRulesFile(data: Data([
+            let file = try OutlookRules(data: Data([
                 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x14, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
@@ -2269,9 +2299,9 @@ final class ImportExceptionTests: XCTestCase {
             XCTAssertEqual(0, file.rules[0].actions.count)
             XCTAssertEqual(2, file.rules[0].exceptions.count)
             XCTAssertEqual(.nameInToBoxException, file.rules[0].exceptions[0].identifier)
-            XCTAssertTrue(file.rules[0].exceptions[0].data is SimpleRuleElementData)
+            XCTAssertEqual(0, file.rules[0].exceptions[0].parameters.count)
             XCTAssertEqual(.sentOnlyToMeException, file.rules[0].exceptions[1].identifier)
-            XCTAssertTrue(file.rules[0].exceptions[1].data is SimpleRuleElementData)
+            XCTAssertEqual(0, file.rules[0].exceptions[1].parameters.count)
         }
     }
 
diff --git a/Tests/OutlookRulesReaderTests/Import/ImportTests.swift b/Tests/OutlookRulesReaderTests/Import/ImportTests.swift
index 30b50f2..3aa8795 100644
--- a/Tests/OutlookRulesReaderTests/Import/ImportTests.swift
+++ b/Tests/OutlookRulesReaderTests/Import/ImportTests.swift
@@ -3,7 +3,7 @@ import XCTest
 
 final class ImportTests: XCTestCase {
     func testEmptyRule() throws {
-        let file = try OutlookRulesFile(data: Data([
+        let file = try OutlookRules(data: Data([
             0x80, 0x4f, 0x12, 0x00, 0x80, 0x4f, 0x12, 0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
             0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
             0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x80, 0x4f,
@@ -21,9 +21,9 @@ final class ImportTests: XCTestCase {
         XCTAssertEqual(0, file.rules[0].actions.count)
     }
     
-    func testApplyCondition() throws {
+    func testeventFlags() throws {
         do {
-            let file = try OutlookRulesFile(data: Data([
+            let file = try OutlookRules(data: Data([
                 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x14, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
@@ -43,10 +43,10 @@ final class ImportTests: XCTestCase {
                 0x00, 0x31, 0x00, 0x30, 0x00, 0x33, 0x00, 0x33, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
             ]))
-            XCTAssertEqual(.afterReceived, file.rules[0].applyCondition)
+            XCTAssertEqual(.afterReceived, file.rules[0].eventFlags)
         }
         do {
-            let file = try OutlookRulesFile(data: Data([
+            let file = try OutlookRules(data: Data([
                 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x14, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
@@ -66,13 +66,13 @@ final class ImportTests: XCTestCase {
                 0x00, 0x31, 0x00, 0x30, 0x00, 0x33, 0x00, 0x33, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
             ]))
-            XCTAssertEqual(.afterSent, file.rules[0].applyCondition)
+            XCTAssertEqual(.afterSent, file.rules[0].eventFlags)
         }
     }
     
     func testName() {
         do {
-            XCTAssertEqual("RULENAME", try OutlookRulesFile(data: Data([
+            XCTAssertEqual("RULENAME", try OutlookRules(data: Data([
                 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x14, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
@@ -88,7 +88,7 @@ final class ImportTests: XCTestCase {
             ])).rules[0].name)
         }
         do {
-            XCTAssertEqual("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", try OutlookRulesFile(data: Data([
+            XCTAssertEqual("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", try OutlookRules(data: Data([
                 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x14, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
@@ -138,7 +138,7 @@ final class ImportTests: XCTestCase {
     
     func testEnabled() {
         do {
-            XCTAssertFalse(try OutlookRulesFile(data: Data([
+            XCTAssertFalse(try OutlookRules(data: Data([
                 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x14, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
@@ -154,7 +154,7 @@ final class ImportTests: XCTestCase {
             ])).rules[0].enabled)
         }
         do {
-            XCTAssertTrue(try OutlookRulesFile(data: Data([
+            XCTAssertTrue(try OutlookRules(data: Data([
                 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x14, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
@@ -173,7 +173,7 @@ final class ImportTests: XCTestCase {
     
     func testMultipleRules() throws {
         do {
-            let file = try OutlookRulesFile(data: Data([
+            let file = try OutlookRules(data: Data([
                 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x14, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00,
@@ -199,7 +199,7 @@ final class ImportTests: XCTestCase {
     
     func testTemplateDirectory() throws {
         do {
-            let file = try OutlookRulesFile(data: Data([
+            let file = try OutlookRules(data: Data([
                 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x14, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
@@ -215,7 +215,7 @@ final class ImportTests: XCTestCase {
             XCTAssertEqual("", file.templateDirectory)
         }
         do {
-            let file = try OutlookRulesFile(data: Data([
+            let file = try OutlookRules(data: Data([
                 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x14, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
@@ -242,7 +242,7 @@ final class ImportTests: XCTestCase {
     
     func testOutlook2007() throws {
         do {
-            let file = try OutlookRulesFile(data: Data([
+            let file = try OutlookRules(data: Data([
                 0x80, 0x4F, 0x12, 0x00, 0x00, 0x00, 0x14, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x80, 0x4F,
@@ -262,7 +262,7 @@ final class ImportTests: XCTestCase {
 
     func testOutlook2000() throws {
         do {
-            let file = try OutlookRulesFile(data: Data([
+            let file = try OutlookRules(data: Data([
                 0xBD, 0xF5, 0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
                 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x08, 0x52, 0x55, 0x4C, 0x45, 0x4E, 0x41, 0x4D, 0x45, 0x00,
diff --git a/docs/RWZ Format.docx b/docs/RWZ Format.docx
index 3ea1e11..cd19419 100644
Binary files a/docs/RWZ Format.docx and b/docs/RWZ Format.docx differ
diff --git a/docs/Rules Sever Side.xlsx b/docs/Rules Sever Side.xlsx
new file mode 100644
index 0000000..4021f37
Binary files /dev/null and b/docs/Rules Sever Side.xlsx differ
diff --git a/spec/Rules.md b/spec/Rules.md
new file mode 100644
index 0000000..4ce7b8c
--- /dev/null
+++ b/spec/Rules.md
@@ -0,0 +1,97 @@
+# Outlook Rules
+
+An Outlook Rule is a set of actions that Outlook performs automatically when certain conditions are met. For example, you can use rules to move, flag, and respond to email messages automatically. You can also use rules to play sounds, move messages to folders, or display new item alerts<sup>1</sup>.
+
+Outlook Rules began as an add-in to Outlook 97<sup>2</sup>  called `RulesWiz.dll `and were integrated in-box automatically in Outlook 98<sup>3</sup>.
+
+## Storage
+Outlook stores Rules Wizard Files differently depending on the version of Outlook<sup>4</sup>.
+
+Outlook allows users to import and export Rules to a rules file with the file extension .rwz . The resulting file is known as a Rules Wizard File (shorted to RWZ file). Users can specify backwards compatibility to the latest version of Outlook, Outlook 2002, Outlook 2000 and Outlook 98. 
+![Rules Export](assets/RulesExport.png)
+
+### Outlook 2002 and Later
+User-created rules and alerts are stored in an account's PST<sup>5</sup>.
+
+The rules stream is located in the `PR_RW_RULES_STREAM/PidTagRwRulesStream (0x68020102)`  property of a message named `Outlook Rules Organizer` of class `IPM.RuleOrganizer`<sup>6</sup> inside the Associated Contents Table<sup>7</sup> of the Inbox folder
+![Rules Stream](assets/RulesStream.png)
+
+### Outlook 2000 and Earlier.
+
+User-created rules and alerts are stored in the file system.
+
+The rules stream is located in the `C:\Documents and Settings\<username>\Application Data\Microsoft\Outlook\<ProfileName>.rwz` file.
+
+### Additional Notes
+
+The format of `.rwz` files and the corresponding `PidTagRwRulesStream` property is client-specific and opaque to the server<sup>8</sup>.  Some values within the header are, for example, different between the stream contained in `PidTagRwRulesStream` and the corresponding `.rwz` exported files. However, this document refers to `.rwz` files and the binary value of the `PidTagRwRulesStream` property interchangeably as, by-and-large, they have the same format.
+
+# Introduction
+The Outlook Rules (.rwz) File Format is used to store exported Outlook rules.
+
+A rules file is a series of variable-length records, called Rules which contain variable-length records. Rules are a series of variable-length records called Rule Elements which contain conditions, actions and exceptions. 
+
+## Glossary
+This document uses the following terms:
+
+**ASCII**: The American Standard Code for Information Interchange (ASCII) is an 8-bit character-encoding scheme based on the English alphabet. ASCII codes represent text in computers, communications equipment, and other devices that work with text. ASCII refers to a single 8-bit ASCII character or an array of 8-bit ASCII characters with the high bit of each character set to zero.
+
+**big-endian**: Multiple-byte values that are byte-ordered with the most significant byte stored in the
+memory location with the lowest address.
+
+**globally unique identifier (GUID)**: A term used interchangeably with universally unique
+identifier (UUID) in Microsoft protocol technical documents (TDs). Interchanging the usage of these terms does not imply or require a specific algorithm or mechanism to generate the value.
+Specifically, the use of this term does not imply or require that the algorithms described in
+[RFC4122] or [C706] must be used for generating the GUID. See also universally unique identifier (UUID).
+
+**little-endian**: Multiple-byte values that are byte-ordered with the least significant byte stored in the memory location with the lowest address.
+
+**timestamp**: A variant time is stored as an 8-byte real value (double), representing a date between January 1, 100 and December 31, 9999, inclusive. The value 2.0 represents January 1, 1900; 3.0 represents January 2, 1900, and so on. Adding 1 to the value increments the date by a day. The fractional part of the value represents the time of day. Therefore, 2.5 represents noon on January 1, 1900; 3.25 represents 6:00 A.M. on January 2, 1900, and so on. Negative numbers represent dates prior to December 30, 1899. The variant time resolves to one second. Any milliseconds in the input date are ignored.
+
+**UTF-16**: A standard for encoding Unicode characters, defined in the Unicode standard, in which the most commonly used characters are defined as double-byte characters. Unless specified otherwise, this term refers to the UTF-16 encoding form specified in [UNICODE5.0.0/2007] section 3.9.
+
+**MAY, SHOULD, MUST, SHOULD NOT, MUST NOT**: These terms (in all caps) are used as defined in [RFC2119]. All statements of optional behavior use either MAY, SHOULD, or SHOULD NOT.
+
+## References
+### Normative References
+[MS-DTYP] Microsoft Corporation, ["Windows Data Types"](https://docs.microsoft.com/en-us/openspecs/windows_protocols/ms-dtyp).
+
+[MS-OXCDATA] Microsoft Corporation, ["Data Structures"](https://docs.microsoft.com/en-us/openspecs/exchange_server_protocols/ms-oxcdata/).
+
+[MS-OXCMSG] Microsoft Corporation, ["Message and Attachment Object Protocol"](https://docs.microsoft.com/en-us/openspecs/exchange_server_protocols/ms-oxcmsg/).
+
+[RFC2119] Bradner, S., “Key words for use in RFCs to Indicate Requirement Levels”, BCP 14, RFC 2119, March 1997, [http://www.rfc-editor.org/rfc/rfc2119.txt](http://www.rfc-editor.org/rfc/rfc2119.txt) 
+
+[UNICODE5.0.0] The Unicode Consortium, “Unicode Default Case Conversion Algorithm 5.0.0”, March 2006, [http://www.unicode.org/Public/5.0.0/ucd/CaseFolding.txt](http://www.unicode.org/Public/5.0.0/ucd/CaseFolding.txt)
+
+## Overview
+
+### Rules Structure
+A rules file stores a list of rules into a single file or memory buffer. A rule consists of a list of conditions, actions and exceptions that are defined in this specification.
+![Rule Structure](assets/RulesStructure.png)
+**Figure 1: rules files**
+
+### Byte Ordering
+Data in the rules stream are stored in little-endian format.
+
+Some computer architectures number bytes in a binary word from left to right, which is referred to as big-endian. The byte numbering used for bitfields in this specification is big-endian. Other
+architectures number the bytes in a binary word from right to left, which is referred to as little-endian.
+
+The byte numbering used for enumerations, objects, and records in this specification is little-endian.
+
+Using the big-endian and little-endian methods, the number 0x12345678 would be stored as shown in the following table.
+
+| Byte order    | Byte 0 | Byte 1 | Byte 2 | Byte 3 |
+|---------------|--------|--------|--------|--------|
+| Big-endian    | 0x12   | 0x34   | 0x56   | 0x78   |
+| Little-endian | 0x78   | 0x56   | 0x34   | 0x12   |
+
+# References
+- [1] https://support.microsoft.com/en-us/office/manage-email-messages-by-using-rules-c24f5dea-9465-4df4-ad17-a50704d66c59
+- [2] https://www.computerhope.com/download/updates.htm
+- [3] https://www.slipstick.com/outlook/rules/rules-wizard/ 
+- [4] https://www.itprotoday.com/email-and-calendaring/how-do-you-delete-and-recreate-corrupt-outlook-rules
+- [5] https://docs.microsoft.com/en-us/openspecs/exchange_server_protocols/ms-oxprops/f1fbd19a-9b2c-4c16-a07b-2242b2c0dece
+- [6] https://docs.microsoft.com/en-us/openspecs/exchange_server_protocols/ms-oxorule/950a82ff-acde-40b3-8f2f-fc46ceb7a182
+- [7] https://docs.microsoft.com/en-us/office/client-developer/outlook/mapi/contents-tables
+- [8] https://docs.microsoft.com/en-us/openspecs/exchange_server_protocols/ms-oxorule/ee0fd52b-1161-49b8-adab-6b8c2e31c3f3
diff --git a/spec/assets/RulesExport.png b/spec/assets/RulesExport.png
new file mode 100644
index 0000000..90b6201
Binary files /dev/null and b/spec/assets/RulesExport.png differ
diff --git a/spec/assets/RulesStream.png b/spec/assets/RulesStream.png
new file mode 100644
index 0000000..0d6fae1
Binary files /dev/null and b/spec/assets/RulesStream.png differ
diff --git a/spec/assets/RulesStructure.png b/spec/assets/RulesStructure.png
new file mode 100644
index 0000000..b97b620
Binary files /dev/null and b/spec/assets/RulesStructure.png differ