diff --git a/Engine/ScriptAnalyzerEngine.csproj b/Engine/ScriptAnalyzerEngine.csproj
index f684df39c..395f74307 100644
--- a/Engine/ScriptAnalyzerEngine.csproj
+++ b/Engine/ScriptAnalyzerEngine.csproj
@@ -78,9 +78,6 @@
     <Compile Include="VariableAnalysis.cs" />
     <Compile Include="VariableAnalysisBase.cs" />
   </ItemGroup>
-  <ItemGroup>
-    <Content Include="Microsoft.Windows.Powershell.ScriptAnalyzer.dll-Help.xml" />
-  </ItemGroup>
   <ItemGroup>
     <None Include="PSScriptAnalyzer.psd1" />
     <None Include="ScriptAnalyzer.format.ps1xml" />
diff --git a/Rules/AvoidShouldContinueWithoutForce.cs b/Rules/AvoidShouldContinueWithoutForce.cs
new file mode 100644
index 000000000..e7a956a54
--- /dev/null
+++ b/Rules/AvoidShouldContinueWithoutForce.cs
@@ -0,0 +1,118 @@
+using System;
+using System.Collections.ObjectModel;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using System.Management.Automation;
+using System.Management.Automation.Language;
+using Microsoft.Windows.Powershell.ScriptAnalyzer.Generic;
+using System.ComponentModel.Composition;
+using System.Resources;
+using System.Globalization;
+using System.Threading;
+using System.Reflection;
+
+namespace Microsoft.Windows.Powershell.ScriptAnalyzer.BuiltinRules
+{
+    /// <summary>
+    /// AvoidShouldContinueWithoutForceParameter: Check that if ShouldContinue is used,
+    /// the function should have a boolean force parameter
+    /// </summary>
+    [Export(typeof(IScriptRule))]
+    public class AvoidShouldContinueWithoutForce : IScriptRule
+    {
+        /// <summary>
+        /// AvoidShouldContinueWithoutForceCheck that if ShouldContinue is used,
+        /// the function should have a boolean force parameter
+        /// </summary>
+        public IEnumerable<DiagnosticRecord> AnalyzeScript(Ast ast, string fileName)
+        {
+            if (ast == null) throw new ArgumentNullException(Strings.NullAstErrorMessage);
+
+            // Finds all ParamAsts.
+            IEnumerable<Ast> funcAsts = ast.FindAll(testAst => testAst is FunctionDefinitionAst, true);
+
+            // Iterrates all ParamAsts and check if there are any force.
+            foreach (FunctionDefinitionAst funcAst in funcAsts)
+            {
+                IEnumerable<Ast> paramAsts = funcAst.FindAll(testAst => testAst is ParameterAst, true);
+                bool hasForce = false;
+
+                foreach (ParameterAst paramAst in paramAsts)
+                {
+                    if (String.Equals(paramAst.Name.VariablePath.ToString(), "force", StringComparison.OrdinalIgnoreCase)
+                        && String.Equals(paramAst.StaticType.FullName, "System.Boolean", StringComparison.OrdinalIgnoreCase))
+                    {
+                        hasForce = true;
+                        break;
+                    }
+                }
+
+                if (hasForce)
+                {
+                    continue;
+                }
+
+                IEnumerable<Ast> imeAsts = funcAst.FindAll(testAst => testAst is InvokeMemberExpressionAst, true);
+
+                foreach (InvokeMemberExpressionAst imeAst in imeAsts)
+                {
+                    VariableExpressionAst typeAst = imeAst.Expression as VariableExpressionAst;
+                    if (typeAst == null) continue;
+
+                    if (String.Equals(typeAst.VariablePath.UserPath, "pscmdlet", StringComparison.OrdinalIgnoreCase)
+                        && (String.Equals(imeAst.Member.Extent.Text, "shouldcontinue", StringComparison.OrdinalIgnoreCase)))
+                    {
+                        yield return new DiagnosticRecord(
+                            String.Format(CultureInfo.CurrentCulture, Strings.AvoidShouldContinueWithoutForceError, funcAst.Name, System.IO.Path.GetFileName(fileName)),
+                            imeAst.Extent, GetName(), DiagnosticSeverity.Warning, fileName);
+                    }
+                }
+            }
+        }
+
+        /// <summary>
+        /// GetName: Retrieves the name of this rule.
+        /// </summary>
+        /// <returns>The name of this rule</returns>
+        public string GetName()
+        {
+            return string.Format(CultureInfo.CurrentCulture, Strings.NameSpaceFormat, GetSourceName(), Strings.AvoidShouldContinueWithoutForceName);
+        }
+
+        /// <summary>
+        /// GetCommonName: Retrieves the common name of this rule.
+        /// </summary>
+        /// <returns>The common name of this rule</returns>
+        public string GetCommonName()
+        {
+            return string.Format(CultureInfo.CurrentCulture, Strings.AvoidShouldContinueWithoutForceCommonName);
+        }
+
+        /// <summary>
+        /// GetDescription: Retrieves the description of this rule.
+        /// </summary>
+        /// <returns>The description of this rule</returns>
+        public string GetDescription()
+        {
+            return string.Format(CultureInfo.CurrentCulture, Strings.AvoidShouldContinueWithoutForceDescription);
+        }
+
+        /// <summary>
+        /// GetSourceType: Retrieves the type of the rule: builtin, managed or module.
+        /// </summary>
+        public SourceType GetSourceType()
+        {
+            return SourceType.Builtin;
+        }
+
+        /// <summary>
+        /// GetSourceName: Retrieves the module/assembly name the rule is from.
+        /// </summary>
+        public string GetSourceName()
+        {
+            return string.Format(CultureInfo.CurrentCulture, Strings.SourceName);
+        }
+    }
+}
diff --git a/Rules/AvoidUserNameAndPasswordParams.cs b/Rules/AvoidUserNameAndPasswordParams.cs
index 10d6f4ef6..e3d1fc4c7 100644
--- a/Rules/AvoidUserNameAndPasswordParams.cs
+++ b/Rules/AvoidUserNameAndPasswordParams.cs
@@ -16,11 +16,11 @@
 namespace Microsoft.Windows.Powershell.ScriptAnalyzer.BuiltinRules
 {
     /// <summary>
-    /// AvoidUserNameAndPasswordParams: Check that a function does not use both username and password
+    /// AvoidUsernameAndPasswordParams: Check that a function does not use both username and password
     /// parameters.
     /// </summary>
     [Export(typeof(IScriptRule))]
-    public class AvoidUserNameAndPasswordParams : IScriptRule
+    public class AvoidUsernameAndPasswordParams : IScriptRule
     {
         /// <summary>
         /// AnalyzeScript: Check that a function does not use both username
@@ -77,8 +77,8 @@ public IEnumerable<DiagnosticRecord> AnalyzeScript(Ast ast, string fileName)
                 if (hasUserName && hasPwd)
                 {
                     yield return new DiagnosticRecord(
-                        String.Format(CultureInfo.CurrentCulture, Strings.AvoidUserNameAndPasswordParamsError, funcAst.Name),
-                        funcAst.Extent, GetName(), DiagnosticSeverity.Warning, fileName);
+                        String.Format(CultureInfo.CurrentCulture, Strings.AvoidUsernameAndPasswordParamsError, funcAst.Name),
+                        funcAst.Extent, GetName(), DiagnosticSeverity.Error, fileName);
                 }
             }
         }
