Revert "remove depracated validation rule"

This reverts commit 9bf3f08.

Author: MaggieKimani1

src/Microsoft.OpenApi/Validations/Rules/OpenApiHeaderRules.cs

@@ -0,0 +1,57 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT license.
+
+using Microsoft.OpenApi.Models;
+
+namespace Microsoft.OpenApi.Validations.Rules
+{
+    /// <summary>
+    /// The validation rules for <see cref="OpenApiHeader"/>.
+    /// </summary>
+    //Removed from Default Rules as this is not a MUST in OpenAPI
+    [OpenApiRule]
+    public static class OpenApiHeaderRules
+    {
+        /// <summary>
+        /// Validate the data matches with the given data type.
+        /// </summary>
+        public static ValidationRule<OpenApiHeader> HeaderMismatchedDataType =>
+            new(nameof(HeaderMismatchedDataType),
+                (context, header) =>
+                {
+                    // example
+                    context.Enter("example");
+
+                    if (header.Example != null)
+                    {
+                        RuleHelpers.ValidateDataTypeMismatch(context, 
+                            nameof(HeaderMismatchedDataType), header.Example, header.Schema);
+                    }
+
+                    context.Exit();
+
+                    // examples
+                    context.Enter("examples");
+
+                    if (header.Examples != null)
+                    {
+                        foreach (var key in header.Examples.Keys)
+                        {
+                            if (header.Examples[key] != null)
+                            {
+                                context.Enter(key);
+                                context.Enter("value");
+                                RuleHelpers.ValidateDataTypeMismatch(context, 
+                                    nameof(HeaderMismatchedDataType), header.Examples[key]?.Value, header.Schema);
+                                context.Exit();
+                                context.Exit();
+                            }
+                        }
+                    }
+
+                    context.Exit();
+                });
+
+        // add more rule.
+    }
+}

src/Microsoft.OpenApi/Validations/Rules/OpenApiMediaTypeRules.cs

@@ -0,0 +1,63 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT license.
+
+using Microsoft.OpenApi.Models;
+
+namespace Microsoft.OpenApi.Validations.Rules
+{
+    /// <summary>
+    /// The validation rules for <see cref="OpenApiMediaType"/>.
+    /// </summary>
+    /// <remarks>
+    /// Removed this in v1.3 as a default rule as the OpenAPI specification does not require that example
+    /// values validate against the schema.  Validating examples against the schema is particularly difficult
+    /// as it requires parsing of the example using the schema as a guide.  This is not possible when the schema
+    /// is referenced.  Even if we fix this issue, this rule should be treated as a warning, not an error
+    /// Future versions of the validator should make that distinction.
+    /// Future versions of the example parsers should not try an infer types.
+    /// Example validation should be done as a separate post reading step so all schemas can be fully available.
+    /// </remarks>
+    [OpenApiRule]
+    public static class OpenApiMediaTypeRules
+    {
+        /// <summary>
+        /// Validate the data matches with the given data type.
+        /// </summary>
+        public static ValidationRule<OpenApiMediaType> MediaTypeMismatchedDataType =>
+            new(nameof(MediaTypeMismatchedDataType),
+                (context, mediaType) =>
+                {
+                    // example
+                    context.Enter("example");
+
+                    if (mediaType.Example != null)
+                    {
+                        RuleHelpers.ValidateDataTypeMismatch(context, nameof(MediaTypeMismatchedDataType), mediaType.Example, mediaType.Schema);
+                    }
+
+                    context.Exit();
+
+                    // enum
+                    context.Enter("examples");
+
+                    if (mediaType.Examples != null)
+                    {
+                        foreach (var key in mediaType.Examples.Keys)
+                        {
+                            if (mediaType.Examples[key] != null)
+                            {
+                                context.Enter(key);
+                                context.Enter("value");
+                                RuleHelpers.ValidateDataTypeMismatch(context, nameof(MediaTypeMismatchedDataType), mediaType.Examples[key]?.Value, mediaType.Schema);
+                                context.Exit();
+                                context.Exit();
+                            }
+                        }
+                    }
+
+                    context.Exit();
+                });
+
+        // add more rule.
+    }
+}

src/Microsoft.OpenApi/Validations/Rules/OpenApiParameterRules.cs

@@ -58,6 +58,45 @@ public static class OpenApiParameterRules
                     context.Exit();
                 });
 
+        /// <summary>
+        /// Validate the data matches with the given data type.
+        /// </summary>
+        public static ValidationRule<OpenApiParameter> ParameterMismatchedDataType =>
+            new(nameof(ParameterMismatchedDataType),
+                (context, parameter) =>
+                {
+                    // example
+                    context.Enter("example");
+
+                    if (parameter.Example != null)
+                    {
+                        RuleHelpers.ValidateDataTypeMismatch(context, nameof(ParameterMismatchedDataType), parameter.Example, parameter.Schema);
+                    }
+
+                    context.Exit();
+
+                    // examples
+                    context.Enter("examples");
+
+                    if (parameter.Examples != null)
+                    {
+                        foreach (var key in parameter.Examples.Keys)
+                        {
+                            if (parameter.Examples[key] != null)
+                            {
+                                context.Enter(key);
+                                context.Enter("value");
+                                RuleHelpers.ValidateDataTypeMismatch(context, 
+                                    nameof(ParameterMismatchedDataType), parameter.Examples[key]?.Value, parameter.Schema);
+                                context.Exit();
+                                context.Exit();
+                            }
+                        }
+                    }
+
+                    context.Exit();
+                });
+
         /// <summary>
         /// Validate that a path parameter should always appear in the path
         /// </summary>

src/Microsoft.OpenApi/Validations/Rules/OpenApiSchemaRules.cs

@@ -13,6 +13,49 @@ namespace Microsoft.OpenApi.Validations.Rules
     [OpenApiRule]
     public static class OpenApiSchemaRules
     {
+        /// <summary>
+        /// Validate the data matches with the given data type.
+        /// </summary>
+        public static ValidationRule<OpenApiSchema> SchemaMismatchedDataType =>
+            new(nameof(SchemaMismatchedDataType),
+                (context, schema) =>
+                {
+                    // default
+                    context.Enter("default");
+
+                    if (schema.Default != null)
+                    {
+                        RuleHelpers.ValidateDataTypeMismatch(context, nameof(SchemaMismatchedDataType), schema.Default, schema);
+                    }
+
+                    context.Exit();
+
+                    // example
+                    context.Enter("example");
+
+                    if (schema.Example != null)
+                    {
+                        RuleHelpers.ValidateDataTypeMismatch(context, nameof(SchemaMismatchedDataType), schema.Example, schema);
+                    }
+
+                    context.Exit();
+
+                    // enum
+                    context.Enter("enum");
+
+                    if (schema.Enum != null)
+                    {
+                        for (var i = 0; i < schema.Enum.Count; i++)
+                        {
+                            context.Enter(i.ToString());
+                            RuleHelpers.ValidateDataTypeMismatch(context, nameof(SchemaMismatchedDataType), schema.Enum[i], schema);
+                            context.Exit();
+                        }
+                    }
+
+                    context.Exit();
+                });
+
         /// <summary>
         /// Validates Schema Discriminator
         /// </summary>