diff --git a/Engine/Commands/InvokeScriptAnalyzerCommand.cs b/Engine/Commands/InvokeScriptAnalyzerCommand.cs
index e7c800f54..ffe3d1387 100644
--- a/Engine/Commands/InvokeScriptAnalyzerCommand.cs
+++ b/Engine/Commands/InvokeScriptAnalyzerCommand.cs
@@ -8,6 +8,7 @@
 using System.Collections.ObjectModel;
 using System.Diagnostics.CodeAnalysis;
 using System.Globalization;
+using System.IO;
 using System.Linq;
 using System.Management.Automation;
 using System.Management.Automation.Runspaces;
diff --git a/Engine/Settings.cs b/Engine/Settings.cs
index 506733cc2..000bd9a35 100644
--- a/Engine/Settings.cs
+++ b/Engine/Settings.cs
@@ -52,13 +52,13 @@ public Settings(object settings, Func<string, string> presetResolver)
                 throw new ArgumentNullException(nameof(settings));
             }
 
-            includeRules = new List<string>();
-            excludeRules = new List<string>();
-            severities = new List<string>();
-            ruleArguments = new Dictionary<string, Dictionary<string, object>>(StringComparer.OrdinalIgnoreCase);
-            var settingsFilePath = settings as string;
+            this.includeRules = new List<string>();
+            this.excludeRules = new List<string>();
+            this.severities = new List<string>();
+            this.ruleArguments = new Dictionary<string, Dictionary<string, object>>(StringComparer.OrdinalIgnoreCase);
 
-            //it can either be a preset or path to a file or a hashtable
+            // If `settings` is a string, then preprocess it by (1) resolving it to a file path, and (2) parsing the file to a Hashtable.
+            var settingsFilePath = settings as string;
             if (settingsFilePath != null)
             {
                 if (presetResolver != null)
@@ -68,34 +68,33 @@ public Settings(object settings, Func<string, string> presetResolver)
                     {
                         settingsFilePath = resolvedFilePath;
                     }
+                    // Do not throw an exception if `presetResolver` fails to resolve `settingsFilePath`. Rather, attempt to handle the issue
+                    // ourselves by acting simply as if no `presetResolver` was passed in the first place.
                 }
+                // Do not throw an exception if the `presetResolver` argument is null. This is because it is permitted for a file path `settings` to
+                // not have any associated `presetResolver`.
 
-                if (File.Exists(settingsFilePath))
+                if (!File.Exists(settingsFilePath))
                 {
-                    filePath = settingsFilePath;
-                    parseSettingsFile(settingsFilePath);
-                }
-                else
-                {
-                    throw new ArgumentException(
-                        String.Format(
-                            CultureInfo.CurrentCulture,
-                            Strings.InvalidPath,
-                            settingsFilePath));
+                    throw new ArgumentException(String.Format(
+                        Strings.InvalidPath,
+                        settingsFilePath));
                 }
+
+                this.filePath = settingsFilePath;
+                settings = ParseSettingsFileToHashtable(settingsFilePath);
             }
-            else
+
+            // Do the real work of parsing the `settings` Hashtable (whether passed directly or first parsed from a resolved file path).
+            var settingsHashtable = settings as Hashtable;
+            if (settingsHashtable != null)
             {
-                var settingsHashtable = settings as Hashtable;
-                if (settingsHashtable != null)
-                {
-                    parseSettingsHashtable(settingsHashtable);
-                }
-                else
-                {
-                    throw new ArgumentException(Strings.SettingsInvalidType);
-                }
+                ParseSettingsHashtable(settingsHashtable);
+                return;
             }
+
+            // The `settings` argument must be either a string or a Hashtable.
+            throw new ArgumentException(Strings.SettingsInvalidType);
         }
 
         /// <summary>
@@ -241,50 +240,6 @@ internal static Settings Create(object settingsObj, string cwd, IOutputWriter ou
             return new Settings(settingsFound);
         }
 
-        /// <summary>
-        /// Recursively convert hashtable to dictionary
-        /// </summary>
-        /// <param name="hashtable"></param>
-        /// <returns>Dictionary that maps string to object</returns>
-        private Dictionary<string, object> GetDictionaryFromHashtable(Hashtable hashtable)
-        {
-            var dictionary = new Dictionary<string, object>(StringComparer.OrdinalIgnoreCase);
-            foreach (var obj in hashtable.Keys)
-            {
-                string key = obj as string;
-                if (key == null)
-                {
-                    throw new InvalidDataException(
-                        string.Format(
-                            CultureInfo.CurrentCulture,
-                            Strings.KeyNotString,
-                            key));
-                }
-
-                var valueHashtableObj = hashtable[obj];
-                if (valueHashtableObj == null)
-                {
-                    throw new InvalidDataException(
-                        string.Format(
-                            CultureInfo.CurrentCulture,
-                            Strings.WrongValueHashTable,
-                            "",
-                            key));
-                }
-
-                var valueHashtable = valueHashtableObj as Hashtable;
-                if (valueHashtable == null)
-                {
-                    dictionary.Add(key, valueHashtableObj);
-                }
-                else
-                {
-                    dictionary.Add(key, GetDictionaryFromHashtable(valueHashtable));
-                }
-            }
-            return dictionary;
-        }
-
         private bool IsStringOrStringArray(object val)
         {
             if (val is string)
@@ -296,167 +251,309 @@ private bool IsStringOrStringArray(object val)
             return val == null ? false : valArr.All(x => x is string);
         }
 
-        private List<string> GetData(object val, string key)
+        private List<string> ParseSettingValueStringOrStrings(object value, string settingName, IList<Exception> exceptions)
         {
-            // value must be either string or or an array of strings
-            if (val == null)
+            if (value == null)
             {
-                throw new InvalidDataException(
-                    string.Format(
-                        CultureInfo.CurrentCulture,
-                        Strings.WrongValueHashTable,
-                        "",
-                        key));
+                exceptions.Add(new InvalidDataException(string.Format(
+                    Strings.SettingValueIsNull,
+                    settingName)));
+                return null;
             }
 
-            List<string> values = new List<string>();
-            var valueStr = val as string;
-            if (valueStr != null)
+            if (value is string)
             {
-                values.Add(valueStr);
+                value = new[] { value };
             }
-            else
+
+            if (!(value is ICollection))
             {
-                var valueArr = val as object[];
-                if (valueArr == null)
-                {
-                    // check if it is an array of strings
-                    valueArr = val as string[];
-                }
+                exceptions.Add(new InvalidDataException(string.Format(
+                    Strings.SettingValueIsNotStringOrStringsType,
+                    settingName)));
+                return null;
+            }
+            var values = value as ICollection;
 
-                if (valueArr != null)
+            var strings = new List<string>(values.Count);
+            int elementIndex = 0;
+            int currentElementIndex = elementIndex;
+            foreach (var element in values)
+            {
+                currentElementIndex = elementIndex++;
+
+                if (element is null)
                 {
-                    foreach (var item in valueArr)
-                    {
-                        var itemStr = item as string;
-                        if (itemStr != null)
-                        {
-                            values.Add(itemStr);
-                        }
-                        else
-                        {
-                            throw new InvalidDataException(
-                                string.Format(
-                                    CultureInfo.CurrentCulture,
-                                    Strings.WrongValueHashTable,
-                                    val,
-                                    key));
-                        }
-                    }
+                    exceptions.Add(new InvalidDataException(string.Format(
+                        Strings.SettingValueElementIsNull,
+                        settingName,
+                        currentElementIndex)));
+                    continue;
                 }
-                else
+
+                if (!(element is string))
                 {
-                    throw new InvalidDataException(
-                            string.Format(
-                                CultureInfo.CurrentCulture,
-                                Strings.WrongValueHashTable,
-                                val,
-                                key));
+                    exceptions.Add(new InvalidDataException(string.Format(
+                        Strings.SettingValueElementIsNotStringType,
+                        settingName,
+                        currentElementIndex,
+                        element)));
+                    continue;
                 }
+
+                strings.Add(element as string);
             }
 
-            return values;
+            return strings;
         }
 
-        /// <summary>
-        /// Sets the arguments for consumption by rules
-        /// </summary>
-        /// <param name="ruleArgs">A hashtable with rule names as keys</param>
-        private Dictionary<string, Dictionary<string, object>> ConvertToRuleArgumentType(object ruleArguments)
+        private bool? ParseSettingValueBoolean(object value, string settingName, IList<Exception> exceptions)
         {
-            var ruleArgs = ruleArguments as Dictionary<string, object>;
-            if (ruleArgs == null)
+            if (value == null)
             {
-                throw new ArgumentException(Strings.SettingsInputShouldBeDictionary, nameof(ruleArguments));
+                exceptions.Add(new InvalidDataException(string.Format(
+                    Strings.SettingValueIsNull,
+                    settingName)));
+                return null;
             }
 
-            if (ruleArgs.Comparer != StringComparer.OrdinalIgnoreCase)
+            if (!(value is bool))
             {
-                throw new ArgumentException(Strings.SettingsDictionaryShouldBeCaseInsesitive, nameof(ruleArguments));
+                exceptions.Add(new InvalidDataException(string.Format(
+                    Strings.SettingValueIsNotBooleanType,
+                    settingName,
+                    value)));
+                return null;
             }
 
-            var ruleArgsDict = new Dictionary<string, Dictionary<string, object>>(StringComparer.OrdinalIgnoreCase);
-            foreach (var rule in ruleArgs.Keys)
+            return (bool) value;
+        }
+
+        private void ParseSettingsHashtable(Hashtable settings)
+        {
+            IList<Exception> exceptions = new List<Exception>();
+
+            ISet<string> uniqueSettingKeys = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
+            foreach (DictionaryEntry setting in settings)
             {
-                var argsDict = ruleArgs[rule] as Dictionary<string, object>;
-                if (argsDict == null)
+                if (setting.Key is null)
                 {
-                    throw new InvalidDataException(Strings.SettingsInputShouldBeDictionary);
+                    exceptions.Add(new InvalidDataException(
+                        Strings.SettingKeyIsNull));
+                    continue;
                 }
-                ruleArgsDict[rule] = argsDict;
-            }
 
-            return ruleArgsDict;
-        }
+                if (!(setting.Key is string))
+                {
+                    exceptions.Add(new InvalidDataException(string.Format(
+                        Strings.SettingKeyIsNotStringType,
+                        setting.Key)));
+                    continue;
+                }
+                string settingName = setting.Key as string;
 