@@ -89,7 +89,7 @@ public IEnumerable<DiagnosticRecord> AnalyzeScript(Ast ast, string fileName)
         /// <returns>The name of this rule</returns>
         public string GetName()
         {
-            return string.Format(CultureInfo.CurrentCulture, Strings.NameSpaceFormat, GetSourceName(), Strings.AvoidUserNameAndPasswordParamsName);
+            return string.Format(CultureInfo.CurrentCulture, Strings.NameSpaceFormat, GetSourceName(), Strings.AvoidUsernameAndPasswordParamsName);
         }
 
         /// <summary>
@@ -98,7 +98,7 @@ public string GetName()
         /// <returns>The common name of this rule</returns>
         public string GetCommonName()
         {
-            return string.Format(CultureInfo.CurrentCulture, Strings.AvoidUserNameAndPasswordParamsCommonName);
+            return string.Format(CultureInfo.CurrentCulture, Strings.AvoidUsernameAndPasswordParamsCommonName);
         }
 
         /// <summary>
@@ -107,7 +107,7 @@ public string GetCommonName()
         /// <returns>The description of this rule</returns>
         public string GetDescription()
         {
-            return string.Format(CultureInfo.CurrentCulture, Strings.AvoidUserNameAndPasswordParamsDescription);
+            return string.Format(CultureInfo.CurrentCulture, Strings.AvoidUsernameAndPasswordParamsDescription);
         }
 
         /// <summary>