-        private void parseSettingsHashtable(Hashtable settingsHashtable)
-        {
-            HashSet<string> validKeys = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
-            var settings = GetDictionaryFromHashtable(settingsHashtable);
-            foreach (var settingKey in settings.Keys)
-            {
-                var key = settingKey.ToLowerInvariant(); // ToLowerInvariant is important to also work with turkish culture, see https://github.com/PowerShell/PSScriptAnalyzer/issues/1095
-                object val = settings[key];
-                switch (key)
+                if (!uniqueSettingKeys.Add(settingName))
+                {
+                    // setting.Key should be used instead of settingName because the former preserves information about the source casing.
+                    exceptions.Add(new InvalidDataException(string.Format(
+                        Strings.SettingKeyIsNotUniqueIgnoringCase,
+                        setting.Key)));
+                    continue;
+                }
+
+                if (setting.Value is null)
+                {
+                    exceptions.Add(new InvalidDataException(string.Format(
+                        Strings.SettingValueIsNull,
+                        settingName)));
+                    continue;
+                }
+
+                // ToLowerInvariant is important to also work with turkish culture, see https://github.com/PowerShell/PSScriptAnalyzer/issues/1095
+                switch (settingName.ToLowerInvariant())
                 {
                     case "severity":
-                        severities = GetData(val, key);
+                        var maybeSeverity = ParseSettingValueStringOrStrings(setting.Value, settingName, exceptions);
+                        if (maybeSeverity is null)
+                        {
+                            continue;
+                        }
+
+                        this.severities = maybeSeverity;
                         break;
 
                     case "includerules":
-                        includeRules = GetData(val, key);
+                        var maybeIncludeRules = ParseSettingValueStringOrStrings(setting.Value, settingName, exceptions);
+                        if (maybeIncludeRules is null)
+                        {
+                            continue;
+                        }
+
+                        this.includeRules = maybeIncludeRules;
                         break;
 
                     case "excluderules":
-                        excludeRules = GetData(val, key);
+                        var maybeExcludeRules = ParseSettingValueStringOrStrings(setting.Value, settingName, exceptions);
+                        if (maybeExcludeRules is null)
+                        {
+                            continue;
+                        }
+
+                        this.excludeRules = maybeExcludeRules;
                         break;
 
                     case "customrulepath":
-                        customRulePath = GetData(val, key);
+                        var maybeCustomRulePath = ParseSettingValueStringOrStrings(setting.Value, settingName, exceptions);
+                        if (maybeCustomRulePath is null)
+                        {
+                            continue;
+                        }
+
+                        this.customRulePath = maybeCustomRulePath;
                         break;
 
                     case "includedefaultrules":
+                        bool? maybeIncludeDefaultRules = ParseSettingValueBoolean(setting.Value, settingName, exceptions);
+                        if (maybeIncludeDefaultRules is null)
+                        {
+                            continue;
+                        }
+
+                        this.includeDefaultRules = (bool) maybeIncludeDefaultRules;
+                        break;
+
                     case "recursecustomrulepath":
-                        if (!(val is bool))
+                        bool? maybeRecurseCustomRulePath = ParseSettingValueBoolean(setting.Value, settingName, exceptions);
+                        if (maybeRecurseCustomRulePath is null)
                         {
-                            throw new InvalidDataException(string.Format(
-                                CultureInfo.CurrentCulture,
-                                Strings.SettingsValueTypeMustBeBool,
-                                settingKey));
+                            continue;
                         }
 
-                        var booleanVal = (bool)val;
-                        var field = this.GetType().GetField(
-                            key,
-                            BindingFlags.Instance | BindingFlags.IgnoreCase | BindingFlags.NonPublic);
-                        field.SetValue(this, booleanVal);
+                        this.recurseCustomRulePath = (bool) maybeRecurseCustomRulePath;
                         break;
 
                     case "rules":
-                        try
+                        if (!(setting.Value is System.Collections.IDictionary))
                         {
-                            ruleArguments = ConvertToRuleArgumentType(val);
+                            exceptions.Add(new InvalidDataException(string.Format(
+                                Strings.SettingRulesValueIsNotDictionaryType,
+                                setting.Value)));
+                            continue;
                         }
-                        catch (ArgumentException argumentException)
+                        Hashtable rules = setting.Value as Hashtable;
+
+                        var parsedRules = new Dictionary<string, Dictionary<string, object>>(StringComparer.OrdinalIgnoreCase);
+                        ISet<string> uniqueRuleKeys = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
+                        foreach (DictionaryEntry rule in rules)
                         {
-                            throw new InvalidDataException(
-                                string.Format(CultureInfo.CurrentCulture, Strings.WrongValueHashTable, "", key),
-                                argumentException);
+                            if (rule.Key is null)
+                            {
+                                exceptions.Add(new InvalidDataException(
+                                    Strings.SettingRuleKeyIsNull));
+                                continue;
+                            }
+
+                            if (!(rule.Key is string))
+                            {
+                                exceptions.Add(new InvalidDataException(string.Format(
+                                    Strings.SettingRuleKeyIsNotStringType,
+                                    rule.Key)));
+                                continue;
+                            }
+                            string ruleName = rule.Key as string;
+
+                            if (!uniqueRuleKeys.Add(ruleName))
+                            {
+                                // rule.Key should be used instead of ruleName because the former preserves information about the source casing.
+                                exceptions.Add(new InvalidDataException(string.Format(
+                                    Strings.SettingRuleKeyIsNotUniqueIgnoringCase,
+                                    rule.Key)));
+                                // Do not `continue` because even if an element's key is non-unique, that element's value may still be checked.
+                            }
+
+                            if (rule.Value is null)
+                            {
+                                exceptions.Add(new InvalidDataException(string.Format(
+                                    Strings.SettingRuleValueIsNull,
+                                    ruleName)));
+                                continue;
+                            }
+
+                            if (!(rule.Value is System.Collections.IDictionary))
+                            {
+                                exceptions.Add(new InvalidDataException(string.Format(
+                                    Strings.SettingRuleValueIsNotDictionaryType,
+                                    ruleName,
+                                    rule.Value)));
+                                continue;
+                            }
+                            Hashtable arguments = rule.Value as Hashtable;
+
+                            var parsedArguments = new Dictionary<string, object>(StringComparer.OrdinalIgnoreCase);
+                            ISet<string> uniqueArgumentKeys = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
+                            foreach (DictionaryEntry argument in arguments)
+                            {
+                                if (argument.Key is null)
+                                {
+                                    exceptions.Add(new InvalidDataException(string.Format(
+                                        Strings.SettingRuleArgumentKeyIsNull,
+                                        ruleName)));
+                                    continue;
+                                }
+
+                                if (!(argument.Key is string))
+                                {
+                                    exceptions.Add(new InvalidDataException(string.Format(
+                                        Strings.SettingRuleArgumentKeyIsNotStringType,
+                                        ruleName,
+                                        argument.Key)));
+                                    continue;
+                                }
+                                string argumentName = argument.Key as string;
+
+                                if (!uniqueArgumentKeys.Add(argumentName))
+                                {
+                                    // argument.Key should be used instead of argumentName because the former preserves information about the source casing.
+                                    exceptions.Add(new InvalidDataException(string.Format(
+                                        Strings.SettingRuleArgumentKeyIsNotUniqueIgnoringCase,
+                                        ruleName,
+                                        argument.Key)));
+                                    continue;
+                                }
+
+                                if (argument.Value is null)
+                                {
+                                    exceptions.Add(new InvalidDataException(string.Format(
+                                        Strings.SettingRuleArgumentValueIsNull,
+                                        ruleName,
+                                        argumentName)));
+                                    continue;
+                                }
+
+                                parsedArguments[argumentName] = argument.Value;
+                            }
+
+                            parsedRules[ruleName] = parsedArguments;
                         }
 
+                        this.ruleArguments = parsedRules;
                         break;
 
                     default:
-                        throw new InvalidDataException(
-                            string.Format(
-                                CultureInfo.CurrentCulture,
-                                Strings.WrongKeyHashTable,
-                                key));
+                        exceptions.Add(new InvalidDataException(string.Format(
+                            Strings.WrongKeyHashTable,
+                            settingName)));
+                        continue;
                 }
             }
+
+            if (exceptions.Count > 0)
+            {
+                throw new AggregateException(exceptions);
+            }
         }
 