diff --git a/Rules/ScriptAnalyzerBuiltinRules.csproj b/Rules/ScriptAnalyzerBuiltinRules.csproj
index bb3955792..e1e90d498 100644
--- a/Rules/ScriptAnalyzerBuiltinRules.csproj
+++ b/Rules/ScriptAnalyzerBuiltinRules.csproj
@@ -58,7 +58,7 @@
     <Compile Include="AvoidPositionalParameters.cs" />
     <Compile Include="AvoidReservedCharInCmdlet.cs" />
     <Compile Include="AvoidReservedParams.cs" />
-    <Compile Include="AvoidShouldContinueShouldProcessWithoutForce.cs" />
+    <Compile Include="AvoidShouldContinueWithoutForce.cs" />
     <Compile Include="AvoidTrapStatement.cs" />
     <Compile Include="AvoidUnitializedVariable.cs" />
     <Compile Include="AvoidUserNameAndPasswordParams.cs" />
@@ -73,6 +73,11 @@
     <Compile Include="PossibleIncorrectComparisonWithNull.cs" />
     <Compile Include="ProvideCommentHelp.cs" />
     <Compile Include="ProvideVerboseMessage.cs" />
+    <Compile Include="Strings.Designer.cs">
+      <AutoGen>True</AutoGen>
+      <DesignTime>True</DesignTime>
+      <DependentUpon>Strings.resx</DependentUpon>
+    </Compile>
     <Compile Include="UseApprovedVerbs.cs" />
     <Compile Include="UseCmdletCorrectly.cs" />
     <Compile Include="UseDeclaredVarsMoreThanAssignments.cs" />
@@ -82,17 +87,12 @@
     <Compile Include="UseShouldProcessCorrectly.cs" />
     <Compile Include="UseSingularNouns.cs" />
     <Compile Include="UseStandardDSCFunctionsInResource.cs" />
-    <Compile Include="Strings.cs">
-      <AutoGen>True</AutoGen>
-      <DesignTime>True</DesignTime>
-      <DependentUpon>Strings.resx</DependentUpon>
-    </Compile>
   </ItemGroup>
   <ItemGroup>
     <EmbeddedResource Include="Strings.resx">
       <SubType>Designer</SubType>
       <Generator>ResXFileCodeGenerator</Generator>
-      <LastGenOutput>Strings.cs</LastGenOutput>
+      <LastGenOutput>Strings.Designer.cs</LastGenOutput>
     </EmbeddedResource>
   </ItemGroup>
   <ItemGroup>
diff --git a/Rules/Strings.cs b/Rules/Strings.Designer.cs
similarity index 96%
rename from Rules/Strings.cs
rename to Rules/Strings.Designer.cs
index 6c18a9ec1..ebccf485e 100644
--- a/Rules/Strings.cs
+++ b/Rules/Strings.Designer.cs
@@ -214,38 +214,38 @@ internal static string AvoidInvokingEmptyMembersName {
         }
         
         /// <summary>
-        ///   Looks up a localized string similar to Avoid Using ShouldContinue Or ShouldProcess Without Boolean Force Parameter.
+        ///   Looks up a localized string similar to Avoid Using ShouldContinue Without Boolean Force Parameter.
         /// </summary>