-        private void parseSettingsFile(string settingsFilePath)
+        private static Hashtable ParseSettingsFileToHashtable(string settingsFilePath)
         {
             Token[] parserTokens = null;
             ParseError[] parserErrors = null;
@@ -466,7 +563,9 @@ private void parseSettingsFile(string settingsFilePath)
             // no hashtable, raise warning
             if (hashTableAsts.Count() == 0)
             {
-                throw new ArgumentException(string.Format(CultureInfo.CurrentCulture, Strings.InvalidProfile, settingsFilePath));
+                throw new ArgumentException(string.Format(
+                    Strings.InvalidProfile,
+                    settingsFilePath));
             }
 
             HashtableAst hashTableAst = hashTableAsts.First() as HashtableAst;
@@ -477,21 +576,19 @@ private void parseSettingsFile(string settingsFilePath)
                 // it is not available on PSv3, we resort to our own narrow implementation.
                 hashtable = GetSafeValueFromHashtableAst(hashTableAst);
             }
-            catch (InvalidOperationException e)
+            catch (InvalidOperationException exception)
             {
-                throw new ArgumentException(Strings.InvalidProfile, e);
+                throw new ArgumentException(Strings.InvalidProfile, exception);
             }
 
-            if (hashtable == null)
+            if (hashtable is null)
             {
-                throw new ArgumentException(
-                    String.Format(
-                        CultureInfo.CurrentCulture,
-                        Strings.InvalidProfile,
-                        settingsFilePath));
+                throw new ArgumentException(String.Format(
+                    Strings.InvalidProfile,
+                    settingsFilePath));
             }
 
-            parseSettingsHashtable(hashtable);
+            return hashtable;
         }
 
         /// <summary>
diff --git a/Engine/Strings.Designer.cs b/Engine/Strings.Designer.cs
index 1fed6e234..705b254b5 100644
--- a/Engine/Strings.Designer.cs
+++ b/Engine/Strings.Designer.cs
@@ -1,7 +1,7 @@
-//------------------------------------------------------------------------------
+//------------------------------------------------------------------------------
 // <auto-generated>
-//     This code was generated by a tool.
-//     Runtime Version:4.0.30319.42000
+//     This code was generated by a New-StronglyTypedCsFileForResx function.
+//     To add or remove a member, edit your .ResX file then rerun Start-ResGen.
 //
 //     Changes to this file may cause incorrect behavior and will be lost if
 //     the code is regenerated.