-        internal static string AvoidShouldContinueShouldProcessWithoutForceCommonName {
+        internal static string AvoidShouldContinueWithoutForceCommonName {
             get {
-                return ResourceManager.GetString("AvoidShouldContinueShouldProcessWithoutForceCommonName", resourceCulture);
+                return ResourceManager.GetString("AvoidShouldContinueWithoutForceCommonName", resourceCulture);
             }
         }
         
         /// <summary>
-        ///   Looks up a localized string similar to Functions that use ShouldContinue or ShouldProcess should have a boolean force parameter to allow user to bypass it..
+        ///   Looks up a localized string similar to Functions that use ShouldContinue should have a boolean force parameter to allow user to bypass it..
         /// </summary>
-        internal static string AvoidShouldContinueShouldProcessWithoutForceDescription {
+        internal static string AvoidShouldContinueWithoutForceDescription {
             get {
-                return ResourceManager.GetString("AvoidShouldContinueShouldProcessWithoutForceDescription", resourceCulture);
+                return ResourceManager.GetString("AvoidShouldContinueWithoutForceDescription", resourceCulture);
             }
         }
         
         /// <summary>
-        ///   Looks up a localized string similar to Function &apos;{0}&apos; in file &apos;{1}&apos; uses ShouldContinue or ShouldProcess but does not have a boolean force parameter. The force parameter will allow users of the script to bypass ShouldContinue prompt.
+        ///   Looks up a localized string similar to Function &apos;{0}&apos; in file &apos;{1}&apos; uses ShouldContinue but does not have a boolean force parameter. The force parameter will allow users of the script to bypass ShouldContinue prompt.
         /// </summary>
-        internal static string AvoidShouldContinueShouldProcessWithoutForceError {
+        internal static string AvoidShouldContinueWithoutForceError {
             get {
-                return ResourceManager.GetString("AvoidShouldContinueShouldProcessWithoutForceError", resourceCulture);
+                return ResourceManager.GetString("AvoidShouldContinueWithoutForceError", resourceCulture);
             }
         }
         
         /// <summary>
-        ///   Looks up a localized string similar to AvoidShouldContinueShouldProcessWithoutForce.
+        ///   Looks up a localized string similar to AvoidShouldContinueWithoutForce.
         /// </summary>
-        internal static string AvoidShouldContinueShouldProcessWithoutForceName {
+        internal static string AvoidShouldContinueWithoutForceName {
             get {
-                return ResourceManager.GetString("AvoidShouldContinueShouldProcessWithoutForceName", resourceCulture);
+                return ResourceManager.GetString("AvoidShouldContinueWithoutForceName", resourceCulture);
             }
         }
         
@@ -360,36 +360,36 @@ internal static string AvoidUnloadableModuleName {
         /// <summary>
         ///   Looks up a localized string similar to Avoid Using Username and Password Parameters.
         /// </summary>
-        internal static string AvoidUserNameAndPasswordParamsCommonName {
+        internal static string AvoidUsernameAndPasswordParamsCommonName {
             get {
-                return ResourceManager.GetString("AvoidUserNameAndPasswordParamsCommonName", resourceCulture);
+                return ResourceManager.GetString("AvoidUsernameAndPasswordParamsCommonName", resourceCulture);
             }
         }
         
         /// <summary>
         ///   Looks up a localized string similar to Functions should only take in a credential parameter of type PSCredential instead of username and password parameters..
         /// </summary>
-        internal static string AvoidUserNameAndPasswordParamsDescription {
+        internal static string AvoidUsernameAndPasswordParamsDescription {
             get {
-                return ResourceManager.GetString("AvoidUserNameAndPasswordParamsDescription", resourceCulture);
+                return ResourceManager.GetString("AvoidUsernameAndPasswordParamsDescription", resourceCulture);
             }
         }
         
         /// <summary>
         ///   Looks up a localized string similar to Function &apos;{0}&apos; has both username and password parameters. A credential parameter of type PSCredential should be used..
         /// </summary>
-        internal static string AvoidUserNameAndPasswordParamsError {
+        internal static string AvoidUsernameAndPasswordParamsError {
             get {
-                return ResourceManager.GetString("AvoidUserNameAndPasswordParamsError", resourceCulture);
+                return ResourceManager.GetString("AvoidUsernameAndPasswordParamsError", resourceCulture);
             }
         }
         
         /// <summary>
         ///   Looks up a localized string similar to AvoidUsingUserNameAndPassWordParams.
         /// </summary>
-        internal static string AvoidUserNameAndPasswordParamsName {
+        internal static string AvoidUsernameAndPasswordParamsName {
             get {
-                return ResourceManager.GetString("AvoidUserNameAndPasswordParamsName", resourceCulture);
+                return ResourceManager.GetString("AvoidUsernameAndPasswordParamsName", resourceCulture);
             }
         }
         
@@ -1357,82 +1357,74 @@ internal static string UseDeclaredVarsMoreThanAssignmentsName {
         }
         
         /// <summary>
-        ///   Looks up a localized string similar to Use Identical Parameters For DSC Test and Set Functions.
+        ///   Looks up a localized string similar to Use identical mandatory parameters for DSC Get/Test/Set TargetResource functions.
         /// </summary>
-        internal static string UseIdenticalParametersDSCCommonName {
+        internal static string UseIdenticalMandatoryParametersDSCCommonName {
             get {
-                return ResourceManager.GetString("UseIdenticalParametersDSCCommonName", resourceCulture);
+                return ResourceManager.GetString("UseIdenticalMandatoryParametersDSCCommonName", resourceCulture);
             }
         }
         
         /// <summary>
-        ///   Looks up a localized string similar to The Test and Set-TargetResource functions of DSC Resource must have the same parameters..
+        ///   Looks up a localized string similar to The Get/Test/Set TargetResource functions of DSC resource must have the same mandatory parameters..
         /// </summary>
-        internal static string UseIdenticalParametersDSCDescription {
+        internal static string UseIdenticalMandatoryParametersDSCDescription {
             get {
-                return ResourceManager.GetString("UseIdenticalParametersDSCDescription", resourceCulture);
+                return ResourceManager.GetString("UseIdenticalMandatoryParametersDSCDescription", resourceCulture);
             }
         }
         
         /// <summary>
-        ///   Looks up a localized string similar to The Test and Set-TargetResource functions of DSC Resource must have the same parameters..
+        ///   Looks up a localized string similar to The mandatory parameter &apos;{0}&apos; is not present in &apos;{1}&apos; DSC resource function(s)..
         /// </summary>
-        internal static string UseIdenticalParametersDSCError {
+        internal static string UseIdenticalMandatoryParametersDSCError {
             get {
-                return ResourceManager.GetString("UseIdenticalParametersDSCError", resourceCulture);
+                return ResourceManager.GetString("UseIdenticalMandatoryParametersDSCError", resourceCulture);
             }
         }
         
         /// <summary>
-        ///   Looks up a localized string similar to UseIdenticalParametersForDSC.
+        ///   Looks up a localized string similar to UseIdenticalMandatoryParametersForDSC.
         /// </summary>
-        internal static string UseIdenticalParametersDSCName {
+        internal static string UseIdenticalMandatoryParametersDSCName {
             get {
-                return ResourceManager.GetString("UseIdenticalParametersDSCName", resourceCulture);
+                return ResourceManager.GetString("UseIdenticalMandatoryParametersDSCName", resourceCulture);
             }
         }
-
+        
         /// <summary>
-        ///   Looks up a localized string similar to the Get/Test/Set TargetResource functions of DSC Resource must have the mandatory same parameters.
+        ///   Looks up a localized string similar to Use Identical Parameters For DSC Test and Set Functions.
         /// </summary>
-        internal static string UseIdenticalMandatoryParametersDSCCommonName
-        {
-            get
-            {
-                return ResourceManager.GetString("UseIdenticalMandatoryParametersDSCCommonName", resourceCulture);
+        internal static string UseIdenticalParametersDSCCommonName {
+            get {
+                return ResourceManager.GetString("UseIdenticalParametersDSCCommonName", resourceCulture);
             }
         }
-
+        
         /// <summary>
-        ///   Looks up a localized string similar to the Get/Test/Set TargetResource functions of DSC Resource must have the mandatory same parameters.
+        ///   Looks up a localized string similar to The Test and Set-TargetResource functions of DSC Resource must have the same parameters..
         /// </summary>
-        internal static string UseIdenticalMandatoryParametersDSCDescription
-        {
-            get
-            {
-                return ResourceManager.GetString("UseIdenticalMandatoryParametersDSCDescription", resourceCulture);
+        internal static string UseIdenticalParametersDSCDescription {
+            get {
+                return ResourceManager.GetString("UseIdenticalParametersDSCDescription", resourceCulture);
             }
         }
-
+        
         /// <summary>
-        ///   Looks up a localized string similar to the Get/Test/Set TargetResource functions of DSC Resource must have the mandatory same parameters.
+        ///   Looks up a localized string similar to The Test and Set-TargetResource functions of DSC Resource must have the same parameters..
         /// </summary>
-        internal static string UseIdenticalMandatoryParametersDSCError
-        {
-            get
-            {
-                return ResourceManager.GetString("UseIdenticalMandatoryParametersDSCError", resourceCulture);
+        internal static string UseIdenticalParametersDSCError {
+            get {
+                return ResourceManager.GetString("UseIdenticalParametersDSCError", resourceCulture);
             }
         }
-
+        
         /// <summary>
-        ///   Looks up a localized string similar to UseIdenticalMandatoryParametersForDSC.
+        ///   Looks up a localized string similar to UseIdenticalParametersForDSC.
         /// </summary>
-        internal static string UseIdenticalMandatoryParametersDSCName
-        {
-            get
-            {
-                return ResourceManager.GetString("UseIdenticalMandatoryParametersDSCName", resourceCulture);
+        internal static string UseIdenticalParametersDSCName {
+            get {
+                return ResourceManager.GetString("UseIdenticalParametersDSCName", resourceCulture);
             }
         }
         
diff --git a/Rules/Strings.resx b/Rules/Strings.resx
index c172d193d..3f4cf7072 100644
--- a/Rules/Strings.resx
+++ b/Rules/Strings.resx
@@ -342,14 +342,14 @@
   <data name="AvoidDefaultValueSwitchParameterCommonName" xml:space="preserve">
     <value>Switch Parameters Should Not Default To True</value>
   </data>
-  <data name="AvoidShouldContinueShouldProcessWithoutForceDescription" xml:space="preserve">
-    <value>Functions that use ShouldContinue or ShouldProcess should have a boolean force parameter to allow user to bypass it.</value>
+  <data name="AvoidShouldContinueWithoutForceDescription" xml:space="preserve">
+    <value>Functions that use ShouldContinue should have a boolean force parameter to allow user to bypass it.</value>
   </data>
-  <data name="AvoidShouldContinueShouldProcessWithoutForceError" xml:space="preserve">
-    <value>Function '{0}' in file '{1}' uses ShouldContinue or ShouldProcess but does not have a boolean force parameter. The force parameter will allow users of the script to bypass ShouldContinue prompt</value>
+  <data name="AvoidShouldContinueWithoutForceError" xml:space="preserve">
+    <value>Function '{0}' in file '{1}' uses ShouldContinue but does not have a boolean force parameter. The force parameter will allow users of the script to bypass ShouldContinue prompt</value>
   </data>
-  <data name="AvoidShouldContinueShouldProcessWithoutForceCommonName" xml:space="preserve">
-    <value>Avoid Using ShouldContinue Or ShouldProcess Without Boolean Force Parameter</value>
+  <data name="AvoidShouldContinueWithoutForceCommonName" xml:space="preserve">
+    <value>Avoid Using ShouldContinue Without Boolean Force Parameter</value>
   </data>
   <data name="AvoidUsingClearHostDescription" xml:space="preserve">
     <value>Using Clear-Host is not recommended because the cmdlet may not work in some hosts or there may even be no hosts at all.</value>
@@ -390,8 +390,8 @@
   <data name="AvoidGlobalVarsName" xml:space="preserve">
     <value>AvoidGlobalVars</value>
   </data>
-  <data name="AvoidShouldContinueShouldProcessWithoutForceName" xml:space="preserve">
-    <value>AvoidShouldContinueShouldProcessWithoutForce</value>
+  <data name="AvoidShouldContinueWithoutForceName" xml:space="preserve">
+    <value>AvoidShouldContinueWithoutForce</value>
   </data>
   <data name="AvoidTrapStatementName" xml:space="preserve">
     <value>AvoidTrapStatement</value>
@@ -510,16 +510,16 @@
   <data name="UseTypeAtVariableAssignmentName" xml:space="preserve">
     <value>UseTypeAtVariableAssignment</value>
   </data>
-  <data name="AvoidUserNameAndPasswordParamsCommonName" xml:space="preserve">
+  <data name="AvoidUsernameAndPasswordParamsCommonName" xml:space="preserve">
     <value>Avoid Using Username and Password Parameters</value>
   </data>
-  <data name="AvoidUserNameAndPasswordParamsDescription" xml:space="preserve">
+  <data name="AvoidUsernameAndPasswordParamsDescription" xml:space="preserve">
     <value>Functions should only take in a credential parameter of type PSCredential instead of username and password parameters.</value>
   </data>
-  <data name="AvoidUserNameAndPasswordParamsError" xml:space="preserve">
+  <data name="AvoidUsernameAndPasswordParamsError" xml:space="preserve">
     <value>Function '{0}' has both username and password parameters. A credential parameter of type PSCredential should be used.</value>
   </data>
-  <data name="AvoidUserNameAndPasswordParamsName" xml:space="preserve">
+  <data name="AvoidUsernameAndPasswordParamsName" xml:space="preserve">
     <value>AvoidUsingUserNameAndPassWordParams</value>
   </data>
   <data name="AvoidInvokingEmptyMembersCommonName" xml:space="preserve">