@@ -9,676 +9,836 @@
 //------------------------------------------------------------------------------
 
 namespace Microsoft.Windows.PowerShell.ScriptAnalyzer {
-    using System;
-    
-    
+using System;
+using System.Reflection;
+
+/// <summary>
+///   A strongly-typed resource class, for looking up localized strings, etc.
+/// </summary>
+[global::System.CodeDom.Compiler.GeneratedCodeAttribute("System.Resources.Tools.StronglyTypedResourceBuilder", "15.0.0.0")]
+[global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
+[global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
+
+internal class Strings {
+
+    private static global::System.Resources.ResourceManager resourceMan;
+
+    private static global::System.Globalization.CultureInfo resourceCulture;
+
+    [global::System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
+    internal Strings() {
+    }
+
     /// <summary>
-    ///   A strongly-typed resource class, for looking up localized strings, etc.
-    /// </summary>
-    // This class was auto-generated by the StronglyTypedResourceBuilder
-    // class via a tool like ResGen or Visual Studio.
-    // To add or remove a member, edit your .ResX file then rerun ResGen
-    // with the /str option, or rebuild your VS project.
-    [global::System.CodeDom.Compiler.GeneratedCodeAttribute("System.Resources.Tools.StronglyTypedResourceBuilder", "16.0.0.0")]
-    [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
-    [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
-    internal class Strings {
-        
-        private static global::System.Resources.ResourceManager resourceMan;
-        
-        private static global::System.Globalization.CultureInfo resourceCulture;
-        
-        [global::System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
-        internal Strings() {
-        }
-        
-        /// <summary>
-        ///   Returns the cached ResourceManager instance used by this class.
-        /// </summary>
-        [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
-        internal static global::System.Resources.ResourceManager ResourceManager {
-            get {
-                if (object.ReferenceEquals(resourceMan, null)) {
-                    global::System.Resources.ResourceManager temp = new global::System.Resources.ResourceManager("Microsoft.Windows.PowerShell.ScriptAnalyzer.Strings", typeof(Strings).Assembly);
-                    resourceMan = temp;
-                }
-                return resourceMan;
+    ///   Returns the cached ResourceManager instance used by this class.
+    /// </summary>
+    [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
+    internal static global::System.Resources.ResourceManager ResourceManager {
+        get {
+            if (object.ReferenceEquals(resourceMan, null)) {
+                global::System.Resources.ResourceManager temp = new global::System.Resources.ResourceManager("Microsoft.Windows.PowerShell.ScriptAnalyzer.Strings", typeof(Strings).GetTypeInfo().Assembly);
+                resourceMan = temp;
             }
+            return resourceMan;
         }
-        
-        /// <summary>
-        ///   Overrides the current thread's CurrentUICulture property for all
-        ///   resource lookups using this strongly typed resource class.
-        /// </summary>
-        [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
-        internal static global::System.Globalization.CultureInfo Culture {
-            get {
-                return resourceCulture;
-            }
-            set {
-                resourceCulture = value;
-            }
+    }
+
+    /// <summary>
+    ///   Overrides the current thread's CurrentUICulture property for all
+    ///   resource lookups using this strongly typed resource class.
+    /// </summary>
+    [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
+    internal static global::System.Globalization.CultureInfo Culture {
+        get {
+            return resourceCulture;
         }
-        
-        /// <summary>
-        ///   Looks up a localized string similar to Checking assembly file &apos;{0}&apos; ....
-        /// </summary>
-        internal static string CheckAssemblyFile {
-            get {
-                return ResourceManager.GetString("CheckAssemblyFile", resourceCulture);
-            }
+        set {
+            resourceCulture = value;
         }
-        
-        /// <summary>
-        ///   Looks up a localized string similar to Checking module &apos;{0}&apos; ....
-        /// </summary>
-        internal static string CheckModuleName {
-            get {
-                return ResourceManager.GetString("CheckModuleName", resourceCulture);
-            }
+    }
+    
+    /// <summary>
+    ///   Looks up a localized string similar to Checking assembly file '{0}' ...
+    /// </summary>
+    internal static string CheckAssemblyFile {
+        get {
+            return ResourceManager.GetString("CheckAssemblyFile", resourceCulture);
         }
-        
-        /// <summary>
-        ///   Looks up a localized string similar to CommandInfo not found for function: {0}.
-        /// </summary>
-        internal static string CommandInfoNotFound {
-            get {
-                return ResourceManager.GetString("CommandInfoNotFound", resourceCulture);
-            }
+    }
+
+    /// <summary>
+    ///   Looks up a localized string similar to Checking module '{0}' ...
+    /// </summary>
+    internal static string CheckModuleName {
+        get {
+            return ResourceManager.GetString("CheckModuleName", resourceCulture);
         }
-        
-        /// <summary>
-        ///   Looks up a localized string similar to &quot;Argument should not be null.&quot;..
-        /// </summary>
-        internal static string ConfigurableScriptRuleNRE {
-            get {
-                return ResourceManager.GetString("ConfigurableScriptRuleNRE", resourceCulture);
-            }
+    }
+
+    /// <summary>
+    ///   Looks up a localized string similar to CommandInfo not found for function: {0}
+    /// </summary>
+    internal static string CommandInfoNotFound {
+        get {
+            return ResourceManager.GetString("CommandInfoNotFound", resourceCulture);
         }
-        
-        /// <summary>
-        ///   Looks up a localized string similar to &quot;Cannot find a ConfigurableRuleProperty attribute on property {0}&quot;..
-        /// </summary>
-        internal static string ConfigurableScriptRulePropertyHasNotAttribute {
-            get {
-                return ResourceManager.GetString("ConfigurableScriptRulePropertyHasNotAttribute", resourceCulture);
-            }
+    }
+
+    /// <summary>
+    ///   Looks up a localized string similar to Writes all diagnostics to WriteObject.
+    /// </summary>
+    internal static string DefaultLoggerDescription {
+        get {
+            return ResourceManager.GetString("DefaultLoggerDescription", resourceCulture);
         }
-        
-        /// <summary>
-        ///   Looks up a localized string similar to SettingsFileHasInvalidHashtable.
-        /// </summary>
-        internal static string ConfigurationFileHasInvalidHashtable {
-            get {
-                return ResourceManager.GetString("ConfigurationFileHasInvalidHashtable", resourceCulture);
-            }
+    }
+
+    /// <summary>
+    ///   Looks up a localized string similar to WriteObjects
+    /// </summary>
+    internal static string DefaultLoggerName {
+        get {
+            return ResourceManager.GetString("DefaultLoggerName", resourceCulture);
         }
-        
-        /// <summary>
-        ///   Looks up a localized string similar to SettingsFileHasNoHashTable.
-        /// </summary>
-        internal static string ConfigurationFileHasNoHashTable {
-            get {
-                return ResourceManager.GetString("ConfigurationFileHasNoHashTable", resourceCulture);
-            }
+    }
+
+    /// <summary>
+    ///   Looks up a localized string similar to Cannot find file '{0}'.
+    /// </summary>
+    internal static string FileNotFound {
+        get {
+            return ResourceManager.GetString("FileNotFound", resourceCulture);
         }
-        
-        /// <summary>
-        ///   Looks up a localized string similar to SettingsFileNotFound.
-        /// </summary>
-        internal static string ConfigurationFileNotFound {
-            get {
-                return ResourceManager.GetString("ConfigurationFileNotFound", resourceCulture);
-            }
+    }
+
+    /// <summary>
+    ///   Looks up a localized string similar to Cannot find the path '{0}'.
+    /// </summary>
+    internal static string InvalidPath {
+        get {
+            return ResourceManager.GetString("InvalidPath", resourceCulture);
         }
-        
-        /// <summary>
-        ///   Looks up a localized string similar to SettingsKeyNotAString.
-        /// </summary>
-        internal static string ConfigurationKeyNotAString {
-            get {
-                return ResourceManager.GetString("ConfigurationKeyNotAString", resourceCulture);
-            }
+    }
+
+    /// <summary>
+    ///   Looks up a localized string similar to No loggers found.
+    /// </summary>
+    internal static string LoggersNotFound {
+        get {
+            return ResourceManager.GetString("LoggersNotFound", resourceCulture);
         }
-        
-        /// <summary>
-        ///   Looks up a localized string similar to SettingsValueNotAString.
-        /// </summary>
-        internal static string ConfigurationValueNotAString {
-            get {
-                return ResourceManager.GetString("ConfigurationValueNotAString", resourceCulture);
-            }
+    }
+
+    /// <summary>
+    ///   Looks up a localized string similar to Cannot find rule extension '{0}'.
+    /// </summary>
+    internal static string MissingRuleExtension {
+        get {
+            return ResourceManager.GetString("MissingRuleExtension", resourceCulture);
         }
-        
-        /// <summary>
-        ///   Looks up a localized string similar to SettingsValueWrongFormat.
-        /// </summary>
-        internal static string ConfigurationValueWrongFormat {
-            get {
-                return ResourceManager.GetString("ConfigurationValueWrongFormat", resourceCulture);
-            }
+    }
+
+    /// <summary>
+    ///   Looks up a localized string similar to {0} cannot be set by both positional and named arguments.
+    /// </summary>
+    internal static string NamedAndPositionalArgumentsConflictError {
+        get {
+            return ResourceManager.GetString("NamedAndPositionalArgumentsConflictError", resourceCulture);
         }
-        
-        /// <summary>
-        ///   Looks up a localized string similar to Writes all diagnostics to WriteObject..
-        /// </summary>
-        internal static string DefaultLoggerDescription {
-            get {
-                return ResourceManager.GetString("DefaultLoggerDescription", resourceCulture);
-            }
+    }
+
+    /// <summary>
+    ///   Looks up a localized string similar to Named arguments must always come after positional arguments.
+    /// </summary>
+    internal static string NamedArgumentsBeforePositionalError {
+        get {
+            return ResourceManager.GetString("NamedArgumentsBeforePositionalError", resourceCulture);
         }
-        
-        /// <summary>
-        ///   Looks up a localized string similar to WriteObjects.
-        /// </summary>
-        internal static string DefaultLoggerName {
-            get {
-                return ResourceManager.GetString("DefaultLoggerName", resourceCulture);
-            }
+    }
+
+    /// <summary>
+    ///   Looks up a localized string similar to Parse error in file {0}:  {1} at line {2} column {3}.
+    /// </summary>
+    internal static string ParserErrorFormat {
+        get {
+            return ResourceManager.GetString("ParserErrorFormat", resourceCulture);
         }
-        
-        /// <summary>
-        ///   Looks up a localized string similar to Edge from {0} to {1} already exists..
-        /// </summary>
-        internal static string DigraphEdgeAlreadyExists {
-            get {
-                return ResourceManager.GetString("DigraphEdgeAlreadyExists", resourceCulture);
-            }
+    }
+
+    /// <summary>
+    ///   Looks up a localized string similar to There are too many parser errors in {0}. Please correct them before running ScriptAnalyzer.
+    /// </summary>
+    internal static string ParserErrorMessage {
+        get {
+            return ResourceManager.GetString("ParserErrorMessage", resourceCulture);
         }
-        
-        /// <summary>
-        ///   Looks up a localized string similar to Vertex {0} already exists! Cannot add it to the digraph..
-        /// </summary>
-        internal static string DigraphVertexAlreadyExists {
-            get {
-                return ResourceManager.GetString("DigraphVertexAlreadyExists", resourceCulture);
-            }
+    }
+
+    /// <summary>
+    ///   Looks up a localized string similar to RULE_ERROR
+    /// </summary>
+    internal static string RuleErrorMessage {
+        get {
+            return ResourceManager.GetString("RuleErrorMessage", resourceCulture);
         }
-        
-        /// <summary>
-        ///   Looks up a localized string similar to Vertex {0} does not exist in the digraph..
-        /// </summary>
-        internal static string DigraphVertexDoesNotExists {
-            get {
-                return ResourceManager.GetString("DigraphVertexDoesNotExists", resourceCulture);
-            }
+    }
+
+    /// <summary>
+    ///   Looks up a localized string similar to Cannot find ScriptAnalyzer rules in the specified path
+    /// </summary>
+    internal static string RulesNotFound {
+        get {
+            return ResourceManager.GetString("RulesNotFound", resourceCulture);
         }
-        
-        /// <summary>
-        ///   Looks up a localized string similar to Cannot determine line endings as the text probably contain mixed line endings..
-        /// </summary>
-        internal static string EditableTextInvalidLineEnding {
-            get {
-                return ResourceManager.GetString("EditableTextInvalidLineEnding", resourceCulture);
-            }
+    }
+
+    /// <summary>
+    ///   Looks up a localized string similar to Suppression Message Attribute error at line {0} in {1} : {2}
+    /// </summary>
+    internal static string RuleSuppressionErrorFormat {
+        get {
+            return ResourceManager.GetString("RuleSuppressionErrorFormat", resourceCulture);
         }
-        
-        /// <summary>
-        ///   Looks up a localized string similar to TextEdit extent not completely contained in EditableText..
-        /// </summary>
-        internal static string EditableTextRangeIsNotContained {
-            get {
-                return ResourceManager.GetString("EditableTextRangeIsNotContained", resourceCulture);
-            }
+    }
+
+    /// <summary>
+    ///   Looks up a localized string similar to All the arguments of the Suppress Message Attribute should be string constants.
+    /// </summary>
+    internal static string StringConstantArgumentsSuppressionAttributeError {
+        get {
+            return ResourceManager.GetString("StringConstantArgumentsSuppressionAttributeError", resourceCulture);
         }
-        
-        /// <summary>
-        ///   Looks up a localized string similar to Cannot find file &apos;{0}&apos;..
-        /// </summary>
-        internal static string FileNotFound {
-            get {
-                return ResourceManager.GetString("FileNotFound", resourceCulture);
-            }
+    }
+
+    /// <summary>
+    ///   Looks up a localized string similar to If Target is specified, Scope must be specified.
+    /// </summary>
+    internal static string TargetWithoutScopeSuppressionAttributeError {
+        get {
+            return ResourceManager.GetString("TargetWithoutScopeSuppressionAttributeError", resourceCulture);
         }
-        
-        /// <summary>
-        ///   Looks up a localized string similar to Cannot find the path &apos;{0}&apos;..
-        /// </summary>
-        internal static string InvalidPath {
-            get {
-                return ResourceManager.GetString("InvalidPath", resourceCulture);
-            }
+    }
+
+    /// <summary>
+    ///   Looks up a localized string similar to Analyzing file: {0}
+    /// </summary>
+    internal static string VerboseFileMessage {
+        get {
+            return ResourceManager.GetString("VerboseFileMessage", resourceCulture);
         }
-        
-        /// <summary>
-        ///   Looks up a localized string similar to Settings file &apos;{0}&apos; is invalid because it does not contain a hashtable..
-        /// </summary>
-        internal static string InvalidProfile {
-            get {
-                return ResourceManager.GetString("InvalidProfile", resourceCulture);
-            }
+    }
+
+    /// <summary>
+    ///   Looks up a localized string similar to Running {0} rule.
+    /// </summary>
+    internal static string VerboseRunningMessage {
+        get {
+            return ResourceManager.GetString("VerboseRunningMessage", resourceCulture);
         }
-        
-        /// <summary>
-        ///   Looks up a localized string similar to Key {0} in the settings is not a string..
-        /// </summary>
-        internal static string KeyNotString {
-            get {
-                return ResourceManager.GetString("KeyNotString", resourceCulture);
-            }
+    }
+
+    /// <summary>
+    ///   Looks up a localized string similar to Scope can only be either function or class.
+    /// </summary>
+    internal static string WrongScopeArgumentSuppressionAttributeError {
+        get {
+            return ResourceManager.GetString("WrongScopeArgumentSuppressionAttributeError", resourceCulture);
         }
-        
-        /// <summary>
-        ///   Looks up a localized string similar to No loggers found..
-        /// </summary>
-        internal static string LoggersNotFound {
-            get {
-                return ResourceManager.GetString("LoggersNotFound", resourceCulture);
-            }
+    }
+
+    /// <summary>
+    ///   Looks up a localized string similar to RuleName must not be null.
+    /// </summary>
+    internal static string NullRuleNameError {
+        get {
+            return ResourceManager.GetString("NullRuleNameError", resourceCulture);
         }
-        
-        /// <summary>
-        ///   Looks up a localized string similar to Cannot find rule extension &apos;{0}&apos;..
-        /// </summary>
-        internal static string MissingRuleExtension {
-            get {
-                return ResourceManager.GetString("MissingRuleExtension", resourceCulture);
-            }
+    }
+
+    /// <summary>
+    ///   Looks up a localized string similar to Cannot find any Targets {0} that match the Scope {1} to apply the SuppressMessageAttribute.
+    /// </summary>
+    internal static string TargetCannotBeFoundError {
+        get {
+            return ResourceManager.GetString("TargetCannotBeFoundError", resourceCulture);
         }
-        
-        /// <summary>
-        ///   Looks up a localized string similar to Temporary module location: {0}..
-        /// </summary>
-        internal static string ModuleDepHandlerTempLocation {
-            get {
-                return ResourceManager.GetString("ModuleDepHandlerTempLocation", resourceCulture);
-            }
+    }
+
+    /// <summary>
+    ///   Looks up a localized string similar to Cannot find any DiagnosticRecord with the Rule Suppression ID {0}.
+    /// </summary>
+    internal static string RuleSuppressionIDError {
+        get {
+            return ResourceManager.GetString("RuleSuppressionIDError", resourceCulture);
         }
-        
-        /// <summary>
-        ///   Looks up a localized string similar to {0} cannot be set by both positional and named arguments..
-        /// </summary>
-        internal static string NamedAndPositionalArgumentsConflictError {
-            get {
-                return ResourceManager.GetString("NamedAndPositionalArgumentsConflictError", resourceCulture);
-            }
+    }
+
+    /// <summary>
+    ///   Looks up a localized string similar to {0} is not a valid key in the settings hashtable: file {3}. Valid keys are ExcludeRules, IncludeRules and Severity.
+    /// </summary>
+    internal static string WrongKey {
+        get {
+            return ResourceManager.GetString("WrongKey", resourceCulture);
         }
-        
-        /// <summary>
-        ///   Looks up a localized string similar to Named arguments must always come after positional arguments..
-        /// </summary>
-        internal static string NamedArgumentsBeforePositionalError {
-            get {
-                return ResourceManager.GetString("NamedArgumentsBeforePositionalError", resourceCulture);
-            }
+    }
+
+    /// <summary>
+    ///   Looks up a localized string similar to Key in the settings hashtable should be a string: line {0} column {1} in file {2}
+    /// </summary>
+    internal static string WrongKeyFormat {
+        get {
+            return ResourceManager.GetString("WrongKeyFormat", resourceCulture);
         }
-        
-        /// <summary>
-        ///   Looks up a localized string similar to RuleName must not be null..
-        /// </summary>
-        internal static string NullRuleNameError {
-            get {
-                return ResourceManager.GetString("NullRuleNameError", resourceCulture);
-            }
+    }
+
+    /// <summary>
+    ///   Looks up a localized string similar to Value in the settings hashtable should be a string or an array of strings: line {0} column {1} in file {2}
+    /// </summary>
+    internal static string WrongValueFormat {
+        get {
+            return ResourceManager.GetString("WrongValueFormat", resourceCulture);
         }
-        
-        /// <summary>
-        ///   Looks up a localized string similar to Parse error in script definition:  {0} at line {1} column {2}..
-        /// </summary>
-        internal static string ParseErrorFormatForScriptDefinition {
-            get {
-                return ResourceManager.GetString("ParseErrorFormatForScriptDefinition", resourceCulture);
-            }
+    }
+
+    /// <summary>
+    ///   Looks up a localized string similar to Settings file '{0}' is invalid because it does not contain a hashtable.
+    /// </summary>
+    internal static string InvalidProfile {
+        get {
+            return ResourceManager.GetString("InvalidProfile", resourceCulture);
         }
-        
-        /// <summary>
-        ///   Looks up a localized string similar to Parse error in file {0}:  {1} at line {2} column {3}..
-        /// </summary>
-        internal static string ParserErrorFormat {
-            get {
-                return ResourceManager.GetString("ParserErrorFormat", resourceCulture);
-            }
+    }
+
+    /// <summary>
+    ///   Looks up a localized string similar to Parse error in script definition:  {0} at line {1} column {2}.
+    /// </summary>
+    internal static string ParseErrorFormatForScriptDefinition {
+        get {
+            return ResourceManager.GetString("ParseErrorFormatForScriptDefinition", resourceCulture);
         }
-        
-        /// <summary>
-        ///   Looks up a localized string similar to There are too many parser errors in {0}. Please correct them before running ScriptAnalyzer..
-        /// </summary>
-        internal static string ParserErrorMessage {
-            get {
-                return ResourceManager.GetString("ParserErrorMessage", resourceCulture);
-            }
+    }
+
+    /// <summary>
+    ///   Looks up a localized string similar to There are too many parser errors in the script definition. Please correct them before running ScriptAnalyzer.
+    /// </summary>
+    internal static string ParserErrorMessageForScriptDefinition {
+        get {
+            return ResourceManager.GetString("ParserErrorMessageForScriptDefinition", resourceCulture);
         }
-        
-        /// <summary>
-        ///   Looks up a localized string similar to There are too many parser errors in the script definition. Please correct them before running ScriptAnalyzer..
-        /// </summary>
-        internal static string ParserErrorMessageForScriptDefinition {
-            get {
-                return ResourceManager.GetString("ParserErrorMessageForScriptDefinition", resourceCulture);
-            }
+    }
+
+    /// <summary>
+    ///   Looks up a localized string similar to Suppression Message Attribute error at line {0} in script definition : {1}
+    /// </summary>
+    internal static string RuleSuppressionErrorFormatScriptDefinition {
+        get {
+            return ResourceManager.GetString("RuleSuppressionErrorFormatScriptDefinition", resourceCulture);
         }
-        
-        /// <summary>
-        ///   Looks up a localized string similar to Column number cannot be less than 1..
-        /// </summary>
-        internal static string PositionColumnLessThanOne {
-            get {
-                return ResourceManager.GetString("PositionColumnLessThanOne", resourceCulture);
-            }
+    }
+
+    /// <summary>
+    ///   Looks up a localized string similar to Analyzing Script Definition.
+    /// </summary>
+    internal static string VerboseScriptDefinitionMessage {
+        get {
+            return ResourceManager.GetString("VerboseScriptDefinitionMessage", resourceCulture);
         }
-        
-        /// <summary>
-        ///   Looks up a localized string similar to Line number cannot be less than 1..
-        /// </summary>
-        internal static string PositionLineLessThanOne {
-            get {
-                return ResourceManager.GetString("PositionLineLessThanOne", resourceCulture);
-            }
+    }
+
+    /// <summary>
+    ///   Looks up a localized string similar to SettingsFileHasInvalidHashtable
+    /// </summary>
+    internal static string ConfigurationFileHasInvalidHashtable {
+        get {
+            return ResourceManager.GetString("ConfigurationFileHasInvalidHashtable", resourceCulture);
         }
-        
-        /// <summary>
-        ///   Looks up a localized string similar to Input position should be less than that of the invoking object..
-        /// </summary>
-        internal static string PositionRefPosLessThanInputPos {
-            get {
-                return ResourceManager.GetString("PositionRefPosLessThanInputPos", resourceCulture);
-            }
+    }
+
+    /// <summary>
+    ///   Looks up a localized string similar to SettingsFileHasNoHashTable
+    /// </summary>
+    internal static string ConfigurationFileHasNoHashTable {
+        get {
+            return ResourceManager.GetString("ConfigurationFileHasNoHashTable", resourceCulture);
         }
-        
-        /// <summary>
-        ///   Looks up a localized string similar to Reference Position should begin before start Position of Range..
-        /// </summary>
-        internal static string RangeRefPosShouldStartBeforeRangeStartPos {
-            get {
-                return ResourceManager.GetString("RangeRefPosShouldStartBeforeRangeStartPos", resourceCulture);
-            }
+    }
+
+    /// <summary>
+    ///   Looks up a localized string similar to SettingsFileNotFound
+    /// </summary>
+    internal static string ConfigurationFileNotFound {
+        get {
+            return ResourceManager.GetString("ConfigurationFileNotFound", resourceCulture);
         }
-        
-        /// <summary>
-        ///   Looks up a localized string similar to Start position cannot be before End position..
-        /// </summary>
-        internal static string RangeStartPosGreaterThanEndPos {
-            get {
-                return ResourceManager.GetString("RangeStartPosGreaterThanEndPos", resourceCulture);
-            }
+    }
+
+    /// <summary>
+    ///   Looks up a localized string similar to SettingsKeyNotAString
+    /// </summary>
+    internal static string ConfigurationKeyNotAString {
+        get {
+            return ResourceManager.GetString("ConfigurationKeyNotAString", resourceCulture);
         }
-        
-        /// <summary>
-        ///   Looks up a localized string similar to RULE_ERROR.
-        /// </summary>
-        internal static string RuleErrorMessage {
-            get {
-                return ResourceManager.GetString("RuleErrorMessage", resourceCulture);
-            }
+    }
+
+    /// <summary>
+    ///   Looks up a localized string similar to SettingsValueNotAString
+    /// </summary>
+    internal static string ConfigurationValueNotAString {
+        get {
+            return ResourceManager.GetString("ConfigurationValueNotAString", resourceCulture);
         }
-        
-        /// <summary>
-        ///   Looks up a localized string similar to Cannot find ScriptAnalyzer rules in the specified path.
-        /// </summary>
-        internal static string RulesNotFound {
-            get {
-                return ResourceManager.GetString("RulesNotFound", resourceCulture);
-            }
+    }
+
+    /// <summary>
+    ///   Looks up a localized string similar to SettingsValueWrongFormat
+    /// </summary>
+    internal static string ConfigurationValueWrongFormat {
+        get {
+            return ResourceManager.GetString("ConfigurationValueWrongFormat", resourceCulture);
         }
-        
-        /// <summary>
-        ///   Looks up a localized string similar to Suppression Message Attribute error at line {0} in {1} : {2}.
-        /// </summary>
-        internal static string RuleSuppressionErrorFormat {
-            get {
-                return ResourceManager.GetString("RuleSuppressionErrorFormat", resourceCulture);
-            }
+    }
+
+    /// <summary>
+    ///   Looks up a localized string similar to WrongSettingsKey
+    /// </summary>
+    internal static string WrongConfigurationKey {
+        get {
+            return ResourceManager.GetString("WrongConfigurationKey", resourceCulture);
         }
-        
-        /// <summary>
-        ///   Looks up a localized string similar to Suppression Message Attribute error at line {0} in script definition : {1}.
-        /// </summary>
-        internal static string RuleSuppressionErrorFormatScriptDefinition {
-            get {
-                return ResourceManager.GetString("RuleSuppressionErrorFormatScriptDefinition", resourceCulture);
-            }
+    }
+
+    /// <summary>
+    ///   Looks up a localized string similar to Key {0} in the settings is not a string.
+    /// </summary>
+    internal static string KeyNotString {
+        get {
+            return ResourceManager.GetString("KeyNotString", resourceCulture);
         }
-        
-        /// <summary>
-        ///   Looks up a localized string similar to Cannot find any DiagnosticRecord with the Rule Suppression ID {0}..
-        /// </summary>
-        internal static string RuleSuppressionIDError {
-            get {
-                return ResourceManager.GetString("RuleSuppressionIDError", resourceCulture);
-            }
+    }
+
+    /// <summary>
+    ///   Looks up a localized string similar to {0} is not a valid key in the settings hashtable. Valid keys are ExcludeRules, IncludeRules and Severity.
+    /// </summary>
+    internal static string WrongKeyHashTable {
+        get {
+            return ResourceManager.GetString("WrongKeyHashTable", resourceCulture);
         }
-        
-        /// <summary>
-        ///   Looks up a localized string similar to Found {0}. Will use it to provide settings for this invocation..
-        /// </summary>
-        internal static string SettingsAutoDiscovered {
-            get {
-                return ResourceManager.GetString("SettingsAutoDiscovered", resourceCulture);
-            }
+    }
+
+    /// <summary>
+    ///   Looks up a localized string similar to Value {0} for key {1} has the wrong data type.
+    /// </summary>
+    internal static string WrongValueHashTable {
+        get {
+            return ResourceManager.GetString("WrongValueHashTable", resourceCulture);
         }
-        
-        /// <summary>
-        ///   Looks up a localized string similar to Cannot resolve settings file path &apos;{0}&apos;..
-        /// </summary>
-        internal static string SettingsCannotFindFile {
-            get {
-                return ResourceManager.GetString("SettingsCannotFindFile", resourceCulture);
-            }
+    }
+
+    /// <summary>
+    ///   Looks up a localized string similar to Input should be a dictionary type.
+    /// </summary>
+    internal static string SettingsInputShouldBeDictionary {
+        get {
+            return ResourceManager.GetString("SettingsInputShouldBeDictionary", resourceCulture);
         }
-        
-        /// <summary>
-        ///   Looks up a localized string similar to Dictionary should be indexable in a case-insensitive manner..
-        /// </summary>
-        internal static string SettingsDictionaryShouldBeCaseInsesitive {
-            get {
-                return ResourceManager.GetString("SettingsDictionaryShouldBeCaseInsesitive", resourceCulture);
-            }
+    }
+
+    /// <summary>
+    ///   Looks up a localized string similar to A setting key is null.
+    /// </summary>
+    internal static string SettingKeyIsNull {
+        get {
+            return ResourceManager.GetString("SettingKeyIsNull", resourceCulture);
         }
-        
-        /// <summary>
-        ///   Looks up a localized string similar to Input should be a dictionary type..
-        /// </summary>
-        internal static string SettingsInputShouldBeDictionary {
-            get {
-                return ResourceManager.GetString("SettingsInputShouldBeDictionary", resourceCulture);
-            }
+    }
+
+    /// <summary>
+    ///   Looks up a localized string similar to The setting key '{0}' is not a string type.
+    /// </summary>
+    internal static string SettingKeyIsNotStringType {
+        get {
+            return ResourceManager.GetString("SettingKeyIsNotStringType", resourceCulture);
         }
-        
-        /// <summary>
-        ///   Looks up a localized string similar to Settings should be either a file path, built-in preset or a hashtable..
-        /// </summary>
-        internal static string SettingsInvalidType {
-            get {
-                return ResourceManager.GetString("SettingsInvalidType", resourceCulture);
-            }
+    }
+
+    /// <summary>
+    ///   Looks up a localized string similar to The setting key '{0}' is not unique, ignoring case.
+    /// </summary>
+    internal static string SettingKeyIsNotUniqueIgnoringCase {
+        get {
+            return ResourceManager.GetString("SettingKeyIsNotUniqueIgnoringCase", resourceCulture);
         }
-        
-        /// <summary>
-        ///   Looks up a localized string similar to Cannot parse settings. Will abort the invocation..
-        /// </summary>
-        internal static string SettingsNotParsable {
-            get {
-                return ResourceManager.GetString("SettingsNotParsable", resourceCulture);
-            }
+    }
+
+    /// <summary>
+    ///   Looks up a localized string similar to The setting '{0}' value is null.
+    /// </summary>
+    internal static string SettingValueIsNull {
+        get {
+            return ResourceManager.GetString("SettingValueIsNull", resourceCulture);
         }
-        
-        /// <summary>
-        ///   Looks up a localized string similar to Settings not provided. Will look for settings file in the given path {0}..
-        /// </summary>
-        internal static string SettingsNotProvided {
-            get {
-                return ResourceManager.GetString("SettingsNotProvided", resourceCulture);
-            }
+    }
+
+    /// <summary>
+    ///   Looks up a localized string similar to The setting '{0}' value '{1}' is not a boolean type.
+    /// </summary>
+    internal static string SettingValueIsNotBooleanType {
+        get {
+            return ResourceManager.GetString("SettingValueIsNotBooleanType", resourceCulture);
         }
-        
-        /// <summary>
-        ///   Looks up a localized string similar to Settings object could not be resolved..
-        /// </summary>
-        internal static string SettingsObjectCouldNotBResolved {
-            get {
-                return ResourceManager.GetString("SettingsObjectCouldNotBResolved", resourceCulture);
-            }
+    }
+
+    /// <summary>
+    ///   Looks up a localized string similar to The setting '{0}' value '{1}' is not a string or collection of strings type.
+    /// </summary>
+    internal static string SettingValueIsNotStringOrStringsType {
+        get {
+            return ResourceManager.GetString("SettingValueIsNotStringOrStringsType", resourceCulture);
         }
-        
-        /// <summary>
-        ///   Looks up a localized string similar to Using settings file at {0}..
-        /// </summary>
-        internal static string SettingsUsingFile {
-            get {
-                return ResourceManager.GetString("SettingsUsingFile", resourceCulture);
-            }
+    }
+
+    /// <summary>
+    ///   Looks up a localized string similar to The setting '{0}', index {1} element is null.
+    /// </summary>
+    internal static string SettingValueElementIsNull {
+        get {
+            return ResourceManager.GetString("SettingValueElementIsNull", resourceCulture);
         }
-        
-        /// <summary>
-        ///   Looks up a localized string similar to Using settings hashtable..
-        /// </summary>
-        internal static string SettingsUsingHashtable {
-            get {
-                return ResourceManager.GetString("SettingsUsingHashtable", resourceCulture);
-            }
+    }
+
+    /// <summary>
+    ///   Looks up a localized string similar to The setting '{0}', index {1} element, value '{2}' is not a string type.
+    /// </summary>
+    internal static string SettingValueElementIsNotStringType {
+        get {
+            return ResourceManager.GetString("SettingValueElementIsNotStringType", resourceCulture);
         }
-        
-        /// <summary>
-        ///   Looks up a localized string similar to {0} property must be of type bool..
-        /// </summary>
-        internal static string SettingsValueTypeMustBeBool {
-            get {
-                return ResourceManager.GetString("SettingsValueTypeMustBeBool", resourceCulture);
-            }
+    }
+
+    /// <summary>
+    ///   Looks up a localized string similar to The setting 'Rules' value '{0}' is not a dictionary type.
+    /// </summary>
+    internal static string SettingRulesValueIsNotDictionaryType {
+        get {
+            return ResourceManager.GetString("SettingRulesValueIsNotDictionaryType", resourceCulture);
         }
-        
-        /// <summary>
-        ///   Looks up a localized string similar to All the arguments of the Suppress Message Attribute should be string constants..
-        /// </summary>
-        internal static string StringConstantArgumentsSuppressionAttributeError {
-            get {
-                return ResourceManager.GetString("StringConstantArgumentsSuppressionAttributeError", resourceCulture);
-            }
+    }
+
+    /// <summary>
+    ///   Looks up a localized string similar to A setting 'Rules', rule key is null.
+    /// </summary>
+    internal static string SettingRuleKeyIsNull {
+        get {
+            return ResourceManager.GetString("SettingRuleKeyIsNull", resourceCulture);
         }
-        
-        /// <summary>
-        ///   Looks up a localized string similar to Cannot find any Targets {0} that match the Scope {1} to apply the SuppressMessageAttribute..
-        /// </summary>
-        internal static string TargetCannotBeFoundError {
-            get {
-                return ResourceManager.GetString("TargetCannotBeFoundError", resourceCulture);
-            }
+    }
+
+    /// <summary>
+    ///   Looks up a localized string similar to The setting 'Rules', rule key '{0}' is not a string type.
+    /// </summary>
+    internal static string SettingRuleKeyIsNotStringType {
+        get {
+            return ResourceManager.GetString("SettingRuleKeyIsNotStringType", resourceCulture);
         }
-        
-        /// <summary>
-        ///   Looks up a localized string similar to If Target is specified, Scope must be specified..
-        /// </summary>
-        internal static string TargetWithoutScopeSuppressionAttributeError {
-            get {
-                return ResourceManager.GetString("TargetWithoutScopeSuppressionAttributeError", resourceCulture);
-            }
+    }
+
+    /// <summary>
+    ///   Looks up a localized string similar to The setting 'Rules', rule key '{0}' is not unique, ignoring case.
+    /// </summary>
+    internal static string SettingRuleKeyIsNotUniqueIgnoringCase {
+        get {
+            return ResourceManager.GetString("SettingRuleKeyIsNotUniqueIgnoringCase", resourceCulture);
         }
-        
-        /// <summary>
-        ///   Looks up a localized string similar to Line element cannot be null..
-        /// </summary>
-        internal static string TextEditNoNullItem {
-            get {
-                return ResourceManager.GetString("TextEditNoNullItem", resourceCulture);
-            }
+    }
+
+    /// <summary>
+    ///   Looks up a localized string similar to The setting 'Rules', rule '{0}' value is null.
+    /// </summary>
+    internal static string SettingRuleValueIsNull {
+        get {
+            return ResourceManager.GetString("SettingRuleValueIsNull", resourceCulture);
         }
-        
-        /// <summary>
-        ///   Looks up a localized string similar to Line element cannot be null..
-        /// </summary>
-        internal static string TextLinesNoNullItem {
-            get {
-                return ResourceManager.GetString("TextLinesNoNullItem", resourceCulture);
-            }
+    }
+
+    /// <summary>
+    ///   Looks up a localized string similar to The setting 'Rules', rule '{0}' value '{1}' is not a dictionary type.
+    /// </summary>
+    internal static string SettingRuleValueIsNotDictionaryType {
+        get {
+            return ResourceManager.GetString("SettingRuleValueIsNotDictionaryType", resourceCulture);
         }
-        
-        /// <summary>
-        ///   Looks up a localized string similar to Ignoring &apos;TypeNotFound&apos; parse error on type &apos;{0}&apos;. Check if the specified type is correct. This can also be due the type not being known at parse time due to types imported by &apos;using&apos; statements..
-        /// </summary>
-        internal static string TypeNotFoundParseErrorFound {
-            get {
-                return ResourceManager.GetString("TypeNotFoundParseErrorFound", resourceCulture);
-            }
+    }
+
+    /// <summary>
+    ///   Looks up a localized string similar to A setting 'Rules', rule '{0}', argument key is null.
+    /// </summary>
+    internal static string SettingRuleArgumentKeyIsNull {
+        get {
+            return ResourceManager.GetString("SettingRuleArgumentKeyIsNull", resourceCulture);
         }
-        
-        /// <summary>
-        ///   Looks up a localized string similar to Analyzing file: {0}.
-        /// </summary>
-        internal static string VerboseFileMessage {
-            get {
-                return ResourceManager.GetString("VerboseFileMessage", resourceCulture);
-            }
+    }
+
+    /// <summary>
+    ///   Looks up a localized string similar to The setting 'Rules', rule '{0}', argument key '{1}' is not a string type.
+    /// </summary>
+    internal static string SettingRuleArgumentKeyIsNotStringType {
+        get {
+            return ResourceManager.GetString("SettingRuleArgumentKeyIsNotStringType", resourceCulture);
         }
-        
-        /// <summary>
-        ///   Looks up a localized string similar to Running {0} rule..
-        /// </summary>
-        internal static string VerboseRunningMessage {
-            get {
-                return ResourceManager.GetString("VerboseRunningMessage", resourceCulture);
-            }
+    }
+
+    /// <summary>
+    ///   Looks up a localized string similar to The setting 'Rules', rule '{0}', argument key '{1}' is not unique, ignoring case.
+    /// </summary>
+    internal static string SettingRuleArgumentKeyIsNotUniqueIgnoringCase {
+        get {
+            return ResourceManager.GetString("SettingRuleArgumentKeyIsNotUniqueIgnoringCase", resourceCulture);
         }
-        
-        /// <summary>
-        ///   Looks up a localized string similar to Analyzing Script Definition..
-        /// </summary>
-        internal static string VerboseScriptDefinitionMessage {
-            get {
-                return ResourceManager.GetString("VerboseScriptDefinitionMessage", resourceCulture);
-            }
+    }
+
+    /// <summary>
+    ///   Looks up a localized string similar to The setting 'Rules', rule '{0}', argument '{1}' value is null.
+    /// </summary>
+    internal static string SettingRuleArgumentValueIsNull {
+        get {
+            return ResourceManager.GetString("SettingRuleArgumentValueIsNull", resourceCulture);
         }
-        
-        /// <summary>
-        ///   Looks up a localized string similar to WrongSettingsKey.
-        /// </summary>
-        internal static string WrongConfigurationKey {
-            get {
-                return ResourceManager.GetString("WrongConfigurationKey", resourceCulture);
-            }
+    }
+
+    /// <summary>
+    ///   Looks up a localized string similar to Dictionary should be indexable in a case-insensitive manner.
+    /// </summary>
+    internal static string SettingsDictionaryShouldBeCaseInsesitive {
+        get {
+            return ResourceManager.GetString("SettingsDictionaryShouldBeCaseInsesitive", resourceCulture);
         }
-        
-        /// <summary>
-        ///   Looks up a localized string similar to {0} is not a valid key in the settings hashtable: file {3}. Valid keys are ExcludeRules, IncludeRules and Severity..
-        /// </summary>
-        internal static string WrongKey {
-            get {
-                return ResourceManager.GetString("WrongKey", resourceCulture);
-            }
+    }
+
+    /// <summary>
+    ///   Looks up a localized string similar to Settings should be either a file path, built-in preset or a hashtable.
+    /// </summary>
+    internal static string SettingsInvalidType {
+        get {
+            return ResourceManager.GetString("SettingsInvalidType", resourceCulture);
         }
-        
-        /// <summary>
-        ///   Looks up a localized string similar to Key in the settings hashtable should be a string: line {0} column {1} in file {2}.
-        /// </summary>
-        internal static string WrongKeyFormat {
-            get {
-                return ResourceManager.GetString("WrongKeyFormat", resourceCulture);
-            }
+    }
+
+    /// <summary>
+    ///   Looks up a localized string similar to Settings not provided. Will look for settings file in the given path {0}.
+    /// </summary>
+    internal static string SettingsNotProvided {
+        get {
+            return ResourceManager.GetString("SettingsNotProvided", resourceCulture);
         }
-        
-        /// <summary>
-        ///   Looks up a localized string similar to {0} is not a valid key in the settings hashtable. Valid keys are CustomRulePath, ExcludeRules, IncludeRules, IncludeDefaultRules, RecurseCustomRulePath, Rules and Severity..
-        /// </summary>
-        internal static string WrongKeyHashTable {
-            get {
-                return ResourceManager.GetString("WrongKeyHashTable", resourceCulture);
-            }
+    }
+
+    /// <summary>
+    ///   Looks up a localized string similar to Found {0}. Will use it to provide settings for this invocation.
+    /// </summary>
+    internal static string SettingsAutoDiscovered {
+        get {
+            return ResourceManager.GetString("SettingsAutoDiscovered", resourceCulture);
         }
-        
-        /// <summary>
-        ///   Looks up a localized string similar to Scope can only be either function or class..
-        /// </summary>
-        internal static string WrongScopeArgumentSuppressionAttributeError {
-            get {
-                return ResourceManager.GetString("WrongScopeArgumentSuppressionAttributeError", resourceCulture);
-            }
+    }
+
+    /// <summary>
+    ///   Looks up a localized string similar to Using settings file at {0}.
+    /// </summary>
+    internal static string SettingsUsingFile {
+        get {
+            return ResourceManager.GetString("SettingsUsingFile", resourceCulture);
         }
-        
-        /// <summary>
-        ///   Looks up a localized string similar to Value in the settings hashtable should be a string or an array of strings: line {0} column {1} in file {2}.
-        /// </summary>
-        internal static string WrongValueFormat {
-            get {
-                return ResourceManager.GetString("WrongValueFormat", resourceCulture);
-            }
+    }
+
+    /// <summary>
+    ///   Looks up a localized string similar to Using settings hashtable.
+    /// </summary>
+    internal static string SettingsUsingHashtable {
+        get {
+            return ResourceManager.GetString("SettingsUsingHashtable", resourceCulture);
         }
-        
-        /// <summary>
-        ///   Looks up a localized string similar to Value {0} for key {1} has the wrong data type..
-        /// </summary>
-        internal static string WrongValueHashTable {
-            get {
-                return ResourceManager.GetString("WrongValueHashTable", resourceCulture);
-            }
+    }
+
+    /// <summary>
+    ///   Looks up a localized string similar to Cannot resolve settings file path '{0}'.
+    /// </summary>
+    internal static string SettingsCannotFindFile {
+        get {
+            return ResourceManager.GetString("SettingsCannotFindFile", resourceCulture);
+        }
+    }
+
+    /// <summary>
+    ///   Looks up a localized string similar to Cannot parse settings. Will abort the invocation.
+    /// </summary>
+    internal static string SettingsNotParsable {
+        get {
+            return ResourceManager.GetString("SettingsNotParsable", resourceCulture);
+        }
+    }
+
+    /// <summary>
+    ///   Looks up a localized string similar to {0} property must be of type bool.
+    /// </summary>
+    internal static string SettingsValueTypeMustBeBool {
+        get {
+            return ResourceManager.GetString("SettingsValueTypeMustBeBool", resourceCulture);
         }
     }
+
+    /// <summary>
+    ///   Looks up a localized string similar to Temporary module location: {0}.
+    /// </summary>
+    internal static string ModuleDepHandlerTempLocation {
+        get {
+            return ResourceManager.GetString("ModuleDepHandlerTempLocation", resourceCulture);
+        }
+    }
+
+    /// <summary>
+    ///   Looks up a localized string similar to Vertex {0} already exists! Cannot add it to the digraph.
+    /// </summary>
+    internal static string DigraphVertexAlreadyExists {
+        get {
+            return ResourceManager.GetString("DigraphVertexAlreadyExists", resourceCulture);
+        }
+    }
+
+    /// <summary>
+    ///   Looks up a localized string similar to Edge from {0} to {1} already exists.
+    /// </summary>
+    internal static string DigraphEdgeAlreadyExists {
+        get {
+            return ResourceManager.GetString("DigraphEdgeAlreadyExists", resourceCulture);
+        }
+    }
+
+    /// <summary>
+    ///   Looks up a localized string similar to Vertex {0} does not exist in the digraph.
+    /// </summary>
+    internal static string DigraphVertexDoesNotExists {
+        get {
+            return ResourceManager.GetString("DigraphVertexDoesNotExists", resourceCulture);
+        }
+    }
+
+    /// <summary>
+    ///   Looks up a localized string similar to "Cannot find a ConfigurableRuleProperty attribute on property {0}".
+    /// </summary>
+    internal static string ConfigurableScriptRulePropertyHasNotAttribute {
+        get {
+            return ResourceManager.GetString("ConfigurableScriptRulePropertyHasNotAttribute", resourceCulture);
+        }
+    }
+
+    /// <summary>
+    ///   Looks up a localized string similar to "Argument should not be null.".
+    /// </summary>
+    internal static string ConfigurableScriptRuleNRE {
+        get {
+            return ResourceManager.GetString("ConfigurableScriptRuleNRE", resourceCulture);
+        }
+    }
+
+    /// <summary>
+    ///   Looks up a localized string similar to Line element cannot be null.
+    /// </summary>
+    internal static string TextLinesNoNullItem {
+        get {
+            return ResourceManager.GetString("TextLinesNoNullItem", resourceCulture);
+        }
+    }
+
+    /// <summary>
+    ///   Looks up a localized string similar to Line element cannot be null.
+    /// </summary>
+    internal static string TextEditNoNullItem {
+        get {
+            return ResourceManager.GetString("TextEditNoNullItem", resourceCulture);
+        }
+    }
+
+    /// <summary>
+    ///   Looks up a localized string similar to TextEdit extent not completely contained in EditableText.
+    /// </summary>
+    internal static string EditableTextRangeIsNotContained {
+        get {
+            return ResourceManager.GetString("EditableTextRangeIsNotContained", resourceCulture);
+        }
+    }
+
+    /// <summary>
+    ///   Looks up a localized string similar to Cannot determine line endings as the text probably contain mixed line endings.
+    /// </summary>
+    internal static string EditableTextInvalidLineEnding {
+        get {
+            return ResourceManager.GetString("EditableTextInvalidLineEnding", resourceCulture);
+        }
+    }
+
+    /// <summary>
+    ///   Looks up a localized string similar to Start position cannot be before End position.
+    /// </summary>
+    internal static string RangeStartPosGreaterThanEndPos {
+        get {
+            return ResourceManager.GetString("RangeStartPosGreaterThanEndPos", resourceCulture);
+        }
+    }
+
+    /// <summary>
+    ///   Looks up a localized string similar to Reference Position should begin before start Position of Range.
+    /// </summary>
+    internal static string RangeRefPosShouldStartBeforeRangeStartPos {
+        get {
+            return ResourceManager.GetString("RangeRefPosShouldStartBeforeRangeStartPos", resourceCulture);
+        }
+    }
+
+    /// <summary>
+    ///   Looks up a localized string similar to Line number cannot be less than 1.
+    /// </summary>
+    internal static string PositionLineLessThanOne {
+        get {
+            return ResourceManager.GetString("PositionLineLessThanOne", resourceCulture);
+        }
+    }
+
+    /// <summary>
+    ///   Looks up a localized string similar to Column number cannot be less than 1.
+    /// </summary>
+    internal static string PositionColumnLessThanOne {
+        get {
+            return ResourceManager.GetString("PositionColumnLessThanOne", resourceCulture);
+        }
+    }
+
+    /// <summary>
+    ///   Looks up a localized string similar to Input position should be less than that of the invoking object.
+    /// </summary>
+    internal static string PositionRefPosLessThanInputPos {
+        get {
+            return ResourceManager.GetString("PositionRefPosLessThanInputPos", resourceCulture);
+        }
+    }
+
+    /// <summary>
+    ///   Looks up a localized string similar to Settings object could not be resolved.
+    /// </summary>
+    internal static string SettingsObjectCouldNotBResolved {
+        get {
+            return ResourceManager.GetString("SettingsObjectCouldNotBResolved", resourceCulture);
+        }
+    }
+
+    /// <summary>
+    ///   Looks up a localized string similar to Ignoring 'TypeNotFound' parse error on type '{0}'. Check if the specified type is correct. This can also be due the type not being known at parse time due to types imported by 'using' statements.
+    /// </summary>
+    internal static string TypeNotFoundParseErrorFound {
+        get {
+            return ResourceManager.GetString("TypeNotFoundParseErrorFound", resourceCulture);
+        }
+    }
+
+}
 }
diff --git a/Engine/Strings.resx b/Engine/Strings.resx
index 346a25aa6..bf829f8b4 100644
--- a/Engine/Strings.resx
+++ b/Engine/Strings.resx
@@ -246,6 +246,62 @@
   <data name="SettingsInputShouldBeDictionary" xml:space="preserve">
     <value>Input should be a dictionary type.</value>
   </data>
+
+  <data name="SettingKeyIsNull" xml:space="preserve">
+    <value>A setting key is null.</value>
+  </data>
+  <data name="SettingKeyIsNotStringType" xml:space="preserve">
+    <value>The setting key '{0}' is not a string type.</value>
+  </data>
+  <data name="SettingKeyIsNotUniqueIgnoringCase" xml:space="preserve">
+    <value>The setting key '{0}' is not unique, ignoring case.</value>
+  </data>
+  <data name="SettingValueIsNull" xml:space="preserve">
+    <value>The setting '{0}' value is null.</value>
+  </data>
+  <data name="SettingValueIsNotBooleanType" xml:space="preserve">
+    <value>The setting '{0}' value '{1}' is not a boolean type.</value>
+  </data>
+  <data name="SettingValueIsNotStringOrStringsType" xml:space="preserve">
+    <value>The setting '{0}' value '{1}' is not a string or collection of strings type.</value>
+  </data>
+  <data name="SettingValueElementIsNull" xml:space="preserve">
+    <value>The setting '{0}', index {1} element is null.</value>
+  </data>
+  <data name="SettingValueElementIsNotStringType" xml:space="preserve">
+    <value>The setting '{0}', index {1} element, value '{2}' is not a string type.</value>
+  </data>
+  <data name="SettingRulesValueIsNotDictionaryType" xml:space="preserve">
+    <value>The setting 'Rules' value '{0}' is not a dictionary type.</value>
+  </data>
+  <data name="SettingRuleKeyIsNull" xml:space="preserve">
+    <value>A setting 'Rules', rule key is null.</value>
+  </data>
+  <data name="SettingRuleKeyIsNotStringType" xml:space="preserve">
+    <value>The setting 'Rules', rule key '{0}' is not a string type.</value>
+  </data>
+  <data name="SettingRuleKeyIsNotUniqueIgnoringCase" xml:space="preserve">
+    <value>The setting 'Rules', rule key '{0}' is not unique, ignoring case.</value>
+  </data>
+  <data name="SettingRuleValueIsNull" xml:space="preserve">
+    <value>The setting 'Rules', rule '{0}' value is null.</value>
+  </data>
+  <data name="SettingRuleValueIsNotDictionaryType" xml:space="preserve">
+    <value>The setting 'Rules', rule '{0}' value '{1}' is not a dictionary type.</value>
+  </data>
+  <data name="SettingRuleArgumentKeyIsNull" xml:space="preserve">
+    <value>A setting 'Rules', rule '{0}', argument key is null.</value>
+  </data>
+  <data name="SettingRuleArgumentKeyIsNotStringType" xml:space="preserve">
+    <value>The setting 'Rules', rule '{0}', argument key '{1}' is not a string type.</value>
+  </data>
+  <data name="SettingRuleArgumentKeyIsNotUniqueIgnoringCase" xml:space="preserve">
+    <value>The setting 'Rules', rule '{0}', argument key '{1}' is not unique, ignoring case.</value>
+  </data>
+  <data name="SettingRuleArgumentValueIsNull" xml:space="preserve">
+    <value>The setting 'Rules', rule '{0}', argument '{1}' value is null.</value>
+  </data>
+
   <data name="SettingsDictionaryShouldBeCaseInsesitive" xml:space="preserve">
     <value>Dictionary should be indexable in a case-insensitive manner.</value>
   </data>