1.5.3

* JsonPartialMatcher - support Regex

* .

* .

* more tests

* .

* .

CHANGELOG.md

@@ -1,3 +1,20 @@
+# 1.5.3 (29 July 2022)
+- [#777](https://github.com/WireMock-Net/WireMock.Net/pull/777) - Update Scriban.Signed to version 5.5.0 [feature] contributed by [StefH](https://github.com/StefH)
+- [#776](https://github.com/WireMock-Net/WireMock.Net/issues/776) - Update Scriban.Signed to support more functions, e.g math.random [feature]
+
+# 1.5.2 (24 July 2022)
+- [#769](https://github.com/WireMock-Net/WireMock.Net/pull/769) - Bump Microsoft.AspNetCore.Server.Kestrel.Core from 2.1.3 to 2.1.7 in /examples/WireMock.Net.StandAlone.Net461 [dependencies] contributed by [dependabot[bot]](https://github.com/apps/dependabot)
+- [#770](https://github.com/WireMock-Net/WireMock.Net/pull/770) - Added some more tests for JsonMatcher + refactored some code to use nullable [test] contributed by [StefH](https://github.com/StefH)
+- [#771](https://github.com/WireMock-Net/WireMock.Net/pull/771) - JsonPartialMatcher - support Regex [feature] contributed by [StefH](https://github.com/StefH)
+
+# 1.5.1 (08 July 2022)
+- [#762](https://github.com/WireMock-Net/WireMock.Net/pull/762) - Bump Newtonsoft.Json from 11.0.2 to 13.0.1 in /examples/WireMock.Net.WebApplication.NETCore2 [dependencies] contributed by [dependabot[bot]](https://github.com/apps/dependabot)
+- [#763](https://github.com/WireMock-Net/WireMock.Net/pull/763) - Bump Newtonsoft.Json from 6.0.1 to 13.0.1 in /examples/WireMock.Net.Client.Net472 [dependencies] contributed by [dependabot[bot]](https://github.com/apps/dependabot)
+- [#765](https://github.com/WireMock-Net/WireMock.Net/pull/765) - Update WireMock.Org.Abstractions and WireMock.Org.RestClient [feature] contributed by [StefH](https://github.com/StefH)
+- [#766](https://github.com/WireMock-Net/WireMock.Net/pull/766) - Bump Microsoft.AspNetCore.Http from 2.1.1 to 2.1.22 in /examples/WireMock.Net.StandAlone.Net461 [dependencies] contributed by [dependabot[bot]](https://github.com/apps/dependabot)
+- [#767](https://github.com/WireMock-Net/WireMock.Net/pull/767) - Rename (WireMock.Pact.Models.V2)-Request to PactRequest and -Response to PactResponse [feature] contributed by [StefH](https://github.com/StefH)
+- [#764](https://github.com/WireMock-Net/WireMock.Net/issues/764) - Wrong mapping of method GetAdminMappingsAsync from IWireMockOrgApi [bug]
+
 # 1.5.0 (09 June 2022)
 - [#755](https://github.com/WireMock-Net/WireMock.Net/pull/755) - Add MatchOperator "Or", "And" and "Average" for patterns [feature] contributed by [StefH](https://github.com/StefH)
 

Directory.Build.props

@@ -4,7 +4,7 @@
     </PropertyGroup>
 
     <PropertyGroup>
-        <VersionPrefix>1.5.0</VersionPrefix>
+        <VersionPrefix>1.5.3</VersionPrefix>
         <PackageIcon>WireMock.Net-Logo.png</PackageIcon>
         <PackageProjectUrl>https://github.com/WireMock-Net/WireMock.Net</PackageProjectUrl>
         <PackageLicenseExpression>Apache-2.0</PackageLicenseExpression>

Generate-ReleaseNotes.cmd

@@ -1,6 +1,6 @@
 rem https://github.com/StefH/GitHubReleaseNotes
 
-SET version=1.5.0
+SET version=1.5.3
 
 GitHubReleaseNotes --output CHANGELOG.md --skip-empty-releases --exclude-labels question invalid doc duplicate --version %version% --token %GH_TOKEN%
 

PackageReleaseNotes.txt

@@ -1,4 +1,5 @@
-# 1.5.0 (09 June 2022)
-- #755 Add MatchOperator "Or", "And" and "Average" for patterns [feature]
+# 1.5.3 (29 July 2022)
+- #777 Update Scriban.Signed to version 5.5.0 [feature]
+- #776 Update Scriban.Signed to support more functions, e.g math.random [feature]
 
 The full release notes can be found here: https://github.com/WireMock-Net/WireMock.Net/blob/master/CHANGELOG.md

examples/WireMock.Net.Client.Net472/packages.config

@@ -1,7 +1,7 @@
 <?xml version="1.0" encoding="utf-8"?>
 <packages>
   <package id="Brutal.Dev.StrongNameSigner" version="2.7.1" targetFramework="net472" />
-  <package id="Newtonsoft.Json" version="6.0.1" targetFramework="net472" />
+  <package id="Newtonsoft.Json" version="13.0.1" targetFramework="net472" />
   <package id="RestEase" version="1.4.10" targetFramework="net472" />
   <package id="WireMock.Net.Abstractions" version="1.2.0" targetFramework="net472" />
   <package id="WireMock.Net.RestClient" version="1.2.0" targetFramework="net472" />

examples/WireMock.Net.Client/WireMock.Net.Client.csproj

@@ -8,7 +8,7 @@
 
   <ItemGroup>
     <PackageReference Include="Newtonsoft.Json" Version="13.0.1" />
-    <PackageReference Include="RestEase" Version="1.5.6" />
+    <PackageReference Include="RestEase" Version="1.5.7" />
   </ItemGroup>
 
   <ItemGroup>

examples/WireMock.Net.Console.Net472.Classic/Nullable/AllowNullAttribute.cs

@@ -0,0 +1,73 @@
+// <auto-generated>
+//   This code file has automatically been added by the "Nullable" NuGet package (https://www.nuget.org/packages/Nullable).
+//   Please see https://github.com/manuelroemer/Nullable for more information.
+//
+//   IMPORTANT:
+//   DO NOT DELETE THIS FILE if you are using a "packages.config" file to manage your NuGet references.
+//   Consider migrating to PackageReferences instead:
+//   https://docs.microsoft.com/en-us/nuget/consume-packages/migrate-packages-config-to-package-reference
+//   Migrating brings the following benefits:
+//   * The "Nullable" folder and the nullable "*Attribute.cs" files don't appear in your project.
+//   * The added files are immutable and can therefore not be modified by coincidence.
+//   * Updating/Uninstalling the package will work flawlessly.
+// </auto-generated>
+
+#region License
+// MIT License
+// 
+// Copyright (c) Manuel Römer
+// 
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+// 
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+// 
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+#endregion
+
+#if !NULLABLE_ATTRIBUTES_DISABLE
+#nullable enable
+#pragma warning disable
+
+namespace System.Diagnostics.CodeAnalysis
+{
+    using global::System;
+
+#if DEBUG
+    /// <summary>
+    ///     Specifies that <see langword="null"/> is allowed as an input even if the
+    ///     corresponding type disallows it.
+    /// </summary>
+#endif
+    [AttributeUsage(
+        AttributeTargets.Field | AttributeTargets.Parameter | AttributeTargets.Property,
+        Inherited = false
+    )]
+#if !NULLABLE_ATTRIBUTES_INCLUDE_IN_CODE_COVERAGE
+    [DebuggerNonUserCode]
+#endif
+    internal sealed class AllowNullAttribute : Attribute
+    {
+#if DEBUG
+        /// <summary>
+        ///     Initializes a new instance of the <see cref="AllowNullAttribute"/> class.
+        /// </summary>
+#endif
+        public AllowNullAttribute() { }
+    }
+}
+
+#pragma warning restore
+#nullable restore
+#endif // NULLABLE_ATTRIBUTES_DISABLE

examples/WireMock.Net.Console.Net472.Classic/Nullable/DisallowNullAttribute.cs

@@ -0,0 +1,73 @@
+// <auto-generated>
+//   This code file has automatically been added by the "Nullable" NuGet package (https://www.nuget.org/packages/Nullable).
+//   Please see https://github.com/manuelroemer/Nullable for more information.
+//
+//   IMPORTANT:
+//   DO NOT DELETE THIS FILE if you are using a "packages.config" file to manage your NuGet references.
+//   Consider migrating to PackageReferences instead:
+//   https://docs.microsoft.com/en-us/nuget/consume-packages/migrate-packages-config-to-package-reference
+//   Migrating brings the following benefits:
+//   * The "Nullable" folder and the nullable "*Attribute.cs" files don't appear in your project.
+//   * The added files are immutable and can therefore not be modified by coincidence.
+//   * Updating/Uninstalling the package will work flawlessly.
+// </auto-generated>
+
+#region License
+// MIT License
+// 
+// Copyright (c) Manuel Römer
+// 
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+// 
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+// 
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+#endregion
+
+#if !NULLABLE_ATTRIBUTES_DISABLE
+#nullable enable
+#pragma warning disable
+
+namespace System.Diagnostics.CodeAnalysis
+{
+    using global::System;
+
+#if DEBUG
+    /// <summary>
+    ///     Specifies that <see langword="null"/> is disallowed as an input even if the
+    ///     corresponding type allows it.
+    /// </summary>
+#endif
+    [AttributeUsage(
+        AttributeTargets.Field | AttributeTargets.Parameter | AttributeTargets.Property,
+        Inherited = false
+    )]
+#if !NULLABLE_ATTRIBUTES_INCLUDE_IN_CODE_COVERAGE
+    [DebuggerNonUserCode]
+#endif
+    internal sealed class DisallowNullAttribute : Attribute
+    {
+#if DEBUG
+        /// <summary>
+        ///     Initializes a new instance of the <see cref="DisallowNullAttribute"/> class.
+        /// </summary>
+#endif
+        public DisallowNullAttribute() { }
+    }
+}
+
+#pragma warning restore
+#nullable restore
+#endif // NULLABLE_ATTRIBUTES_DISABLE

examples/WireMock.Net.Console.Net472.Classic/Nullable/DoesNotReturnAttribute.cs

@@ -0,0 +1,70 @@
+// <auto-generated>
+//   This code file has automatically been added by the "Nullable" NuGet package (https://www.nuget.org/packages/Nullable).
+//   Please see https://github.com/manuelroemer/Nullable for more information.
+//
+//   IMPORTANT:
+//   DO NOT DELETE THIS FILE if you are using a "packages.config" file to manage your NuGet references.
+//   Consider migrating to PackageReferences instead:
+//   https://docs.microsoft.com/en-us/nuget/consume-packages/migrate-packages-config-to-package-reference
+//   Migrating brings the following benefits:
+//   * The "Nullable" folder and the nullable "*Attribute.cs" files don't appear in your project.
+//   * The added files are immutable and can therefore not be modified by coincidence.
+//   * Updating/Uninstalling the package will work flawlessly.
+// </auto-generated>
+
+#region License
+// MIT License
+// 
+// Copyright (c) Manuel Römer
+// 
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+// 
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+// 
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+#endregion
+
+#if !NULLABLE_ATTRIBUTES_DISABLE
+#nullable enable
+#pragma warning disable
+
+namespace System.Diagnostics.CodeAnalysis
+{
+    using global::System;
+
+#if DEBUG
+    /// <summary>
+    ///     Specifies that a method that will never return under any circumstance.
+    /// </summary>
+#endif
+    [AttributeUsage(AttributeTargets.Method, Inherited = false)]
+#if !NULLABLE_ATTRIBUTES_INCLUDE_IN_CODE_COVERAGE
+    [DebuggerNonUserCode]
+#endif
+    internal sealed class DoesNotReturnAttribute : Attribute
+    {
+#if DEBUG
+        /// <summary>
+        ///     Initializes a new instance of the <see cref="DoesNotReturnAttribute"/> class.
+        /// </summary>
+        ///
+#endif
+        public DoesNotReturnAttribute() { }
+    }
+}
+
+#pragma warning restore
+#nullable restore
+#endif // NULLABLE_ATTRIBUTES_DISABLE

examples/WireMock.Net.Console.Net472.Classic/Nullable/DoesNotReturnIfAttribute.cs

@@ -0,0 +1,88 @@
+// <auto-generated>
+//   This code file has automatically been added by the "Nullable" NuGet package (https://www.nuget.org/packages/Nullable).
+//   Please see https://github.com/manuelroemer/Nullable for more information.
+//
+//   IMPORTANT:
+//   DO NOT DELETE THIS FILE if you are using a "packages.config" file to manage your NuGet references.
+//   Consider migrating to PackageReferences instead:
+//   https://docs.microsoft.com/en-us/nuget/consume-packages/migrate-packages-config-to-package-reference
+//   Migrating brings the following benefits:
+//   * The "Nullable" folder and the nullable "*Attribute.cs" files don't appear in your project.
+//   * The added files are immutable and can therefore not be modified by coincidence.
+//   * Updating/Uninstalling the package will work flawlessly.
+// </auto-generated>
+
+#region License
+// MIT License
+// 
+// Copyright (c) Manuel Römer
+// 
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+// 
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+// 
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+#endregion
+
+#if !NULLABLE_ATTRIBUTES_DISABLE
+#nullable enable
+#pragma warning disable
+
+namespace System.Diagnostics.CodeAnalysis
+{
+    using global::System;
+
+#if DEBUG
+    /// <summary>
+    ///     Specifies that the method will not return if the associated <see cref="Boolean"/>
+    ///     parameter is passed the specified value.
+    /// </summary>
+#endif
+    [AttributeUsage(AttributeTargets.Parameter, Inherited = false)]
+#if !NULLABLE_ATTRIBUTES_INCLUDE_IN_CODE_COVERAGE
+    [DebuggerNonUserCode]
+#endif
+    internal sealed class DoesNotReturnIfAttribute : Attribute
+    {
+#if DEBUG
+        /// <summary>
+        ///     Gets the condition parameter value.
+        ///     Code after the method is considered unreachable by diagnostics if the argument
+        ///     to the associated parameter matches this value.
+        /// </summary>
+#endif
+        public bool ParameterValue { get; }
+
+#if DEBUG
+        /// <summary>
+        ///     Initializes a new instance of the <see cref="DoesNotReturnIfAttribute"/>
+        ///     class with the specified parameter value.
+        /// </summary>
+        /// <param name="parameterValue">
+        ///     The condition parameter value.
+        ///     Code after the method is considered unreachable by diagnostics if the argument
+        ///     to the associated parameter matches this value.
+        /// </param>
+#endif
+        public DoesNotReturnIfAttribute(bool parameterValue)
+        {
+            ParameterValue = parameterValue;
+        }
+    }
+}
+
+#pragma warning restore
+#nullable restore
+#endif // NULLABLE_ATTRIBUTES_DISABLE

examples/WireMock.Net.Console.Net472.Classic/Nullable/MaybeNullAttribute.cs

@@ -0,0 +1,74 @@
+// <auto-generated>
+//   This code file has automatically been added by the "Nullable" NuGet package (https://www.nuget.org/packages/Nullable).
+//   Please see https://github.com/manuelroemer/Nullable for more information.
+//
+//   IMPORTANT:
+//   DO NOT DELETE THIS FILE if you are using a "packages.config" file to manage your NuGet references.
+//   Consider migrating to PackageReferences instead:
+//   https://docs.microsoft.com/en-us/nuget/consume-packages/migrate-packages-config-to-package-reference
+//   Migrating brings the following benefits:
+//   * The "Nullable" folder and the nullable "*Attribute.cs" files don't appear in your project.
+//   * The added files are immutable and can therefore not be modified by coincidence.
+//   * Updating/Uninstalling the package will work flawlessly.
+// </auto-generated>
+
+#region License
+// MIT License
+// 
+// Copyright (c) Manuel Römer
+// 
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+// 
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+// 
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+#endregion
+
+#if !NULLABLE_ATTRIBUTES_DISABLE
+#nullable enable
+#pragma warning disable
+
+namespace System.Diagnostics.CodeAnalysis
+{
+    using global::System;
+
+#if DEBUG
+    /// <summary>
+    ///     Specifies that an output may be <see langword="null"/> even if the
+    ///     corresponding type disallows it.
+    /// </summary>
+#endif
+    [AttributeUsage(
+        AttributeTargets.Field | AttributeTargets.Parameter |
+        AttributeTargets.Property | AttributeTargets.ReturnValue,
+        Inherited = false
+    )]
+#if !NULLABLE_ATTRIBUTES_INCLUDE_IN_CODE_COVERAGE
+    [DebuggerNonUserCode]
+#endif
+    internal sealed class MaybeNullAttribute : Attribute
+    {
+#if DEBUG
+        /// <summary>
+        ///     Initializes a new instance of the <see cref="MaybeNullAttribute"/> class.
+        /// </summary>
+#endif
+        public MaybeNullAttribute() { }
+    }
+}
+
+#pragma warning restore
+#nullable restore
+#endif // NULLABLE_ATTRIBUTES_DISABLE

examples/WireMock.Net.Console.Net472.Classic/Nullable/MaybeNullWhenAttribute.cs

@@ -0,0 +1,85 @@
+// <auto-generated>
+//   This code file has automatically been added by the "Nullable" NuGet package (https://www.nuget.org/packages/Nullable).
+//   Please see https://github.com/manuelroemer/Nullable for more information.
+//
+//   IMPORTANT:
+//   DO NOT DELETE THIS FILE if you are using a "packages.config" file to manage your NuGet references.
+//   Consider migrating to PackageReferences instead:
+//   https://docs.microsoft.com/en-us/nuget/consume-packages/migrate-packages-config-to-package-reference
+//   Migrating brings the following benefits:
+//   * The "Nullable" folder and the nullable "*Attribute.cs" files don't appear in your project.
+//   * The added files are immutable and can therefore not be modified by coincidence.
+//   * Updating/Uninstalling the package will work flawlessly.
+// </auto-generated>
+
+#region License
+// MIT License
+// 
+// Copyright (c) Manuel Römer
+// 
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+// 
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+// 
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+#endregion
+
+#if !NULLABLE_ATTRIBUTES_DISABLE
+#nullable enable
+#pragma warning disable
+
+namespace System.Diagnostics.CodeAnalysis
+{
+    using global::System;
+
+#if DEBUG
+    /// <summary>
+    ///     Specifies that when a method returns <see cref="ReturnValue"/>, 
+    ///     the parameter may be <see langword="null"/> even if the corresponding type disallows it.
+    /// </summary>
+#endif
+    [AttributeUsage(AttributeTargets.Parameter, Inherited = false)]
+#if !NULLABLE_ATTRIBUTES_INCLUDE_IN_CODE_COVERAGE
+    [DebuggerNonUserCode]
+#endif
+    internal sealed class MaybeNullWhenAttribute : Attribute
+    {
+#if DEBUG
+        /// <summary>
+        ///     Gets the return value condition.
+        ///     If the method returns this value, the associated parameter may be <see langword="null"/>.
+        /// </summary>
+#endif
+        public bool ReturnValue { get; }
+
+#if DEBUG
+        /// <summary>
+        ///      Initializes the attribute with the specified return value condition.
+        /// </summary>
+        /// <param name="returnValue">
+        ///     The return value condition.
+        ///     If the method returns this value, the associated parameter may be <see langword="null"/>.
+        /// </param>
+#endif
+        public MaybeNullWhenAttribute(bool returnValue)
+        {
+            ReturnValue = returnValue;
+        }
+    }
+}
+
+#pragma warning restore
+#nullable restore
+#endif // NULLABLE_ATTRIBUTES_DISABLE

examples/WireMock.Net.Console.Net472.Classic/Nullable/MemberNotNullAttribute.cs

@@ -0,0 +1,96 @@
+// <auto-generated>
+//   This code file has automatically been added by the "Nullable" NuGet package (https://www.nuget.org/packages/Nullable).
+//   Please see https://github.com/manuelroemer/Nullable for more information.
+//
+//   IMPORTANT:
+//   DO NOT DELETE THIS FILE if you are using a "packages.config" file to manage your NuGet references.
+//   Consider migrating to PackageReferences instead:
+//   https://docs.microsoft.com/en-us/nuget/consume-packages/migrate-packages-config-to-package-reference
+//   Migrating brings the following benefits:
+//   * The "Nullable" folder and the nullable "*Attribute.cs" files don't appear in your project.
+//   * The added files are immutable and can therefore not be modified by coincidence.
+//   * Updating/Uninstalling the package will work flawlessly.
+// </auto-generated>
+
+#region License
+// MIT License
+// 
+// Copyright (c) Manuel Römer
+// 
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+// 
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+// 
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+#endregion
+
+#if !NULLABLE_ATTRIBUTES_DISABLE
+#nullable enable
+#pragma warning disable
+
+namespace System.Diagnostics.CodeAnalysis
+{
+    using global::System;
+
+#if DEBUG
+    /// <summary>
+    ///     Specifies that the method or property will ensure that the listed field and property members have
+    ///     not-<see langword="null"/> values.
+    /// </summary>
+#endif
+    [AttributeUsage(AttributeTargets.Method | AttributeTargets.Property, Inherited = false, AllowMultiple = true)]
+#if !NULLABLE_ATTRIBUTES_INCLUDE_IN_CODE_COVERAGE
+    [DebuggerNonUserCode]
+#endif
+    internal sealed class MemberNotNullAttribute : Attribute
+    {
+#if DEBUG
+        /// <summary>
+        ///     Gets field or property member names.
+        /// </summary>
+#endif
+        public string[] Members { get; }
+
+#if DEBUG
+        /// <summary>
+        ///     Initializes the attribute with a field or property member.
+        /// </summary>
+        /// <param name="member">
+        ///     The field or property member that is promised to be not-null.
+        /// </param>
+#endif
+        public MemberNotNullAttribute(string member)
+        {
+            Members = new[] { member };
+        }
+
+#if DEBUG
+        /// <summary>
+        ///     Initializes the attribute with the list of field and property members.
+        /// </summary>
+        /// <param name="members">
+        ///     The list of field and property members that are promised to be not-null.
+        /// </param>
+#endif
+        public MemberNotNullAttribute(params string[] members)
+        {
+            Members = members;
+        }
+    }
+}
+
+#pragma warning restore
+#nullable restore
+#endif // NULLABLE_ATTRIBUTES_DISABLE

examples/WireMock.Net.Console.Net472.Classic/Nullable/MemberNotNullWhenAttribute.cs

@@ -0,0 +1,114 @@
+// <auto-generated>
+//   This code file has automatically been added by the "Nullable" NuGet package (https://www.nuget.org/packages/Nullable).
+//   Please see https://github.com/manuelroemer/Nullable for more information.
+//
+//   IMPORTANT:
+//   DO NOT DELETE THIS FILE if you are using a "packages.config" file to manage your NuGet references.
+//   Consider migrating to PackageReferences instead:
+//   https://docs.microsoft.com/en-us/nuget/consume-packages/migrate-packages-config-to-package-reference
+//   Migrating brings the following benefits:
+//   * The "Nullable" folder and the nullable "*Attribute.cs" files don't appear in your project.
+//   * The added files are immutable and can therefore not be modified by coincidence.
+//   * Updating/Uninstalling the package will work flawlessly.
+// </auto-generated>
+
+#region License
+// MIT License
+// 
+// Copyright (c) Manuel Römer
+// 
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+// 
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+// 
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+#endregion
+
+#if !NULLABLE_ATTRIBUTES_DISABLE
+#nullable enable
+#pragma warning disable
+
+namespace System.Diagnostics.CodeAnalysis
+{
+    using global::System;
+
+#if DEBUG
+    /// <summary>
+    ///     Specifies that the method or property will ensure that the listed field and property members have
+    ///     non-<see langword="null"/> values when returning with the specified return value condition.
+    /// </summary>
+#endif
+    [AttributeUsage(AttributeTargets.Method | AttributeTargets.Property, Inherited = false, AllowMultiple = true)]
+#if !NULLABLE_ATTRIBUTES_INCLUDE_IN_CODE_COVERAGE
+    [DebuggerNonUserCode]
+#endif
+    internal sealed class MemberNotNullWhenAttribute : Attribute
+    {
+#if DEBUG
+        /// <summary>
+        ///     Gets the return value condition.
+        /// </summary>
+#endif
+        public bool ReturnValue { get; }
+
+#if DEBUG
+        /// <summary>
+        ///     Gets field or property member names.
+        /// </summary>
+#endif
+        public string[] Members { get; }
+
+#if DEBUG
+        /// <summary>
+        ///     Initializes the attribute with the specified return value condition and a field or property member.
+        /// </summary>
+        /// <param name="returnValue">
+        ///     The return value condition. If the method returns this value,
+        ///     the associated parameter will not be <see langword="null"/>.
+        /// </param>
+        /// <param name="member">
+        ///     The field or property member that is promised to be not-<see langword="null"/>.
+        /// </param>
+#endif
+        public MemberNotNullWhenAttribute(bool returnValue, string member)
+        {
+            ReturnValue = returnValue;
+            Members = new[] { member };
+        }
+
+#if DEBUG
+        /// <summary>
+        ///     Initializes the attribute with the specified return value condition and list
+        ///     of field and property members.
+        /// </summary>
+        /// <param name="returnValue">
+        ///     The return value condition. If the method returns this value,
+        ///     the associated parameter will not be <see langword="null"/>.
+        /// </param>
+        /// <param name="members">
+        ///     The list of field and property members that are promised to be not-null.
+        /// </param>
+#endif
+        public MemberNotNullWhenAttribute(bool returnValue, params string[] members)
+        {
+            ReturnValue = returnValue;
+            Members = members;
+        }
+    }
+}
+
+#pragma warning restore
+#nullable restore
+#endif // NULLABLE_ATTRIBUTES_DISABLE

examples/WireMock.Net.Console.Net472.Classic/Nullable/NotNullAttribute.cs

@@ -0,0 +1,74 @@
+// <auto-generated>
+//   This code file has automatically been added by the "Nullable" NuGet package (https://www.nuget.org/packages/Nullable).
+//   Please see https://github.com/manuelroemer/Nullable for more information.
+//
+//   IMPORTANT:
+//   DO NOT DELETE THIS FILE if you are using a "packages.config" file to manage your NuGet references.
+//   Consider migrating to PackageReferences instead:
+//   https://docs.microsoft.com/en-us/nuget/consume-packages/migrate-packages-config-to-package-reference
+//   Migrating brings the following benefits:
+//   * The "Nullable" folder and the nullable "*Attribute.cs" files don't appear in your project.
+//   * The added files are immutable and can therefore not be modified by coincidence.
+//   * Updating/Uninstalling the package will work flawlessly.
+// </auto-generated>
+
+#region License
+// MIT License
+// 
+// Copyright (c) Manuel Römer
+// 
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+// 
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+// 
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+#endregion
+
+#if !NULLABLE_ATTRIBUTES_DISABLE
+#nullable enable
+#pragma warning disable
+
+namespace System.Diagnostics.CodeAnalysis
+{
+    using global::System;
+
+#if DEBUG
+    /// <summary>
+    ///     Specifies that an output is not <see langword="null"/> even if the
+    ///     corresponding type allows it.
+    /// </summary>
+#endif
+    [AttributeUsage(
+        AttributeTargets.Field | AttributeTargets.Parameter |
+        AttributeTargets.Property | AttributeTargets.ReturnValue,
+        Inherited = false
+    )]
+#if !NULLABLE_ATTRIBUTES_INCLUDE_IN_CODE_COVERAGE
+    [DebuggerNonUserCode]
+#endif
+    internal sealed class NotNullAttribute : Attribute
+    {
+#if DEBUG
+        /// <summary>
+        ///     Initializes a new instance of the <see cref="NotNullAttribute"/> class.
+        /// </summary>
+#endif
+        public NotNullAttribute() { }
+    }
+}
+
+#pragma warning restore
+#nullable restore
+#endif // NULLABLE_ATTRIBUTES_DISABLE

examples/WireMock.Net.Console.Net472.Classic/Nullable/NotNullIfNotNullAttribute.cs

@@ -0,0 +1,91 @@
+// <auto-generated>
+//   This code file has automatically been added by the "Nullable" NuGet package (https://www.nuget.org/packages/Nullable).
+//   Please see https://github.com/manuelroemer/Nullable for more information.
+//
+//   IMPORTANT:
+//   DO NOT DELETE THIS FILE if you are using a "packages.config" file to manage your NuGet references.
+//   Consider migrating to PackageReferences instead:
+//   https://docs.microsoft.com/en-us/nuget/consume-packages/migrate-packages-config-to-package-reference
+//   Migrating brings the following benefits:
+//   * The "Nullable" folder and the nullable "*Attribute.cs" files don't appear in your project.
+//   * The added files are immutable and can therefore not be modified by coincidence.
+//   * Updating/Uninstalling the package will work flawlessly.
+// </auto-generated>
+
+#region License
+// MIT License
+// 
+// Copyright (c) Manuel Römer
+// 
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+// 
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+// 
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+#endregion
+
+#if !NULLABLE_ATTRIBUTES_DISABLE
+#nullable enable
+#pragma warning disable
+
+namespace System.Diagnostics.CodeAnalysis
+{
+    using global::System;
+
+#if DEBUG
+    /// <summary>
+    ///     Specifies that the output will be non-<see langword="null"/> if the
+    ///     named parameter is non-<see langword="null"/>.
+    /// </summary>
+#endif
+    [AttributeUsage(
+        AttributeTargets.Parameter | AttributeTargets.Property | AttributeTargets.ReturnValue,
+        AllowMultiple = true,
+        Inherited = false
+    )]
+#if !NULLABLE_ATTRIBUTES_INCLUDE_IN_CODE_COVERAGE
+    [DebuggerNonUserCode]
+#endif
+    internal sealed class NotNullIfNotNullAttribute : Attribute
+    {
+#if DEBUG
+        /// <summary>
+        ///     Gets the associated parameter name.
+        ///     The output will be non-<see langword="null"/> if the argument to the
+        ///     parameter specified is non-<see langword="null"/>.
+        /// </summary>
+#endif
+        public string ParameterName { get; }
+
+#if DEBUG
+        /// <summary>
+        ///     Initializes the attribute with the associated parameter name.
+        /// </summary>
+        /// <param name="parameterName">
+        ///     The associated parameter name.
+        ///     The output will be non-<see langword="null"/> if the argument to the
+        ///     parameter specified is non-<see langword="null"/>.
+        /// </param>
+#endif
+        public NotNullIfNotNullAttribute(string parameterName)
+        {
+            ParameterName = parameterName;
+        }
+    }
+}
+
+#pragma warning restore
+#nullable restore
+#endif // NULLABLE_ATTRIBUTES_DISABLE

examples/WireMock.Net.Console.Net472.Classic/Nullable/NotNullWhenAttribute.cs

@@ -0,0 +1,85 @@
+// <auto-generated>
+//   This code file has automatically been added by the "Nullable" NuGet package (https://www.nuget.org/packages/Nullable).
+//   Please see https://github.com/manuelroemer/Nullable for more information.
+//
+//   IMPORTANT:
+//   DO NOT DELETE THIS FILE if you are using a "packages.config" file to manage your NuGet references.
+//   Consider migrating to PackageReferences instead:
+//   https://docs.microsoft.com/en-us/nuget/consume-packages/migrate-packages-config-to-package-reference
+//   Migrating brings the following benefits:
+//   * The "Nullable" folder and the nullable "*Attribute.cs" files don't appear in your project.
+//   * The added files are immutable and can therefore not be modified by coincidence.
+//   * Updating/Uninstalling the package will work flawlessly.
+// </auto-generated>
+
+#region License
+// MIT License
+// 
+// Copyright (c) Manuel Römer
+// 
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+// 
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+// 
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+#endregion
+
+#if !NULLABLE_ATTRIBUTES_DISABLE
+#nullable enable
+#pragma warning disable
+
+namespace System.Diagnostics.CodeAnalysis
+{
+    using global::System;
+
+#if DEBUG
+    /// <summary>
+    ///     Specifies that when a method returns <see cref="ReturnValue"/>,
+    ///     the parameter will not be <see langword="null"/> even if the corresponding type allows it.
+    /// </summary>
+#endif
+    [AttributeUsage(AttributeTargets.Parameter, Inherited = false)]
+#if !NULLABLE_ATTRIBUTES_INCLUDE_IN_CODE_COVERAGE
+    [DebuggerNonUserCode]
+#endif
+    internal sealed class NotNullWhenAttribute : Attribute
+    {
+#if DEBUG
+        /// <summary>
+        ///     Gets the return value condition.
+        ///     If the method returns this value, the associated parameter will not be <see langword="null"/>.
+        /// </summary>
+#endif
+        public bool ReturnValue { get; }
+
+#if DEBUG
+        /// <summary>
+        ///     Initializes the attribute with the specified return value condition.
+        /// </summary>
+        /// <param name="returnValue">
+        ///     The return value condition.
+        ///     If the method returns this value, the associated parameter will not be <see langword="null"/>.
+        /// </param>
+#endif
+        public NotNullWhenAttribute(bool returnValue)
+        {
+            ReturnValue = returnValue;
+        }
+    }
+}
+
+#pragma warning restore
+#nullable restore
+#endif // NULLABLE_ATTRIBUTES_DISABLE

examples/WireMock.Net.Console.Net472.Classic/WireMock.Net.Console.Net472.Classic.csproj

@@ -54,23 +54,23 @@
     <Reference Include="HandlebarsDotNet.Helpers.Core, Version=2.3.5.0, Culture=neutral, PublicKeyToken=00d131fae0c250bc, processorArchitecture=MSIL">
       <HintPath>..\..\packages\Handlebars.Net.Helpers.Core.2.3.5\lib\net452\HandlebarsDotNet.Helpers.Core.dll</HintPath>
     </Reference>
-    <Reference Include="HandlebarsDotNet.Helpers.DynamicLinq, Version=2.3.3.0, Culture=neutral, PublicKeyToken=00d131fae0c250bc, processorArchitecture=MSIL">
-      <HintPath>..\..\packages\Handlebars.Net.Helpers.DynamicLinq.2.3.3\lib\net452\HandlebarsDotNet.Helpers.DynamicLinq.dll</HintPath>
+    <Reference Include="HandlebarsDotNet.Helpers.DynamicLinq, Version=2.3.5.0, Culture=neutral, PublicKeyToken=00d131fae0c250bc, processorArchitecture=MSIL">
+      <HintPath>..\..\packages\Handlebars.Net.Helpers.DynamicLinq.2.3.5\lib\net452\HandlebarsDotNet.Helpers.DynamicLinq.dll</HintPath>
     </Reference>
-    <Reference Include="HandlebarsDotNet.Helpers.Humanizer, Version=2.3.3.0, Culture=neutral, PublicKeyToken=00d131fae0c250bc, processorArchitecture=MSIL">
-      <HintPath>..\..\packages\Handlebars.Net.Helpers.Humanizer.2.3.3\lib\net452\HandlebarsDotNet.Helpers.Humanizer.dll</HintPath>
+    <Reference Include="HandlebarsDotNet.Helpers.Humanizer, Version=2.3.5.0, Culture=neutral, PublicKeyToken=00d131fae0c250bc, processorArchitecture=MSIL">
+      <HintPath>..\..\packages\Handlebars.Net.Helpers.Humanizer.2.3.5\lib\net452\HandlebarsDotNet.Helpers.Humanizer.dll</HintPath>
     </Reference>
-    <Reference Include="HandlebarsDotNet.Helpers.Json, Version=2.3.3.0, Culture=neutral, PublicKeyToken=00d131fae0c250bc, processorArchitecture=MSIL">
-      <HintPath>..\..\packages\Handlebars.Net.Helpers.Json.2.3.3\lib\net452\HandlebarsDotNet.Helpers.Json.dll</HintPath>
+    <Reference Include="HandlebarsDotNet.Helpers.Json, Version=2.3.5.0, Culture=neutral, PublicKeyToken=00d131fae0c250bc, processorArchitecture=MSIL">
+      <HintPath>..\..\packages\Handlebars.Net.Helpers.Json.2.3.5\lib\net452\HandlebarsDotNet.Helpers.Json.dll</HintPath>
     </Reference>
-    <Reference Include="HandlebarsDotNet.Helpers.Random, Version=2.3.3.0, Culture=neutral, PublicKeyToken=00d131fae0c250bc, processorArchitecture=MSIL">
-      <HintPath>..\..\packages\Handlebars.Net.Helpers.Random.2.3.3\lib\net452\HandlebarsDotNet.Helpers.Random.dll</HintPath>
+    <Reference Include="HandlebarsDotNet.Helpers.Random, Version=2.3.5.0, Culture=neutral, PublicKeyToken=00d131fae0c250bc, processorArchitecture=MSIL">
+      <HintPath>..\..\packages\Handlebars.Net.Helpers.Random.2.3.5\lib\net452\HandlebarsDotNet.Helpers.Random.dll</HintPath>
     </Reference>
-    <Reference Include="HandlebarsDotNet.Helpers.Xeger, Version=2.3.3.0, Culture=neutral, PublicKeyToken=00d131fae0c250bc, processorArchitecture=MSIL">
-      <HintPath>..\..\packages\Handlebars.Net.Helpers.Xeger.2.3.3\lib\net452\HandlebarsDotNet.Helpers.Xeger.dll</HintPath>
+    <Reference Include="HandlebarsDotNet.Helpers.Xeger, Version=2.3.5.0, Culture=neutral, PublicKeyToken=00d131fae0c250bc, processorArchitecture=MSIL">
+      <HintPath>..\..\packages\Handlebars.Net.Helpers.Xeger.2.3.5\lib\net452\HandlebarsDotNet.Helpers.Xeger.dll</HintPath>
     </Reference>
-    <Reference Include="HandlebarsDotNet.Helpers.XPath, Version=2.3.3.0, Culture=neutral, PublicKeyToken=00d131fae0c250bc, processorArchitecture=MSIL">
-      <HintPath>..\..\packages\Handlebars.Net.Helpers.XPath.2.3.3\lib\net452\HandlebarsDotNet.Helpers.XPath.dll</HintPath>
+    <Reference Include="HandlebarsDotNet.Helpers.XPath, Version=2.3.5.0, Culture=neutral, PublicKeyToken=00d131fae0c250bc, processorArchitecture=MSIL">
+      <HintPath>..\..\packages\Handlebars.Net.Helpers.XPath.2.3.5\lib\net452\HandlebarsDotNet.Helpers.XPath.dll</HintPath>
     </Reference>
     <Reference Include="Humanizer, Version=2.14.0.0, Culture=neutral, PublicKeyToken=979442b78dfc278e, processorArchitecture=MSIL">
       <HintPath>..\..\packages\Humanizer.Core.2.14.1\lib\netstandard2.0\Humanizer.dll</HintPath>
@@ -246,11 +246,23 @@
     <Reference Include="Microsoft.Net.Http.Headers, Version=2.2.0.0, Culture=neutral, PublicKeyToken=adb9793829ddae60, processorArchitecture=MSIL">
       <HintPath>..\..\packages\Microsoft.Net.Http.Headers.2.2.0\lib\netstandard2.0\Microsoft.Net.Http.Headers.dll</HintPath>
     </Reference>
+    <Reference Include="Namotion.Reflection, Version=2.0.10.0, Culture=neutral, PublicKeyToken=c2f9c3bdfae56102, processorArchitecture=MSIL">
+      <HintPath>..\..\packages\Namotion.Reflection.2.0.10\lib\net45\Namotion.Reflection.dll</HintPath>
+    </Reference>
     <Reference Include="Newtonsoft.Json, Version=13.0.0.0, Culture=neutral, PublicKeyToken=30ad4fe6b2a6aeed, processorArchitecture=MSIL">
       <HintPath>..\..\packages\Newtonsoft.Json.13.0.1\lib\net45\Newtonsoft.Json.dll</HintPath>
     </Reference>
-    <Reference Include="RandomDataGenerator, Version=1.0.13.0, Culture=neutral, PublicKeyToken=ae5c571d29a3b8d9, processorArchitecture=MSIL">
-      <HintPath>..\..\packages\RandomDataGenerator.Net.1.0.14\lib\net45\RandomDataGenerator.dll</HintPath>
+    <Reference Include="NJsonSchema, Version=10.6.10.0, Culture=neutral, PublicKeyToken=c2f9c3bdfae56102, processorArchitecture=MSIL">
+      <HintPath>..\..\packages\NJsonSchema.10.6.10\lib\net45\NJsonSchema.dll</HintPath>
+    </Reference>
+    <Reference Include="NJsonSchema.Extensions, Version=0.1.0.0, Culture=neutral, PublicKeyToken=e52fadf300daf456, processorArchitecture=MSIL">
+      <HintPath>..\..\packages\NJsonSchema.Extensions.0.1.0\lib\net45\NJsonSchema.Extensions.dll</HintPath>
+    </Reference>
+    <Reference Include="NSwag.Core, Version=13.15.10.0, Culture=neutral, PublicKeyToken=c2d88086e098d109, processorArchitecture=MSIL">
+      <HintPath>..\..\packages\NSwag.Core.13.15.10\lib\net45\NSwag.Core.dll</HintPath>
+    </Reference>
+    <Reference Include="RandomDataGenerator, Version=1.0.15.0, Culture=neutral, PublicKeyToken=ae5c571d29a3b8d9, processorArchitecture=MSIL">
+      <HintPath>..\..\packages\RandomDataGenerator.Net.1.0.15\lib\net45\RandomDataGenerator.dll</HintPath>
     </Reference>
     <Reference Include="Scriban.Signed, Version=2.1.4.0, Culture=neutral, PublicKeyToken=5675fb69b15f2433, processorArchitecture=MSIL">
       <HintPath>..\..\packages\Scriban.Signed.2.1.4\lib\net45\Scriban.Signed.dll</HintPath>
@@ -289,6 +301,10 @@
     <Reference Include="System.Memory, Version=4.0.1.1, Culture=neutral, PublicKeyToken=cc7b13ffcd2ddd51, processorArchitecture=MSIL">
       <HintPath>..\..\packages\System.Memory.4.5.4\lib\net461\System.Memory.dll</HintPath>
     </Reference>
+    <Reference Include="System.Net" />
+    <Reference Include="System.Net.Http.Formatting, Version=5.2.8.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35, processorArchitecture=MSIL">
+      <HintPath>..\..\packages\Microsoft.AspNet.WebApi.Client.5.2.8\lib\net45\System.Net.Http.Formatting.dll</HintPath>
+    </Reference>
     <Reference Include="System.Net.Http.WebRequest" />
     <Reference Include="System.Numerics" />
     <Reference Include="System.Numerics.Vectors, Version=4.1.4.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a, processorArchitecture=MSIL">
@@ -300,6 +316,7 @@
     <Reference Include="System.Runtime.CompilerServices.Unsafe, Version=5.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a, processorArchitecture=MSIL">
       <HintPath>..\..\packages\System.Runtime.CompilerServices.Unsafe.5.0.0\lib\net45\System.Runtime.CompilerServices.Unsafe.dll</HintPath>
     </Reference>
+    <Reference Include="System.Runtime.Serialization" />
     <Reference Include="System.Security.Cryptography.Cng, Version=4.3.1.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a, processorArchitecture=MSIL">
       <HintPath>..\..\packages\System.Security.Cryptography.Cng.4.5.0\lib\net47\System.Security.Cryptography.Cng.dll</HintPath>
     </Reference>
@@ -325,14 +342,14 @@
     <Reference Include="TinyMapper, Version=3.0.1.0, Culture=neutral, processorArchitecture=MSIL">
       <HintPath>..\..\packages\TinyMapper.3.0.3\lib\net40\TinyMapper.dll</HintPath>
     </Reference>
-    <Reference Include="WireMock.Net, Version=1.4.41.0, Culture=neutral, PublicKeyToken=c8d65537854e1f03, processorArchitecture=MSIL">
-      <HintPath>..\..\packages\WireMock.Net.1.4.41\lib\net461\WireMock.Net.dll</HintPath>
+    <Reference Include="WireMock.Net, Version=1.5.1.0, Culture=neutral, PublicKeyToken=c8d65537854e1f03, processorArchitecture=MSIL">
+      <HintPath>..\..\packages\WireMock.Net.1.5.1\lib\net461\WireMock.Net.dll</HintPath>
     </Reference>
-    <Reference Include="WireMock.Net.Abstractions, Version=1.4.41.0, Culture=neutral, PublicKeyToken=c8d65537854e1f03, processorArchitecture=MSIL">
-      <HintPath>..\..\packages\WireMock.Net.Abstractions.1.4.41\lib\net451\WireMock.Net.Abstractions.dll</HintPath>
+    <Reference Include="WireMock.Net.Abstractions, Version=1.5.1.0, Culture=neutral, PublicKeyToken=c8d65537854e1f03, processorArchitecture=MSIL">
+      <HintPath>..\..\packages\WireMock.Net.Abstractions.1.5.1\lib\net451\WireMock.Net.Abstractions.dll</HintPath>
     </Reference>
-    <Reference Include="WireMock.Org.Abstractions, Version=1.4.41.0, Culture=neutral, PublicKeyToken=c8d65537854e1f03, processorArchitecture=MSIL">
-      <HintPath>..\..\packages\WireMock.Org.Abstractions.1.4.41\lib\net45\WireMock.Org.Abstractions.dll</HintPath>
+    <Reference Include="WireMock.Org.Abstractions, Version=1.5.1.0, Culture=neutral, PublicKeyToken=c8d65537854e1f03, processorArchitecture=MSIL">
+      <HintPath>..\..\packages\WireMock.Org.Abstractions.1.5.1\lib\net45\WireMock.Org.Abstractions.dll</HintPath>
     </Reference>
     <Reference Include="XPath2, Version=1.1.3.0, Culture=neutral, PublicKeyToken=463c6d7fb740c7e5, processorArchitecture=MSIL">
       <HintPath>..\..\packages\XPath2.1.1.3\lib\net452\XPath2.dll</HintPath>
@@ -351,6 +368,17 @@
     <Compile Include="..\WireMock.Net.Console.Net452.Classic\Program.cs">
       <Link>Program.cs</Link>
     </Compile>
+    <Compile Include="Nullable\AllowNullAttribute.cs" />
+    <Compile Include="Nullable\DisallowNullAttribute.cs" />
+    <Compile Include="Nullable\DoesNotReturnAttribute.cs" />
+    <Compile Include="Nullable\DoesNotReturnIfAttribute.cs" />
+    <Compile Include="Nullable\MaybeNullAttribute.cs" />
+    <Compile Include="Nullable\MaybeNullWhenAttribute.cs" />
+    <Compile Include="Nullable\MemberNotNullAttribute.cs" />
+    <Compile Include="Nullable\MemberNotNullWhenAttribute.cs" />
+    <Compile Include="Nullable\NotNullAttribute.cs" />
+    <Compile Include="Nullable\NotNullIfNotNullAttribute.cs" />
+    <Compile Include="Nullable\NotNullWhenAttribute.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
   </ItemGroup>
   <ItemGroup>

examples/WireMock.Net.Console.Net472.Classic/packages.config

@@ -5,12 +5,12 @@
   <package id="Handlebars.Net" version="2.1.2" targetFramework="net472" />
   <package id="Handlebars.Net.Helpers" version="2.3.5" targetFramework="net472" />
   <package id="Handlebars.Net.Helpers.Core" version="2.3.5" targetFramework="net472" />
-  <package id="Handlebars.Net.Helpers.DynamicLinq" version="2.3.3" targetFramework="net472" />
-  <package id="Handlebars.Net.Helpers.Humanizer" version="2.3.3" targetFramework="net472" />
-  <package id="Handlebars.Net.Helpers.Json" version="2.3.3" targetFramework="net472" />
-  <package id="Handlebars.Net.Helpers.Random" version="2.3.3" targetFramework="net472" />
-  <package id="Handlebars.Net.Helpers.Xeger" version="2.3.3" targetFramework="net472" />
-  <package id="Handlebars.Net.Helpers.XPath" version="2.3.3" targetFramework="net472" />
+  <package id="Handlebars.Net.Helpers.DynamicLinq" version="2.3.5" targetFramework="net472" />
+  <package id="Handlebars.Net.Helpers.Humanizer" version="2.3.5" targetFramework="net472" />
+  <package id="Handlebars.Net.Helpers.Json" version="2.3.5" targetFramework="net472" />
+  <package id="Handlebars.Net.Helpers.Random" version="2.3.5" targetFramework="net472" />
+  <package id="Handlebars.Net.Helpers.Xeger" version="2.3.5" targetFramework="net472" />
+  <package id="Handlebars.Net.Helpers.XPath" version="2.3.5" targetFramework="net472" />
   <package id="Humanizer" version="2.14.1" targetFramework="net472" />
   <package id="Humanizer.Core" version="2.14.1" targetFramework="net472" />
   <package id="Humanizer.Core.af" version="2.14.1" targetFramework="net472" />
@@ -63,6 +63,7 @@
   <package id="Humanizer.Core.zh-Hant" version="2.14.1" targetFramework="net472" />
   <package id="JmesPath.Net" version="1.0.125" targetFramework="net472" />
   <package id="log4net" version="2.0.14" targetFramework="net472" />
+  <package id="Microsoft.AspNet.WebApi.Client" version="5.2.8" targetFramework="net472" />
   <package id="Microsoft.AspNetCore" version="2.2.0" targetFramework="net472" />
   <package id="Microsoft.AspNetCore.Authentication.Abstractions" version="2.2.0" targetFramework="net472" />
   <package id="Microsoft.AspNetCore.Authentication.Core" version="2.2.0" targetFramework="net472" />
@@ -119,8 +120,13 @@
   <package id="Microsoft.IdentityModel.Protocols.OpenIdConnect" version="6.12.2" targetFramework="net472" />
   <package id="Microsoft.IdentityModel.Tokens" version="6.12.2" targetFramework="net472" />
   <package id="Microsoft.Net.Http.Headers" version="2.2.0" targetFramework="net472" />
+  <package id="Namotion.Reflection" version="2.0.10" targetFramework="net472" />
   <package id="Newtonsoft.Json" version="13.0.1" targetFramework="net472" />
-  <package id="RandomDataGenerator.Net" version="1.0.14" targetFramework="net472" />
+  <package id="NJsonSchema" version="10.6.10" targetFramework="net472" />
+  <package id="NJsonSchema.Extensions" version="0.1.0" targetFramework="net472" />
+  <package id="NSwag.Core" version="13.15.10" targetFramework="net472" />
+  <package id="Nullable" version="1.3.0" targetFramework="net472" developmentDependency="true" />
+  <package id="RandomDataGenerator.Net" version="1.0.15" targetFramework="net472" />
   <package id="Scriban.Signed" version="2.1.4" targetFramework="net472" />
   <package id="SimMetrics.Net" version="1.0.5" targetFramework="net461" />
   <package id="Stef.Validation" version="0.1.0" targetFramework="net472" />
@@ -141,9 +147,9 @@
   <package id="System.Threading.Tasks.Extensions" version="4.5.1" targetFramework="net472" />
   <package id="System.ValueTuple" version="4.5.0" targetFramework="net472" />
   <package id="TinyMapper" version="3.0.3" targetFramework="net472" />
-  <package id="WireMock.Net" version="1.4.41" targetFramework="net472" />
-  <package id="WireMock.Net.Abstractions" version="1.4.41" targetFramework="net472" />
-  <package id="WireMock.Org.Abstractions" version="1.4.41" targetFramework="net472" />
+  <package id="WireMock.Net" version="1.5.1" targetFramework="net472" />
+  <package id="WireMock.Net.Abstractions" version="1.5.1" targetFramework="net472" />
+  <package id="WireMock.Org.Abstractions" version="1.5.1" targetFramework="net472" />
   <package id="XPath2" version="1.1.3" targetFramework="net472" />
   <package id="XPath2.Extensions" version="1.1.3" targetFramework="net472" />
 </packages>

examples/WireMock.Net.StandAlone.Net461/WireMock.Net.StandAlone.Net461.csproj

@@ -204,8 +204,8 @@
     <Reference Include="Owin, Version=1.0.0.0, Culture=neutral, PublicKeyToken=f0ebd12fd5e55cc5, processorArchitecture=MSIL">
       <HintPath>..\..\packages\Owin.1.0\lib\net40\Owin.dll</HintPath>
     </Reference>
-    <Reference Include="RestEase, Version=1.5.5.0, Culture=neutral, processorArchitecture=MSIL">
-      <HintPath>..\..\packages\RestEase.1.5.5\lib\net45\RestEase.dll</HintPath>
+    <Reference Include="RestEase, Version=1.5.7.0, Culture=neutral, processorArchitecture=MSIL">
+      <HintPath>..\..\packages\RestEase.1.5.7\lib\net452\RestEase.dll</HintPath>
     </Reference>
     <Reference Include="SimMetrics.Net, Version=1.0.5.0, Culture=neutral, PublicKeyToken=c58dc06d59f3391b, processorArchitecture=MSIL">
       <HintPath>..\..\packages\SimMetrics.Net.1.0.5\lib\net45\SimMetrics.Net.dll</HintPath>

examples/WireMock.Net.StandAlone.Net461/packages.config

@@ -15,7 +15,7 @@
   <package id="Microsoft.AspNetCore.Hosting" version="2.1.1" targetFramework="net461" />
   <package id="Microsoft.AspNetCore.Hosting.Abstractions" version="2.1.1" targetFramework="net461" />
   <package id="Microsoft.AspNetCore.Hosting.Server.Abstractions" version="2.1.1" targetFramework="net461" />
-  <package id="Microsoft.AspNetCore.Http" version="2.1.1" targetFramework="net461" />
+  <package id="Microsoft.AspNetCore.Http" version="2.1.22" targetFramework="net461" />
   <package id="Microsoft.AspNetCore.Http.Abstractions" version="2.1.1" targetFramework="net461" />
   <package id="Microsoft.AspNetCore.Http.Extensions" version="2.1.1" targetFramework="net461" />
   <package id="Microsoft.AspNetCore.Http.Features" version="2.1.1" targetFramework="net461" />
@@ -24,7 +24,7 @@
   <package id="Microsoft.AspNetCore.Routing.Abstractions" version="2.1.1" targetFramework="net461" />
   <package id="Microsoft.AspNetCore.Server.IISIntegration" version="2.1.2" targetFramework="net461" />
   <package id="Microsoft.AspNetCore.Server.Kestrel" version="2.1.3" targetFramework="net461" />
-  <package id="Microsoft.AspNetCore.Server.Kestrel.Core" version="2.1.3" targetFramework="net461" />
+  <package id="Microsoft.AspNetCore.Server.Kestrel.Core" version="2.1.7" targetFramework="net461" />
   <package id="Microsoft.AspNetCore.Server.Kestrel.Https" version="2.1.3" targetFramework="net461" />
   <package id="Microsoft.AspNetCore.Server.Kestrel.Transport.Abstractions" version="2.1.3" targetFramework="net461" />
   <package id="Microsoft.AspNetCore.Server.Kestrel.Transport.Sockets" version="2.1.3" targetFramework="net461" />
@@ -59,7 +59,7 @@
   <package id="MimeKitLite" version="2.0.7" targetFramework="net461" />
   <package id="Newtonsoft.Json" version="13.0.1" targetFramework="net461" />
   <package id="Owin" version="1.0" targetFramework="net461" />
-  <package id="RestEase" version="1.5.5" targetFramework="net461" />
+  <package id="RestEase" version="1.5.7" targetFramework="net461" />
   <package id="SimMetrics.Net" version="1.0.5" targetFramework="net461" />
   <package id="System.Buffers" version="4.5.0" targetFramework="net461" />
   <package id="System.Collections.Immutable" version="1.5.0" targetFramework="net461" />

examples/WireMock.Net.WebApplication.NETCore2/WireMock.Net.WebApplication.NETCore2.csproj

@@ -12,7 +12,7 @@
   <ItemGroup Condition=" '$(TargetFramework)' == 'netcoreapp2.0'">
     <DotNetCliToolReference Include="Microsoft.VisualStudio.Web.CodeGeneration.Tools" Version="2.0.2" />
     <PackageReference Include="Microsoft.AspNetCore.All" Version="2.0.9" />
-    <PackageReference Include="Newtonsoft.Json" Version="11.0.2" />
+    <PackageReference Include="Newtonsoft.Json" Version="13.0.1" />
   </ItemGroup>
 
   <ItemGroup Condition=" '$(TargetFramework)' == 'netcoreapp2.1'">

src/WireMock.Net.Abstractions/Admin/Mappings/MatcherModel.cs

@@ -1,48 +1,52 @@
-namespace WireMock.Admin.Mappings
+namespace WireMock.Admin.Mappings;
+
+/// <summary>
+/// MatcherModel
+/// </summary>
+[FluentBuilder.AutoGenerateBuilder]
+public class MatcherModel
 {
     /// <summary>
-    /// MatcherModel
+    /// Gets or sets the name.
     /// </summary>
-    [FluentBuilder.AutoGenerateBuilder]
-    public class MatcherModel
-    {
-        /// <summary>
-        /// Gets or sets the name.
-        /// </summary>
-        public string Name { get; set; }
+    public string Name { get; set; } = null!;
 
-        /// <summary>
-        /// Gets or sets the pattern. Can be a string (default) or an object.
-        /// </summary>
-        public object? Pattern { get; set; }
+    /// <summary>
+    /// Gets or sets the pattern. Can be a string (default) or an object.
+    /// </summary>
+    public object? Pattern { get; set; }
 
-        /// <summary>
-        /// Gets or sets the patterns. Can be array of strings (default) or an array of objects.
-        /// </summary>
-        public object[]? Patterns { get; set; }
+    /// <summary>
+    /// Gets or sets the patterns. Can be array of strings (default) or an array of objects.
+    /// </summary>
+    public object[]? Patterns { get; set; }
 
-        /// <summary>
-        /// Gets or sets the pattern as a file.
-        /// </summary>
-        public string? PatternAsFile { get; set; }
+    /// <summary>
+    /// Gets or sets the pattern as a file.
+    /// </summary>
+    public string? PatternAsFile { get; set; }
 
-        /// <summary>
-        /// Gets or sets the ignore case.
-        /// </summary>
-        public bool? IgnoreCase { get; set; }
+    /// <summary>
+    /// Gets or sets the ignore case.
+    /// </summary>
+    public bool? IgnoreCase { get; set; }
 
-        /// <summary>
-        /// Reject on match.
-        /// </summary>
-        public bool? RejectOnMatch { get; set; }
+    /// <summary>
+    /// Reject on match.
+    /// </summary>
+    public bool? RejectOnMatch { get; set; }
 
-        /// <summary>
-        /// The Operator to use when multiple patterns are defined. Optional.
-        /// - null      = Same as "or".
-        /// - "or"      = Only one pattern should match.
-        /// - "and"     = All patterns should match.
-        /// - "average" = The average value from all patterns.
-        /// </summary>
-        public string? MatchOperator { get; set; }
-    }
+    /// <summary>
+    /// The Operator to use when multiple patterns are defined. Optional.
+    /// - null      = Same as "or".
+    /// - "or"      = Only one pattern should match.
+    /// - "and"     = All patterns should match.
+    /// - "average" = The average value from all patterns.
+    /// </summary>
+    public string? MatchOperator { get; set; }
+
+    /// <summary>
+    /// Support Regex, only used for JsonPartialMatcher.
+    /// </summary>
+    public bool? Regex { get; set; }
 }

src/WireMock.Net.Abstractions/Admin/Mappings/WebhookRequestModel.cs

@@ -15,24 +15,24 @@ namespace WireMock.Admin.Mappings
         public string Url { get; set; }
 
         /// <summary>
-        /// The methods
+        /// The method
         /// </summary>
         public string Method { get; set; }
 
         /// <summary>
         /// Gets or sets the headers.
         /// </summary>
-        public IDictionary<string, string> Headers { get; set; }
+        public IDictionary<string, string>? Headers { get; set; }
 
         /// <summary>
         /// Gets or sets the body.
         /// </summary>
-        public string Body { get; set; }
+        public string? Body { get; set; }
 
         /// <summary>
         /// Gets or sets the body (as JSON object).
         /// </summary>
-        public object BodyAsJson { get; set; }
+        public object? BodyAsJson { get; set; }
 
         /// <summary>
         /// Use ResponseMessage Transformer.

src/WireMock.Net.Abstractions/Matchers/Request/IRequestMatcher.cs

@@ -1,20 +1,17 @@
-using JetBrains.Annotations;
+namespace WireMock.Matchers.Request;
 
-namespace WireMock.Matchers.Request
+/// <summary>
+/// The RequestMatcher interface.
+/// </summary>
+public interface IRequestMatcher
 {
     /// <summary>
-    /// The RequestMatcher interface.
+    /// Determines whether the specified RequestMessage is match.
     /// </summary>
-    public interface IRequestMatcher
-    {
-        /// <summary>
-        /// Determines whether the specified RequestMessage is match.
-        /// </summary>
-        /// <param name="requestMessage">The RequestMessage.</param>
-        /// <param name="requestMatchResult">The RequestMatchResult.</param>
-        /// <returns>
-        /// A value between 0.0 - 1.0 of the similarity.
-        /// </returns>
-        double GetMatchingScore(IRequestMessage requestMessage, IRequestMatchResult requestMatchResult);
-    }
+    /// <param name="requestMessage">The RequestMessage.</param>
+    /// <param name="requestMatchResult">The RequestMatchResult.</param>
+    /// <returns>
+    /// A value between 0.0 - 1.0 of the similarity.
+    /// </returns>
+    double GetMatchingScore(IRequestMessage requestMessage, IRequestMatchResult requestMatchResult);
 }

src/WireMock.Net.Abstractions/WireMock.Net.Abstractions.csproj

@@ -35,7 +35,7 @@
         <PackageReference Include="Microsoft.SourceLink.GitHub" Version="1.1.1" PrivateAssets="All" />
 
         <!-- See also https://mstack.nl/blog/20210801-source-generators -->
-        <PackageReference Include="FluentBuilder" Version="0.4.4">
+        <PackageReference Include="FluentBuilder" Version="0.4.9">
             <PrivateAssets>all</PrivateAssets>
             <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
         </PackageReference>

src/WireMock.Net.RestClient/WireMock.Net.RestClient.csproj

@@ -31,7 +31,7 @@
 
   <ItemGroup>
     <PackageReference Include="Microsoft.SourceLink.GitHub" Version="1.1.1" PrivateAssets="All" />
-    <PackageReference Include="RestEase" Version="1.5.6" />
+    <PackageReference Include="RestEase" Version="1.5.7" />
   </ItemGroup>
 
   <ItemGroup>

src/WireMock.Net/Http/HttpResponseMessageHelper.cs

@@ -5,60 +5,64 @@ using System.Net.Http;
 using System.Threading.Tasks;
 using WireMock.Util;
 
-namespace WireMock.Http
+namespace WireMock.Http;
+
+internal static class HttpResponseMessageHelper
 {
-    internal static class HttpResponseMessageHelper
+    public static async Task<ResponseMessage> CreateAsync(
+        HttpResponseMessage httpResponseMessage,
+        Uri requiredUri,
+        Uri originalUri,
+        bool deserializeJson,
+        bool decompressGzipAndDeflate)
     {
-        public static async Task<ResponseMessage> CreateAsync(HttpResponseMessage httpResponseMessage, Uri requiredUri, Uri originalUri, bool deserializeJson, bool decompressGzipAndDeflate)
+        var responseMessage = new ResponseMessage { StatusCode = (int)httpResponseMessage.StatusCode };
+
+        // Set both content and response headers, replacing URLs in values
+        var headers = (httpResponseMessage.Content?.Headers.Union(httpResponseMessage.Headers) ?? Enumerable.Empty<KeyValuePair<string, IEnumerable<string>>>()).ToArray();
+        if (httpResponseMessage.Content != null)
         {
-            var responseMessage = new ResponseMessage { StatusCode = (int)httpResponseMessage.StatusCode };
-
-            // Set both content and response headers, replacing URLs in values
-            var headers = (httpResponseMessage.Content?.Headers.Union(httpResponseMessage.Headers) ?? Enumerable.Empty<KeyValuePair<string, IEnumerable<string>>>()).ToArray();
-            if (httpResponseMessage.Content != null)
+            var stream = await httpResponseMessage.Content.ReadAsStreamAsync().ConfigureAwait(false);
+            IEnumerable<string>? contentTypeHeader = null;
+            if (headers.Any(header => string.Equals(header.Key, HttpKnownHeaderNames.ContentType, StringComparison.OrdinalIgnoreCase)))
             {
-                var stream = await httpResponseMessage.Content.ReadAsStreamAsync().ConfigureAwait(false);
-                IEnumerable<string> contentTypeHeader = null;
-                if (headers.Any(header => string.Equals(header.Key, HttpKnownHeaderNames.ContentType, StringComparison.OrdinalIgnoreCase)))
-                {
-                    contentTypeHeader = headers.First(header => string.Equals(header.Key, HttpKnownHeaderNames.ContentType, StringComparison.OrdinalIgnoreCase)).Value;
-                }
-
-                IEnumerable<string> contentEncodingHeader = null;
-                if (headers.Any(header => string.Equals(header.Key, HttpKnownHeaderNames.ContentEncoding, StringComparison.OrdinalIgnoreCase)))
-                {
-                    contentEncodingHeader = headers.First(header => string.Equals(header.Key, HttpKnownHeaderNames.ContentEncoding, StringComparison.OrdinalIgnoreCase)).Value;
-                }
-
-                var bodyParserSettings = new BodyParserSettings
-                {
-                    Stream = stream,
-                    ContentType = contentTypeHeader?.FirstOrDefault(),
-                    DeserializeJson = deserializeJson,
-                    ContentEncoding = contentEncodingHeader?.FirstOrDefault(),
-                    DecompressGZipAndDeflate = decompressGzipAndDeflate
-                };
-                responseMessage.BodyData = await BodyParser.ParseAsync(bodyParserSettings).ConfigureAwait(false);
+                contentTypeHeader = headers.First(header => string.Equals(header.Key, HttpKnownHeaderNames.ContentType, StringComparison.OrdinalIgnoreCase)).Value;
             }
 
-            foreach (var header in headers)
+            IEnumerable<string>? contentEncodingHeader = null;
+            if (headers.Any(header => string.Equals(header.Key, HttpKnownHeaderNames.ContentEncoding, StringComparison.OrdinalIgnoreCase)))
             {
-                // If Location header contains absolute redirect URL, and base URL is one that we proxy to,
-                // we need to replace it to original one.
-                if (string.Equals(header.Key, HttpKnownHeaderNames.Location, StringComparison.OrdinalIgnoreCase)
-                    && Uri.TryCreate(header.Value.First(), UriKind.Absolute, out Uri absoluteLocationUri)
-                    && string.Equals(absoluteLocationUri.Host, requiredUri.Host, StringComparison.OrdinalIgnoreCase))
-                {
-                    var replacedLocationUri = new Uri(originalUri, absoluteLocationUri.PathAndQuery);
-                    responseMessage.AddHeader(header.Key, replacedLocationUri.ToString());
-                }
-                else
-                {
-                    responseMessage.AddHeader(header.Key, header.Value.ToArray());
-                }
+                contentEncodingHeader = headers.First(header => string.Equals(header.Key, HttpKnownHeaderNames.ContentEncoding, StringComparison.OrdinalIgnoreCase)).Value;
             }
 
-            return responseMessage;
+            var bodyParserSettings = new BodyParserSettings
+            {
+                Stream = stream,
+                ContentType = contentTypeHeader?.FirstOrDefault(),
+                DeserializeJson = deserializeJson,
+                ContentEncoding = contentEncodingHeader?.FirstOrDefault(),
+                DecompressGZipAndDeflate = decompressGzipAndDeflate
+            };
+            responseMessage.BodyData = await BodyParser.ParseAsync(bodyParserSettings).ConfigureAwait(false);
         }
+
+        foreach (var header in headers)
+        {
+            // If Location header contains absolute redirect URL, and base URL is one that we proxy to,
+            // we need to replace it to original one.
+            if (string.Equals(header.Key, HttpKnownHeaderNames.Location, StringComparison.OrdinalIgnoreCase)
+                && Uri.TryCreate(header.Value.First(), UriKind.Absolute, out Uri absoluteLocationUri)
+                && string.Equals(absoluteLocationUri.Host, requiredUri.Host, StringComparison.OrdinalIgnoreCase))
+            {
+                var replacedLocationUri = new Uri(originalUri, absoluteLocationUri.PathAndQuery);
+                responseMessage.AddHeader(header.Key, replacedLocationUri.ToString());
+            }
+            else
+            {
+                responseMessage.AddHeader(header.Key, header.Value.ToArray());
+            }
+        }
+
+        return responseMessage;
     }
 }

src/WireMock.Net/Matchers/AbstractJsonPartialMatcher.cs

@@ -1,6 +1,7 @@
 using System.Collections.Generic;
 using System.Linq;
 using Newtonsoft.Json.Linq;
+using WireMock.Util;
 
 namespace WireMock.Matchers;
 
@@ -9,15 +10,22 @@ namespace WireMock.Matchers;
 /// </summary>
 public abstract class AbstractJsonPartialMatcher : JsonMatcher
 {
+    /// <summary>
+    /// Support Regex
+    /// </summary>
+    public bool Regex { get; }
+
     /// <summary>
     /// Initializes a new instance of the <see cref="AbstractJsonPartialMatcher"/> class.
     /// </summary>
     /// <param name="value">The string value to check for equality.</param>
     /// <param name="ignoreCase">Ignore the case from the PropertyName and PropertyValue (string only).</param>
     /// <param name="throwException">Throw an exception when the internal matching fails because of invalid input.</param>
-    protected AbstractJsonPartialMatcher(string value, bool ignoreCase = false, bool throwException = false) 
+    /// <param name="regex">Support Regex.</param>
+    protected AbstractJsonPartialMatcher(string value, bool ignoreCase = false, bool throwException = false, bool regex = false)
         : base(value, ignoreCase, throwException)
     {
+        Regex = regex;
     }
 
     /// <summary>
@@ -26,9 +34,11 @@ public abstract class AbstractJsonPartialMatcher : JsonMatcher
     /// <param name="value">The object value to check for equality.</param>
     /// <param name="ignoreCase">Ignore the case from the PropertyName and PropertyValue (string only).</param>
     /// <param name="throwException">Throw an exception when the internal matching fails because of invalid input.</param>
-    protected AbstractJsonPartialMatcher(object value, bool ignoreCase = false, bool throwException = false) 
+    /// <param name="regex">Support Regex.</param>
+    protected AbstractJsonPartialMatcher(object value, bool ignoreCase = false, bool throwException = false, bool regex = false)
         : base(value, ignoreCase, throwException)
     {
+        Regex = regex;
     }
 
     /// <summary>
@@ -38,9 +48,11 @@ public abstract class AbstractJsonPartialMatcher : JsonMatcher
     /// <param name="value">The value to check for equality.</param>
     /// <param name="ignoreCase">Ignore the case from the PropertyName and PropertyValue (string only).</param>
     /// <param name="throwException">Throw an exception when the internal matching fails because of invalid input.</param>
-    protected AbstractJsonPartialMatcher(MatchBehaviour matchBehaviour, object value, bool ignoreCase = false, bool throwException = false) 
+    /// <param name="regex">Support Regex.</param>
+    protected AbstractJsonPartialMatcher(MatchBehaviour matchBehaviour, object value, bool ignoreCase = false, bool throwException = false, bool regex = false)
         : base(matchBehaviour, value, ignoreCase, throwException)
     {
+        Regex = regex;
     }
 
     /// <inheritdoc />
@@ -51,6 +63,17 @@ public abstract class AbstractJsonPartialMatcher : JsonMatcher
             return true;
         }
 
+        if (Regex && value.Type == JTokenType.String && input != null)
+        {
+            var valueAsString = value.ToString();
+            
+            var (valid, result) = RegexUtils.MatchRegex(valueAsString, input.ToString());
+            if (valid)
+            {
+                return result;
+            }
+        }
+
         if (input == null || value.Type != input.Type)
         {
             return false;

src/WireMock.Net/Matchers/JsonMatcher.cs

@@ -13,12 +13,12 @@ namespace WireMock.Matchers;
 /// </summary>
 public class JsonMatcher : IValueMatcher, IIgnoreCaseMatcher
 {
-    /// <inheritdoc cref="IValueMatcher.Value"/>
-    public object Value { get; }
-
     /// <inheritdoc cref="IMatcher.Name"/>
     public virtual string Name => "JsonMatcher";
 
+    /// <inheritdoc cref="IValueMatcher.Value"/>
+    public object Value { get; }
+    
     /// <inheritdoc cref="IMatcher.MatchBehaviour"/>
     public MatchBehaviour MatchBehaviour { get; }
 
@@ -68,9 +68,7 @@ public class JsonMatcher : IValueMatcher, IIgnoreCaseMatcher
 
         Value = value;
         _valueAsJToken = ConvertValueToJToken(value);
-        _jTokenConverter = ignoreCase
-            ? (Func<JToken, JToken>)Rename
-            : jToken => jToken;
+        _jTokenConverter = ignoreCase ? Rename : jToken => jToken;
     }
 
     /// <inheritdoc cref="IObjectMatcher.IsMatch"/>

src/WireMock.Net/Matchers/JsonPartialMatcher.cs

@@ -9,20 +9,20 @@ public class JsonPartialMatcher : AbstractJsonPartialMatcher
     public override string Name => nameof(JsonPartialMatcher);
 
     /// <inheritdoc />
-    public JsonPartialMatcher(string value, bool ignoreCase = false, bool throwException = false)
-        : base(value, ignoreCase, throwException)
+    public JsonPartialMatcher(string value, bool ignoreCase = false, bool throwException = false, bool regex = false)
+        : base(value, ignoreCase, throwException, regex)
     {
     }
 
     /// <inheritdoc />
-    public JsonPartialMatcher(object value, bool ignoreCase = false, bool throwException = false)
-        : base(value, ignoreCase, throwException)
+    public JsonPartialMatcher(object value, bool ignoreCase = false, bool throwException = false, bool regex = false)
+        : base(value, ignoreCase, throwException, regex)
     {
     }
 
     /// <inheritdoc />
-    public JsonPartialMatcher(MatchBehaviour matchBehaviour, object value, bool ignoreCase = false, bool throwException = false)
-        : base(matchBehaviour, value, ignoreCase, throwException)
+    public JsonPartialMatcher(MatchBehaviour matchBehaviour, object value, bool ignoreCase = false, bool throwException = false, bool regex = false)
+        : base(matchBehaviour, value, ignoreCase, throwException, regex)
     {
     }
 

src/WireMock.Net/Matchers/JsonPartialWildCardMatcher.cs

@@ -1,5 +1,3 @@
-using JetBrains.Annotations;
-
 namespace WireMock.Matchers;
 
 /// <summary>
@@ -11,20 +9,20 @@ public class JsonPartialWildcardMatcher : AbstractJsonPartialMatcher
     public override string Name => nameof(JsonPartialWildcardMatcher);
 
     /// <inheritdoc />
-    public JsonPartialWildcardMatcher(string value, bool ignoreCase = false, bool throwException = false)
-        : base(value, ignoreCase, throwException)
+    public JsonPartialWildcardMatcher(string value, bool ignoreCase = false, bool throwException = false, bool regex = false)
+        : base(value, ignoreCase, throwException, regex)
     {
     }
 
     /// <inheritdoc />
-    public JsonPartialWildcardMatcher(object value, bool ignoreCase = false, bool throwException = false)
-        : base(value, ignoreCase, throwException)
+    public JsonPartialWildcardMatcher(object value, bool ignoreCase = false, bool throwException = false, bool regex = false)
+        : base(value, ignoreCase, throwException, regex)
     {
     }
 
     /// <inheritdoc />
-    public JsonPartialWildcardMatcher(MatchBehaviour matchBehaviour, object value, bool ignoreCase = false, bool throwException = false)
-        : base(matchBehaviour, value, ignoreCase, throwException)
+    public JsonPartialWildcardMatcher(MatchBehaviour matchBehaviour, object value, bool ignoreCase = false, bool throwException = false, bool regex = false)
+        : base(matchBehaviour, value, ignoreCase, throwException, regex)
     {
     }
 

src/WireMock.Net/Matchers/Request/RequestMessageHeaderMatcher.cs

@@ -23,7 +23,7 @@ public class RequestMessageHeaderMatcher : IRequestMatcher
     /// <summary>
     /// The name
     /// </summary>
-    public string? Name { get; }
+    public string Name { get; }
 
     /// <value>
     /// The matchers.
@@ -94,6 +94,7 @@ public class RequestMessageHeaderMatcher : IRequestMatcher
     public RequestMessageHeaderMatcher(params Func<IDictionary<string, string[]>, bool>[] funcs)
     {
         Funcs = Guard.NotNull(funcs);
+        Name = string.Empty; // Not used when Func, but set to a non-null valid value.
     }
 
     /// <inheritdoc />
@@ -121,7 +122,7 @@ public class RequestMessageHeaderMatcher : IRequestMatcher
 
         if (Matchers != null)
         {
-            if (!headers.ContainsKey(Name!))
+            if (!headers.ContainsKey(Name))
             {
                 return MatchBehaviourHelper.Convert(_matchBehaviour, MatchScores.Mismatch);
             }
@@ -129,7 +130,7 @@ public class RequestMessageHeaderMatcher : IRequestMatcher
             var results = new List<double>();
             foreach (var matcher in Matchers)
             {
-                var resultsPerMatcher = headers[Name!].Select(v => matcher.IsMatch(v)).ToArray();
+                var resultsPerMatcher = headers[Name].Select(v => matcher.IsMatch(v)).ToArray();
 
                 results.Add(MatchScores.ToScore(resultsPerMatcher, MatchOperator.And));
             }

src/WireMock.Net/Matchers/Request/RequestMessageParamMatcher.cs

@@ -92,7 +92,7 @@ public class RequestMessageParamMatcher : IRequestMatcher
             return MatchScores.ToScore(requestMessage.Query != null && Funcs.Any(f => f(requestMessage.Query)));
         }
 
-        WireMockList<string> valuesPresentInRequestMessage = ((RequestMessage)requestMessage).GetParameter(Key, IgnoreCase ?? false);
+        var valuesPresentInRequestMessage = ((RequestMessage)requestMessage).GetParameter(Key!, IgnoreCase ?? false);
         if (valuesPresentInRequestMessage == null)
         {
             // Key is not present at all, just return Mismatch
@@ -102,7 +102,7 @@ public class RequestMessageParamMatcher : IRequestMatcher
         if (Matchers != null && Matchers.Any())
         {
             // Return the score based on Matchers and valuesPresentInRequestMessage
-            return CalculateScore(valuesPresentInRequestMessage);
+            return CalculateScore(Matchers, valuesPresentInRequestMessage);
         }
 
         if (Matchers == null || !Matchers.Any())
@@ -114,14 +114,14 @@ public class RequestMessageParamMatcher : IRequestMatcher
         return MatchScores.Mismatch;
     }
 
-    private double CalculateScore(WireMockList<string> valuesPresentInRequestMessage)
+    private double CalculateScore(IReadOnlyList<IStringMatcher> matchers, WireMockList<string> valuesPresentInRequestMessage)
     {
         var total = new List<double>();
 
         // If the total patterns in all matchers > values in message, use the matcher as base
-        if (Matchers.Sum(m => m.GetPatterns().Length) > valuesPresentInRequestMessage.Count)
+        if (matchers.Sum(m => m.GetPatterns().Length) > valuesPresentInRequestMessage.Count)
         {
-            foreach (var matcher in Matchers)
+            foreach (var matcher in matchers)
             {
                 double score = 0d;
                 foreach (string valuePresentInRequestMessage in valuesPresentInRequestMessage)
@@ -136,7 +136,7 @@ public class RequestMessageParamMatcher : IRequestMatcher
         {
             foreach (string valuePresentInRequestMessage in valuesPresentInRequestMessage)
             {
-                double score = Matchers.Max(m => m.IsMatch(valuePresentInRequestMessage));
+                double score = matchers.Max(m => m.IsMatch(valuePresentInRequestMessage));
                 total.Add(score);
             }
         }

src/WireMock.Net/Owin/Mappers/OwinRequestMapper.cs

@@ -27,8 +27,8 @@ namespace WireMock.Owin.Mappers
 
             string method = request.Method;
 
-            Dictionary<string, string[]> headers = null;
-            IEnumerable<string> contentEncodingHeader = null;
+            Dictionary<string, string[]>? headers = null;
+            IEnumerable<string>? contentEncodingHeader = null;
             if (request.Headers.Any())
             {
                 headers = new Dictionary<string, string[]>();
@@ -43,7 +43,7 @@ namespace WireMock.Owin.Mappers
                 }
             }
 
-            IDictionary<string, string> cookies = null;
+            IDictionary<string, string>? cookies = null;
             if (request.Cookies.Any())
             {
                 cookies = new Dictionary<string, string>();
@@ -53,7 +53,7 @@ namespace WireMock.Owin.Mappers
                 }
             }
 
-            IBodyData body = null;
+            IBodyData? body = null;
             if (request.Body != null && BodyParser.ShouldParseBody(method, options.AllowBodyForAllHttpMethods == true))
             {
                 var bodyParserSettings = new BodyParserSettings

src/WireMock.Net/Pact/Models/V2/Interaction.cs

@@ -1,13 +1,12 @@
-namespace WireMock.Pact.Models.V2
+namespace WireMock.Pact.Models.V2;
+
+public class Interaction
 {
-    public class Interaction
-    {
-        public string Description { get; set; } = string.Empty;
+    public string Description { get; set; } = string.Empty;
 
-        public string ProviderState { get; set; }
+    public string ProviderState { get; set; }
 
-        public Request Request { get; set; } = new Request();
+    public PactRequest Request { get; set; } = new PactRequest();
 
-        public Response Response { get; set; } = new Response();
-    }
+    public PactResponse Response { get; set; } = new PactResponse();
 }

src/WireMock.Net/Pact/Models/V2/PactRequest.cs

@@ -2,7 +2,7 @@ using System.Collections.Generic;
 
 namespace WireMock.Pact.Models.V2;
 
-public class Request
+public class PactRequest
 {
     public IDictionary<string, string>? Headers { get; set; }
 

src/WireMock.Net/Pact/Models/V2/PactResponse.cs

@@ -2,7 +2,7 @@ using System.Collections.Generic;
 
 namespace WireMock.Pact.Models.V2;
 
-public class Response
+public class PactResponse
 {
     public object? Body { get; set; }
 

src/WireMock.Net/RegularExpressions/RegexExtended.cs

@@ -3,88 +3,87 @@ using System.Collections.Generic;
 using System.Text.RegularExpressions;
 using Stef.Validation;
 
-namespace WireMock.RegularExpressions
+namespace WireMock.RegularExpressions;
+
+/// <summary>
+/// Extension to the <see cref="Regex"/> object, adding support for GUID tokens for matching on.
+/// </summary>
+#if !NETSTANDARD1_3
+[Serializable]
+#endif
+internal class RegexExtended : Regex
 {
-    /// <summary>
-    /// Extension to the <see cref="Regex"/> object, adding support for GUID tokens for matching on.
-    /// </summary>
-#if !NETSTANDARD1_3
-    [Serializable]
-#endif
-    internal class RegexExtended : Regex
+    /// <inheritdoc cref="Regex"/>
+    public RegexExtended(string pattern) : this(pattern, RegexOptions.None)
     {
-        /// <inheritdoc cref="Regex"/>
-        public RegexExtended(string pattern) : this(pattern, RegexOptions.None)
-        {
-        }
+    }
 
-        /// <inheritdoc cref="Regex"/>
-        public RegexExtended(string pattern, RegexOptions options) :
-            this(pattern, options, Regex.InfiniteMatchTimeout)
-        {
-        }
+    /// <inheritdoc cref="Regex"/>
+    public RegexExtended(string pattern, RegexOptions options) :
+        this(pattern, options, Regex.InfiniteMatchTimeout)
+    {
+    }
 
-        /// <inheritdoc cref="Regex"/>
-        public RegexExtended(string pattern, RegexOptions options, TimeSpan matchTimeout) :
-            base(ReplaceGuidPattern(pattern), options, matchTimeout)
-        {
-        }
+    /// <inheritdoc cref="Regex"/>
+    public RegexExtended(string pattern, RegexOptions options, TimeSpan matchTimeout) :
+        base(ReplaceGuidPattern(pattern), options, matchTimeout)
+    {
+    }
 
 #if !NETSTANDARD1_3
-        /// <inheritdoc cref="Regex"/>
-        protected RegexExtended(System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context) :
-            base(info, context)
-        {
-        }
+    /// <inheritdoc cref="Regex"/>
+    protected RegexExtended(System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context) :
+        base(info, context)
+    {
+    }
 #endif
-        // Dictionary of various Guid tokens with a corresponding regular expression pattern to use instead.
-        private static readonly Dictionary<string, string> GuidTokenPatterns = new Dictionary<string, string>
+    // Dictionary of various Guid tokens with a corresponding regular expression pattern to use instead.
+    private static readonly Dictionary<string, string> GuidTokenPatterns = new()
+    {
+        // Lower case format `B` Guid pattern
+        { @"\guidb", @"(\{[a-z0-9]{8}-([a-z0-9]{4}-){3}[a-z0-9]{12}\})" },
+
+        // Upper case format `B` Guid pattern
+        { @"\GUIDB", @"(\{[A-Z0-9]{8}-([A-Z0-9]{4}-){3}[A-Z0-9]{12}\})" },
+
+        // Lower case format `D` Guid pattern
+        { @"\guidd", "([a-z0-9]{8}-([a-z0-9]{4}-){3}[a-z0-9]{12})" },
+
+        // Upper case format `D` Guid pattern
+        { @"\GUIDD", "([A-Z0-9]{8}-([A-Z0-9]{4}-){3}[A-Z0-9]{12})" },
+
+        // Lower case format `N` Guid pattern
+        { @"\guidn", "([a-z0-9]{32})" },
+
+        // Upper case format `N` Guid pattern
+        { @"\GUIDN", "([A-Z0-9]{32})" },
+
+        // Lower case format `P` Guid pattern
+        { @"\guidp", @"(\([a-z0-9]{8}-([a-z0-9]{4}-){3}[a-z0-9]{12}\))" },
+
+        // Upper case format `P` Guid pattern
+        { @"\GUIDP", @"(\([A-Z0-9]{8}-([A-Z0-9]{4}-){3}[A-Z0-9]{12}\))" },
+
+        // Lower case format `X` Guid pattern
+        { @"\guidx", @"(\{0x[a-f0-9]{8},0x[a-f0-9]{4},0x[a-f0-9]{4},\{(0x[a-f0-9]{2},){7}(0x[a-f0-9]{2})\}\})" },
+
+        // Upper case format `X` Guid pattern
+        { @"\GUIDX", @"(\{0x[A-F0-9]{8},0x[A-F0-9]{4},0x[A-F0-9]{4},\{(0x[A-F0-9]{2},){7}(0x[A-F0-9]{2})\}\})" },
+    };
+
+    /// <summary>
+    /// Replaces all instances of valid GUID tokens with the correct regular expression to match.
+    /// </summary>
+    /// <param name="pattern">Pattern to replace token for.</param>
+    private static string ReplaceGuidPattern(string pattern)
+    {
+        Guard.NotNull(pattern, nameof(pattern));
+
+        foreach (var tokenPattern in GuidTokenPatterns)
         {
-            // Lower case format `B` Guid pattern
-            { @"\guidb", @"(\{[a-z0-9]{8}-([a-z0-9]{4}-){3}[a-z0-9]{12}\})" },
-
-            // Upper case format `B` Guid pattern
-            { @"\GUIDB", @"(\{[A-Z0-9]{8}-([A-Z0-9]{4}-){3}[A-Z0-9]{12}\})" },
-
-            // Lower case format `D` Guid pattern
-            { @"\guidd", "([a-z0-9]{8}-([a-z0-9]{4}-){3}[a-z0-9]{12})" },
-
-            // Upper case format `D` Guid pattern
-            { @"\GUIDD", "([A-Z0-9]{8}-([A-Z0-9]{4}-){3}[A-Z0-9]{12})" },
-
-            // Lower case format `N` Guid pattern
-            { @"\guidn", "([a-z0-9]{32})" },
-
-            // Upper case format `N` Guid pattern
-            { @"\GUIDN", "([A-Z0-9]{32})" },
-
-            // Lower case format `P` Guid pattern
-            { @"\guidp", @"(\([a-z0-9]{8}-([a-z0-9]{4}-){3}[a-z0-9]{12}\))" },
-
-            // Upper case format `P` Guid pattern
-            { @"\GUIDP", @"(\([A-Z0-9]{8}-([A-Z0-9]{4}-){3}[A-Z0-9]{12}\))" },
-
-            // Lower case format `X` Guid pattern
-            { @"\guidx", @"(\{0x[a-f0-9]{8},0x[a-f0-9]{4},0x[a-f0-9]{4},\{(0x[a-f0-9]{2},){7}(0x[a-f0-9]{2})\}\})" },
-
-            // Upper case format `X` Guid pattern
-            { @"\GUIDX", @"(\{0x[A-F0-9]{8},0x[A-F0-9]{4},0x[A-F0-9]{4},\{(0x[A-F0-9]{2},){7}(0x[A-F0-9]{2})\}\})" },
-        };
-
-        /// <summary>
-        /// Replaces all instances of valid GUID tokens with the correct regular expression to match.
-        /// </summary>
-        /// <param name="pattern">Pattern to replace token for.</param>
-        private static string ReplaceGuidPattern(string pattern)
-        {
-            Guard.NotNull(pattern, nameof(pattern));
-
-            foreach (var tokenPattern in GuidTokenPatterns)
-            {
-                pattern = pattern.Replace(tokenPattern.Key, tokenPattern.Value);
-            }
-
-            return pattern;
+            pattern = pattern.Replace(tokenPattern.Key, tokenPattern.Value);
         }
+
+        return pattern;
     }
 }

src/WireMock.Net/RequestMessage.cs

@@ -1,159 +1,157 @@
 // This source file is based on mock4net by Alexandre Victoor which is licensed under the Apache 2.0 License.
 // For more details see 'mock4net/LICENSE.txt' and 'mock4net/readme.md' in this project root.
-using JetBrains.Annotations;
 using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Net;
+using Stef.Validation;
 using WireMock.Models;
 using WireMock.Types;
 using WireMock.Util;
-using Stef.Validation;
 
-namespace WireMock
+namespace WireMock;
+
+/// <summary>
+/// The RequestMessage.
+/// </summary>
+public class RequestMessage : IRequestMessage
 {
+    /// <inheritdoc cref="IRequestMessage.ClientIP" />
+    public string ClientIP { get; }
+
+    /// <inheritdoc cref="IRequestMessage.Url" />
+    public string Url { get; }
+
+    /// <inheritdoc cref="IRequestMessage.AbsoluteUrl" />
+    public string AbsoluteUrl { get; }
+
+    /// <inheritdoc cref="IRequestMessage.ProxyUrl" />
+    public string ProxyUrl { get; set; }
+
+    /// <inheritdoc cref="IRequestMessage.DateTime" />
+    public DateTime DateTime { get; set; }
+
+    /// <inheritdoc cref="IRequestMessage.Path" />
+    public string Path { get; }
+
+    /// <inheritdoc cref="IRequestMessage.AbsolutePath" />
+    public string AbsolutePath { get; }
+
+    /// <inheritdoc cref="IRequestMessage.PathSegments" />
+    public string[] PathSegments { get; }
+
+    /// <inheritdoc cref="IRequestMessage.AbsolutePathSegments" />
+    public string[] AbsolutePathSegments { get; }
+
+    /// <inheritdoc cref="IRequestMessage.Method" />
+    public string Method { get; }
+
+    /// <inheritdoc cref="IRequestMessage.Headers" />
+    public IDictionary<string, WireMockList<string>>? Headers { get; }
+
+    /// <inheritdoc cref="IRequestMessage.Cookies" />
+    public IDictionary<string, string>? Cookies { get; }
+
+    /// <inheritdoc cref="IRequestMessage.Query" />
+    public IDictionary<string, WireMockList<string>>? Query { get; }
+
+    /// <inheritdoc cref="IRequestMessage.RawQuery" />
+    public string RawQuery { get; }
+
+    /// <inheritdoc cref="IRequestMessage.BodyData" />
+    public IBodyData? BodyData { get; }
+
+    /// <inheritdoc cref="IRequestMessage.Body" />
+    public string Body { get; }
+
+    /// <inheritdoc cref="IRequestMessage.BodyAsJson" />
+    public object BodyAsJson { get; }
+
+    /// <inheritdoc cref="IRequestMessage.BodyAsBytes" />
+    public byte[] BodyAsBytes { get; }
+
+    /// <inheritdoc cref="IRequestMessage.DetectedBodyType" />
+    public string DetectedBodyType { get; }
+
+    /// <inheritdoc cref="IRequestMessage.DetectedBodyTypeFromContentType" />
+    public string DetectedBodyTypeFromContentType { get; }
+
+    /// <inheritdoc cref="IRequestMessage.DetectedCompression" />
+    public string DetectedCompression { get; }
+
+    /// <inheritdoc cref="IRequestMessage.Host" />
+    public string Host { get; }
+
+    /// <inheritdoc cref="IRequestMessage.Protocol" />
+    public string Protocol { get; }
+
+    /// <inheritdoc cref="IRequestMessage.Port" />
+    public int Port { get; }
+
+    /// <inheritdoc cref="IRequestMessage.Origin" />
+    public string Origin { get; }
+
     /// <summary>
-    /// The RequestMessage.
+    /// Initializes a new instance of the <see cref="RequestMessage"/> class.
     /// </summary>
-    public class RequestMessage : IRequestMessage
+    /// <param name="urlDetails">The original url details.</param>
+    /// <param name="method">The HTTP method.</param>
+    /// <param name="clientIP">The client IP Address.</param>
+    /// <param name="bodyData">The BodyData.</param>
+    /// <param name="headers">The headers.</param>
+    /// <param name="cookies">The cookies.</param>
+    public RequestMessage(UrlDetails urlDetails, string method, string clientIP, IBodyData? bodyData = null, IDictionary<string, string[]>? headers = null, IDictionary<string, string>? cookies = null)
     {
-        /// <inheritdoc cref="IRequestMessage.ClientIP" />
-        public string ClientIP { get; }
+        Guard.NotNull(urlDetails, nameof(urlDetails));
+        Guard.NotNull(method, nameof(method));
+        Guard.NotNull(clientIP, nameof(clientIP));
 
-        /// <inheritdoc cref="IRequestMessage.Url" />
-        public string Url { get; }
+        AbsoluteUrl = urlDetails.AbsoluteUrl.ToString();
+        Url = urlDetails.Url.ToString();
+        Protocol = urlDetails.Url.Scheme;
+        Host = urlDetails.Url.Host;
+        Port = urlDetails.Url.Port;
+        Origin = $"{Protocol}://{Host}:{Port}";
 
-        /// <inheritdoc cref="IRequestMessage.AbsoluteUrl" />
-        public string AbsoluteUrl { get; }
+        AbsolutePath = WebUtility.UrlDecode(urlDetails.AbsoluteUrl.AbsolutePath);
+        Path = WebUtility.UrlDecode(urlDetails.Url.AbsolutePath);
+        PathSegments = Path.Split('/').Skip(1).ToArray();
+        AbsolutePathSegments = AbsolutePath.Split('/').Skip(1).ToArray();
 
-        /// <inheritdoc cref="IRequestMessage.ProxyUrl" />
-        public string ProxyUrl { get; set; }
+        Method = method;
+        ClientIP = clientIP;
 
-        /// <inheritdoc cref="IRequestMessage.DateTime" />
-        public DateTime DateTime { get; set; }
+        BodyData = bodyData;
 
-        /// <inheritdoc cref="IRequestMessage.Path" />
-        public string Path { get; }
+        // Convenience getters for e.g. Handlebars
+        Body = BodyData?.BodyAsString;
+        BodyAsJson = BodyData?.BodyAsJson;
+        BodyAsBytes = BodyData?.BodyAsBytes;
+        DetectedBodyType = BodyData?.DetectedBodyType.ToString();
+        DetectedBodyTypeFromContentType = BodyData?.DetectedBodyTypeFromContentType.ToString();
+        DetectedCompression = BodyData?.DetectedCompression;
 
-        /// <inheritdoc cref="IRequestMessage.AbsolutePath" />
-        public string AbsolutePath { get; }
+        Headers = headers?.ToDictionary(header => header.Key, header => new WireMockList<string>(header.Value));
+        Cookies = cookies;
+        RawQuery = urlDetails.Url.Query;
+        Query = QueryStringParser.Parse(RawQuery);
+    }
 
-        /// <inheritdoc cref="IRequestMessage.PathSegments" />
-        public string[] PathSegments { get; }
-
-        /// <inheritdoc cref="IRequestMessage.AbsolutePathSegments" />
-        public string[] AbsolutePathSegments { get; }
-
-        /// <inheritdoc cref="IRequestMessage.Method" />
-        public string Method { get; }
-
-        /// <inheritdoc cref="IRequestMessage.Headers" />
-        public IDictionary<string, WireMockList<string>>? Headers { get; }
-
-        /// <inheritdoc cref="IRequestMessage.Cookies" />
-        public IDictionary<string, string>? Cookies { get; }
-
-        /// <inheritdoc cref="IRequestMessage.Query" />
-        public IDictionary<string, WireMockList<string>>? Query { get; }
-
-        /// <inheritdoc cref="IRequestMessage.RawQuery" />
-        public string RawQuery { get; }
-
-        /// <inheritdoc cref="IRequestMessage.BodyData" />
-        public IBodyData? BodyData { get; }
-
-        /// <inheritdoc cref="IRequestMessage.Body" />
-        public string Body { get; }
-
-        /// <inheritdoc cref="IRequestMessage.BodyAsJson" />
-        public object BodyAsJson { get; }
-
-        /// <inheritdoc cref="IRequestMessage.BodyAsBytes" />
-        public byte[] BodyAsBytes { get; }
-
-        /// <inheritdoc cref="IRequestMessage.DetectedBodyType" />
-        public string DetectedBodyType { get; }
-
-        /// <inheritdoc cref="IRequestMessage.DetectedBodyTypeFromContentType" />
-        public string DetectedBodyTypeFromContentType { get; }
-
-        /// <inheritdoc cref="IRequestMessage.DetectedCompression" />
-        public string DetectedCompression { get; }
-
-        /// <inheritdoc cref="IRequestMessage.Host" />
-        public string Host { get; }
-
-        /// <inheritdoc cref="IRequestMessage.Protocol" />
-        public string Protocol { get; }
-
-        /// <inheritdoc cref="IRequestMessage.Port" />
-        public int Port { get; }
-
-        /// <inheritdoc cref="IRequestMessage.Origin" />
-        public string Origin { get; }
-
-        /// <summary>
-        /// Initializes a new instance of the <see cref="RequestMessage"/> class.
-        /// </summary>
-        /// <param name="urlDetails">The original url details.</param>
-        /// <param name="method">The HTTP method.</param>
-        /// <param name="clientIP">The client IP Address.</param>
-        /// <param name="bodyData">The BodyData.</param>
-        /// <param name="headers">The headers.</param>
-        /// <param name="cookies">The cookies.</param>
-        public RequestMessage(UrlDetails urlDetails, string method, string clientIP, IBodyData? bodyData = null, IDictionary<string, string[]>? headers = null, IDictionary<string, string>? cookies = null)
+    /// <summary>
+    /// Get a query parameter.
+    /// </summary>
+    /// <param name="key">The key.</param>
+    /// <param name="ignoreCase">Defines if the key should be matched using case-ignore.</param>
+    /// <returns>The query parameter.</returns>
+    public WireMockList<string>? GetParameter(string key, bool ignoreCase = false)
+    {
+        if (Query == null)
         {
-            Guard.NotNull(urlDetails, nameof(urlDetails));
-            Guard.NotNull(method, nameof(method));
-            Guard.NotNull(clientIP, nameof(clientIP));
-
-            AbsoluteUrl = urlDetails.AbsoluteUrl.ToString();
-            Url = urlDetails.Url.ToString();
-            Protocol = urlDetails.Url.Scheme;
-            Host = urlDetails.Url.Host;
-            Port = urlDetails.Url.Port;
-            Origin = $"{Protocol}://{Host}:{Port}";
-
-            AbsolutePath = WebUtility.UrlDecode(urlDetails.AbsoluteUrl.AbsolutePath);
-            Path = WebUtility.UrlDecode(urlDetails.Url.AbsolutePath);
-            PathSegments = Path.Split('/').Skip(1).ToArray();
-            AbsolutePathSegments = AbsolutePath.Split('/').Skip(1).ToArray();
-
-            Method = method;
-            ClientIP = clientIP;
-
-            BodyData = bodyData;
-
-            // Convenience getters for e.g. Handlebars
-            Body = BodyData?.BodyAsString;
-            BodyAsJson = BodyData?.BodyAsJson;
-            BodyAsBytes = BodyData?.BodyAsBytes;
-            DetectedBodyType = BodyData?.DetectedBodyType.ToString();
-            DetectedBodyTypeFromContentType = BodyData?.DetectedBodyTypeFromContentType.ToString();
-            DetectedCompression = BodyData?.DetectedCompression;
-
-            Headers = headers?.ToDictionary(header => header.Key, header => new WireMockList<string>(header.Value));
-            Cookies = cookies;
-            RawQuery = urlDetails.Url.Query;
-            Query = QueryStringParser.Parse(RawQuery);
+            return null;
         }
 
-        /// <summary>
-        /// Get a query parameter.
-        /// </summary>
-        /// <param name="key">The key.</param>
-        /// <param name="ignoreCase">Defines if the key should be matched using case-ignore.</param>
-        /// <returns>The query parameter.</returns>
-        public WireMockList<string>? GetParameter(string? key, bool ignoreCase = false)
-        {
-            if (Query == null)
-            {
-                return null;
-            }
+        var query = !ignoreCase ? Query : new Dictionary<string, WireMockList<string>>(Query, StringComparer.OrdinalIgnoreCase);
 
-            var query = !ignoreCase ? Query : new Dictionary<string, WireMockList<string>>(Query, StringComparer.OrdinalIgnoreCase);
-
-            return query.ContainsKey(key) ? query[key] : null;
-        }
+        return query.ContainsKey(key) ? query[key] : null;
     }
 }

src/WireMock.Net/ResponseBuilders/IHeadersResponseBuilder.cs

@@ -1,41 +1,40 @@
-using JetBrains.Annotations;
+using JetBrains.Annotations;
 using System.Collections.Generic;
 using WireMock.Types;
 
-namespace WireMock.ResponseBuilders
+namespace WireMock.ResponseBuilders;
+
+/// <summary>
+/// The HeadersResponseBuilder interface.
+/// </summary>
+public interface IHeadersResponseBuilder : IBodyResponseBuilder
 {
     /// <summary>
-    /// The HeadersResponseBuilder interface.
+    /// The with header.
     /// </summary>
-    public interface IHeadersResponseBuilder : IBodyResponseBuilder
-    {
-        /// <summary>
-        /// The with header.
-        /// </summary>
-        /// <param name="name">The name.</param>
-        /// <param name="values">The values.</param>
-        /// <returns>The <see cref="IResponseBuilder"/>.</returns>
-        IResponseBuilder WithHeader([NotNull] string name, params string[] values);
+    /// <param name="name">The name.</param>
+    /// <param name="values">The values.</param>
+    /// <returns>The <see cref="IResponseBuilder"/>.</returns>
+    IResponseBuilder WithHeader(string name, params string[] values);
 
-        /// <summary>
-        /// The with headers.
-        /// </summary>
-        /// <param name="headers">The headers.</param>
-        /// <returns>The <see cref="IResponseBuilder"/>.</returns>
-        IResponseBuilder WithHeaders([NotNull] IDictionary<string, string> headers);
+    /// <summary>
+    /// The with headers.
+    /// </summary>
+    /// <param name="headers">The headers.</param>
+    /// <returns>The <see cref="IResponseBuilder"/>.</returns>
+    IResponseBuilder WithHeaders(IDictionary<string, string> headers);
 
-        /// <summary>
-        /// The with headers.
-        /// </summary>
-        /// <param name="headers">The headers.</param>
-        /// <returns>The <see cref="IResponseBuilder"/>.</returns>
-        IResponseBuilder WithHeaders([NotNull] IDictionary<string, string[]> headers);
+    /// <summary>
+    /// The with headers.
+    /// </summary>
+    /// <param name="headers">The headers.</param>
+    /// <returns>The <see cref="IResponseBuilder"/>.</returns>
+    IResponseBuilder WithHeaders(IDictionary<string, string[]> headers);
 
-        /// <summary>
-        /// The with headers.
-        /// </summary>
-        /// <param name="headers">The headers.</param>
-        /// <returns>The <see cref="IResponseBuilder"/>.</returns>
-        IResponseBuilder WithHeaders([NotNull] IDictionary<string, WireMockList<string>> headers);
-    }
+    /// <summary>
+    /// The with headers.
+    /// </summary>
+    /// <param name="headers">The headers.</param>
+    /// <returns>The <see cref="IResponseBuilder"/>.</returns>
+    IResponseBuilder WithHeaders(IDictionary<string, WireMockList<string>> headers);
 }

src/WireMock.Net/Serialization/MatcherMapper.cs

@@ -47,6 +47,7 @@ internal class MatcherMapper
         bool ignoreCase = matcher.IgnoreCase == true;
         bool throwExceptionWhenMatcherFails = _settings.ThrowExceptionWhenMatcherFails == true;
         bool useRegexExtended = _settings.UseRegexExtended == true;
+        bool useRegex = matcher.Regex == true;
 
         switch (matcherName)
         {
@@ -79,11 +80,11 @@ internal class MatcherMapper
 
             case nameof(JsonPartialMatcher):
                 var valueForJsonPartialMatcher = matcher.Pattern ?? matcher.Patterns;
-                return new JsonPartialMatcher(matchBehaviour, valueForJsonPartialMatcher!, ignoreCase, throwExceptionWhenMatcherFails);
+                return new JsonPartialMatcher(matchBehaviour, valueForJsonPartialMatcher!, ignoreCase, throwExceptionWhenMatcherFails, useRegex);
 
             case nameof(JsonPartialWildcardMatcher):
                 var valueForJsonPartialWildcardMatcher = matcher.Pattern ?? matcher.Patterns;
-                return new JsonPartialWildcardMatcher(matchBehaviour, valueForJsonPartialWildcardMatcher!, ignoreCase, throwExceptionWhenMatcherFails);
+                return new JsonPartialWildcardMatcher(matchBehaviour, valueForJsonPartialWildcardMatcher!, ignoreCase, throwExceptionWhenMatcherFails, useRegex);
 
             case nameof(JsonPathMatcher):
                 return new JsonPathMatcher(matchBehaviour, throwExceptionWhenMatcherFails, matchOperator, stringPatterns);
@@ -146,6 +147,17 @@ internal class MatcherMapper
             Name = matcher.Name
         };
 
+        switch (matcher)
+        {
+            case JsonPartialMatcher jsonPartialMatcher:
+                model.Regex = jsonPartialMatcher.Regex;
+                break;
+
+            case JsonPartialWildcardMatcher jsonPartialWildcardMatcher:
+                model.Regex = jsonPartialWildcardMatcher.Regex;
+                break;
+        }
+
         switch (matcher)
         {
             // If the matcher is a IStringMatcher, get the operator & patterns.

src/WireMock.Net/Serialization/PactMapper.cs

@@ -53,9 +53,9 @@ internal static class PactMapper
         return (filename, JsonUtils.SerializeAsPactFile(pact));
     }
 
-    private static Request MapRequest(RequestModel request, string path)
+    private static PactRequest MapRequest(RequestModel request, string path)
     {
-        return new Request
+        return new PactRequest
         {
             Method = request.Methods?.FirstOrDefault() ?? DefaultMethod,
             Path = path,
@@ -65,14 +65,14 @@ internal static class PactMapper
         };
     }
 
-    private static Response MapResponse(ResponseModel? response)
+    private static PactResponse MapResponse(ResponseModel? response)
     {
         if (response == null)
         {
-            return new Response();
+            return new PactResponse();
         }
 
-        return new Response
+        return new PactResponse
         {
             Status = MapStatusCode(response.StatusCode),
             Headers = MapResponseHeaders(response.Headers),

src/WireMock.Net/Server/WireMockServer.Admin.cs

@@ -293,7 +293,7 @@ public partial class WireMockServer
 
     private IResponseMessage SettingsUpdate(IRequestMessage requestMessage)
     {
-        var settings = DeserializeObject<SettingsModel>(requestMessage);
+        var settings = DeserializeObject<SettingsModel>(requestMessage)!;
 
         // _settings
         _settings.AllowBodyForAllHttpMethods = settings.AllowBodyForAllHttpMethods;

src/WireMock.Net/Server/WireMockServer.ImportWireMockOrg.cs

@@ -10,299 +10,302 @@ using WireMock.RequestBuilders;
 using WireMock.ResponseBuilders;
 using WireMock.Util;
 using Stef.Validation;
-using OrgMapping = WireMock.Org.Abstractions.Mapping;
+using OrgMappings = WireMock.Org.Abstractions.Mappings;
 
-namespace WireMock.Server
+namespace WireMock.Server;
+
+public partial class WireMockServer
 {
-    public partial class WireMockServer
+    /// <summary>
+    /// Read WireMock.org mapping json file.
+    /// </summary>
+    /// <param name="path">The path to the WireMock.org mapping json file.</param>
+    [PublicAPI]
+    public void ReadStaticWireMockOrgMappingAndAddOrUpdate(string path)
     {
-        /// <summary>
-        /// Read WireMock.org mapping json file.
-        /// </summary>
-        /// <param name="path">The path to the WireMock.org mapping json file.</param>
-        [PublicAPI]
-        public void ReadStaticWireMockOrgMappingAndAddOrUpdate(string path)
+        Guard.NotNull(path, nameof(path));
+
+        string filenameWithoutExtension = Path.GetFileNameWithoutExtension(path);
+
+        if (FileHelper.TryReadMappingFileWithRetryAndDelay(_settings.FileSystemHandler, path, out string value))
         {
-            Guard.NotNull(path, nameof(path));
-
-            string filenameWithoutExtension = Path.GetFileNameWithoutExtension(path);
-
-            if (FileHelper.TryReadMappingFileWithRetryAndDelay(_settings.FileSystemHandler, path, out string value))
+            var mappings = DeserializeJsonToArray<OrgMappings>(value);
+            foreach (var mapping in mappings)
             {
-                var mappings = DeserializeJsonToArray<OrgMapping>(value);
-                foreach (var mapping in mappings)
+                if (mappings.Length == 1 && Guid.TryParse(filenameWithoutExtension, out Guid guidFromFilename))
                 {
-                    if (mappings.Length == 1 && Guid.TryParse(filenameWithoutExtension, out Guid guidFromFilename))
-                    {
-                        ConvertWireMockOrgMappingAndRegisterAsRespondProvider(mapping, guidFromFilename, path);
-                    }
-                    else
-                    {
-                        ConvertWireMockOrgMappingAndRegisterAsRespondProvider(mapping, null, path);
-                    }
+                    ConvertWireMockOrgMappingAndRegisterAsRespondProvider(mapping, guidFromFilename, path);
+                }
+                else
+                {
+                    ConvertWireMockOrgMappingAndRegisterAsRespondProvider(mapping, null, path);
                 }
             }
         }
+    }
 
-        private IResponseMessage MappingsPostWireMockOrg(IRequestMessage requestMessage)
+    private IResponseMessage MappingsPostWireMockOrg(IRequestMessage requestMessage)
+    {
+        try
         {
-            try
+            var mappingModels = DeserializeRequestMessageToArray<OrgMappings>(requestMessage);
+            if (mappingModels.Length == 1)
             {
-                var mappingModels = DeserializeRequestMessageToArray<OrgMapping>(requestMessage);
-                if (mappingModels.Length == 1)
-                {
-                    Guid? guid = ConvertWireMockOrgMappingAndRegisterAsRespondProvider(mappingModels[0]);
-                    return ResponseMessageBuilder.Create("Mapping added", 201, guid);
-                }
-
-                foreach (var mappingModel in mappingModels)
-                {
-                    ConvertWireMockOrgMappingAndRegisterAsRespondProvider(mappingModel);
-                }
-
-                return ResponseMessageBuilder.Create("Mappings added", 201);
+                Guid? guid = ConvertWireMockOrgMappingAndRegisterAsRespondProvider(mappingModels[0]);
+                return ResponseMessageBuilder.Create("Mapping added", 201, guid);
             }
-            catch (ArgumentException a)
+
+            foreach (var mappingModel in mappingModels)
             {
-                _settings.Logger.Error("HttpStatusCode set to 400 {0}", a);
-                return ResponseMessageBuilder.Create(a.Message, 400);
+                ConvertWireMockOrgMappingAndRegisterAsRespondProvider(mappingModel);
             }
-            catch (Exception e)
+
+            return ResponseMessageBuilder.Create("Mappings added", 201);
+        }
+        catch (ArgumentException a)
+        {
+            _settings.Logger.Error("HttpStatusCode set to 400 {0}", a);
+            return ResponseMessageBuilder.Create(a.Message, 400);
+        }
+        catch (Exception e)
+        {
+            _settings.Logger.Error("HttpStatusCode set to 500 {0}", e);
+            return ResponseMessageBuilder.Create(e.ToString(), 500);
+        }
+    }
+
+    private Guid? ConvertWireMockOrgMappingAndRegisterAsRespondProvider(OrgMappings mapping, Guid? guid = null, string? path = null)
+    {
+        var requestBuilder = Request.Create();
+
+        var request = mapping.Request;
+        if (request != null)
+        {
+            if (request.Url != null)
             {
-                _settings.Logger.Error("HttpStatusCode set to 500 {0}", e);
-                return ResponseMessageBuilder.Create(e.ToString(), 500);
+                requestBuilder = requestBuilder.WithUrl(request.Url);
+            }
+            else if (request.UrlPattern != null)
+            {
+                requestBuilder = requestBuilder.WithUrl(new RegexMatcher(request.UrlPattern));
+            }
+            else if (request.UrlPath != null)
+            {
+                requestBuilder = requestBuilder.WithPath(request.UrlPath);
+            }
+            else if (request.UrlPathPattern != null)
+            {
+                requestBuilder = requestBuilder.WithPath(new RegexMatcher(request.UrlPathPattern));
+            }
+
+            if (request.Method != null)
+            {
+                requestBuilder = requestBuilder.UsingMethod(request.Method);
+            }
+
+            /*
+            "headers" : {
+              "Accept" : {
+                "contains" : "xml"
+              }
+            }
+            */
+            if (request.Headers is JObject headers)
+            {
+                ProcessWireMockOrgJObjectAndUseStringMatcher(headers, (key, match) =>
+                {
+                    requestBuilder = requestBuilder.WithHeader(key, match);
+                });
+            }
+
+            if (request.Cookies is JObject cookies)
+            {
+                ProcessWireMockOrgJObjectAndUseStringMatcher(cookies, (key, match) =>
+                {
+                    requestBuilder = requestBuilder.WithCookie(key, match);
+                });
+            }
+
+            /*
+            "queryParameters" : {
+              "search_term" : {
+                "equalTo" : "WireMock"
+              }
+            }
+            */
+            if (request.QueryParameters is JObject queryParameters)
+            {
+                ProcessWireMockOrgJObjectAndUseStringMatcher(queryParameters, (key, match) =>
+                {
+                    requestBuilder = requestBuilder.WithParam(key, match);
+                });
+            }
+
+            /*
+             "bodyPatterns" : [ {
+              "equalToJson" : "{ "cityName": "São Paulo", "cityCode": 5001 },
+              "ignoreArrayOrder" : true,
+              "ignoreExtraElements" : true
+            } ]
+            */
+            if (request.BodyPatterns?.Any() == true)
+            {
+                var jObjectArray = request.BodyPatterns.Cast<JObject>();
+                var bodyPattern = jObjectArray.First();
+                ProcessWireMockOrgJObjectAndUseIMatcher(bodyPattern, match =>
+                {
+                    requestBuilder = requestBuilder.WithBody(match);
+                });
             }
         }
 
-        private Guid? ConvertWireMockOrgMappingAndRegisterAsRespondProvider(OrgMapping mapping, Guid? guid = null, string path = null)
+        IResponseBuilder responseBuilder = Response.Create();
+
+        var response = mapping.Response;
+        if (response != null)
         {
-            var requestBuilder = Request.Create();
+            responseBuilder = responseBuilder.WithStatusCode(response.Status);
 
-            var request = mapping.Request;
-            if (request != null)
+            if (response.Headers is JObject responseHeaders)
             {
-                if (request.Url != null)
+                var rb = responseBuilder;
+                ProcessWireMockOrgJObjectAndConvertToIDictionary(responseHeaders, headers =>
                 {
-                    requestBuilder = requestBuilder.WithUrl(request.Url);
-                }
-                else if (request.UrlPattern != null)
-                {
-                    requestBuilder = requestBuilder.WithUrl(new RegexMatcher(request.UrlPattern));
-                }
-                else if (request.UrlPath != null)
-                {
-                    requestBuilder = requestBuilder.WithPath(request.Url);
-                }
-                else if (request.UrlPathPattern != null)
-                {
-                    requestBuilder = requestBuilder.WithPath(new RegexMatcher(request.UrlPathPattern));
-                }
-
-                if (request.Method != null)
-                {
-                    requestBuilder = requestBuilder.UsingMethod(request.Method);
-                }
-
-                /*
-                "headers" : {
-                  "Accept" : {
-                    "contains" : "xml"
-                  }
-                }
-                */
-                if (request.Headers is JObject headers)
-                {
-                    ProcessWireMockOrgJObjectAndUseStringMatcher(headers, (key, match) =>
-                    {
-                        requestBuilder = requestBuilder.WithHeader(key, match);
-                    });
-                }
-
-                if (request.Cookies is JObject cookies)
-                {
-                    ProcessWireMockOrgJObjectAndUseStringMatcher(cookies, (key, match) =>
-                    {
-                        requestBuilder = requestBuilder.WithCookie(key, match);
-                    });
-                }
-
-                /*
-                "queryParameters" : {
-                  "search_term" : {
-                    "equalTo" : "WireMock"
-                  }
-                }
-                */
-                if (request.QueryParameters is JObject queryParameters)
-                {
-                    ProcessWireMockOrgJObjectAndUseStringMatcher(queryParameters, (key, match) =>
-                    {
-                        requestBuilder = requestBuilder.WithParam(key, match);
-                    });
-                }
-
-                /*
-                 "bodyPatterns" : [ {
-                  "equalToJson" : "{ "cityName": "São Paulo", "cityCode": 5001 },
-                  "ignoreArrayOrder" : true,
-                  "ignoreExtraElements" : true
-                } ]
-                */
-                if (request.BodyPatterns?.Any() == true)
-                {
-                    var jObjectArray = request.BodyPatterns.Cast<JObject>();
-                    var bodyPattern = jObjectArray.First();
-                    ProcessWireMockOrgJObjectAndUseIMatcher(bodyPattern, (match) =>
-                    {
-                        requestBuilder = requestBuilder.WithBody(match);
-                    });
-                }
+                    rb = rb.WithHeaders(headers);
+                });
             }
 
-            IResponseBuilder responseBuilder = Response.Create();
-
-            var response = mapping.Response;
-            if (response != null)
+            if (response.Transformers != null)
             {
-                responseBuilder = responseBuilder.WithStatusCode(response.Status);
-
-                if (response.Headers is JObject responseHeaders)
-                {
-                    ProcessWireMockOrgJObjectAndConvertToIDictionary(responseHeaders, (headers) =>
-                    {
-                        responseBuilder = responseBuilder.WithHeaders(headers);
-                    });
-                }
-
-                if (response.Transformers != null)
-                {
-                    responseBuilder = responseBuilder.WithTransformer();
-                }
-
-                if (response.Body != null)
-                {
-                    responseBuilder = responseBuilder.WithBody(response.Body);
-                }
-
-                if (response.JsonBody != null)
-                {
-                    responseBuilder = responseBuilder.WithBodyAsJson(response.JsonBody);
-                }
-
-                if (response.Base64Body != null)
-                {
-                    responseBuilder = responseBuilder.WithBody(Encoding.UTF8.GetString(Convert.FromBase64String(response.Base64Body)));
-                }
-
-                if (response.BodyFileName != null)
-                {
-                    responseBuilder = responseBuilder.WithBodyFromFile(response.BodyFileName);
-                }
+                responseBuilder = responseBuilder.WithTransformer();
             }
 
-            var respondProvider = Given(requestBuilder);
-            if (guid != null)
+            if (response.Body != null)
             {
-                respondProvider = respondProvider.WithGuid(guid.Value);
-            }
-            else if (!string.IsNullOrEmpty(mapping.Uuid))
-            {
-                respondProvider = respondProvider.WithGuid(new Guid(mapping.Uuid));
+                responseBuilder = responseBuilder.WithBody(response.Body);
             }
 
-            if (mapping.Name != null)
+            if (response.JsonBody != null)
             {
-                respondProvider = respondProvider.WithTitle(mapping.Name);
+                responseBuilder = responseBuilder.WithBodyAsJson(response.JsonBody);
             }
 
-            if (path != null)
+            if (response.Base64Body != null)
             {
-                respondProvider = respondProvider.WithPath(path);
+                responseBuilder = responseBuilder.WithBody(Encoding.UTF8.GetString(Convert.FromBase64String(response.Base64Body)));
             }
 
-            respondProvider.RespondWith(responseBuilder);
-
-            return respondProvider.Guid;
-        }
-
-        private void ProcessWireMockOrgJObjectAndConvertToIDictionary(JObject items, Action<IDictionary<string, string>> action)
-        {
-            var dict = new Dictionary<string, string>();
-            foreach (var item in items)
+            if (response.BodyFileName != null)
             {
-                var key = item.Key;
-                var valueAsString = item.Value.Value<string>();
-                dict.Add(key, valueAsString);
-            }
-
-            action(dict);
-        }
-
-        private void ProcessWireMockOrgJObjectAndUseStringMatcher(JObject items, Action<string, IStringMatcher> action)
-        {
-            foreach (var item in items)
-            {
-                var key = item.Key;
-                var match = item.Value.First as JProperty;
-                var valueAsString = match?.Value.Value<string>();
-                if (string.IsNullOrEmpty(valueAsString))
-                {
-                    continue;
-                }
-
-                var matcher = ProcessAsStringMatcher(match, valueAsString);
-                if (matcher != null)
-                {
-                    action(key, matcher);
-                }
+                responseBuilder = responseBuilder.WithBodyFromFile(response.BodyFileName);
             }
         }
 
-        private void ProcessWireMockOrgJObjectAndUseIMatcher(JObject items, Action<IMatcher> action)
+        var respondProvider = Given(requestBuilder);
+        if (guid != null)
         {
-            if (!(items.First is JProperty firstItem))
+            respondProvider = respondProvider.WithGuid(guid.Value);
+        }
+        else if (!string.IsNullOrEmpty(mapping.Uuid))
+        {
+            respondProvider = respondProvider.WithGuid(new Guid(mapping.Uuid));
+        }
+
+        if (mapping.Name != null)
+        {
+            respondProvider = respondProvider.WithTitle(mapping.Name);
+        }
+
+        if (path != null)
+        {
+            respondProvider = respondProvider.WithPath(path);
+        }
+
+        respondProvider.RespondWith(responseBuilder);
+
+        return respondProvider.Guid;
+    }
+
+    private void ProcessWireMockOrgJObjectAndConvertToIDictionary(JObject items, Action<IDictionary<string, string>> action)
+    {
+        var dict = new Dictionary<string, string>();
+        foreach (var item in items)
+        {
+            var key = item.Key;
+            var valueAsString = item.Value?.Value<string>();
+            if (valueAsString == null)
+            {
+                // Skip if the item.Value is null or when the string value is null
+                continue;
+            }
+
+            dict.Add(key, valueAsString);
+        }
+
+        action(dict);
+    }
+
+    private void ProcessWireMockOrgJObjectAndUseStringMatcher(JObject items, Action<string, IStringMatcher> action)
+    {
+        foreach (var item in items)
+        {
+            var key = item.Key;
+            var match = item.Value?.First as JProperty;
+            if (match == null)
+            {
+                continue;
+            }
+
+            var valueAsString = match.Value.Value<string>();
+            if (string.IsNullOrEmpty(valueAsString))
+            {
+                continue;
+            }
+
+            var matcher = ProcessAsStringMatcher(match, valueAsString!);
+            if (matcher != null)
+            {
+                action(key, matcher);
+            }
+        }
+    }
+
+    private static void ProcessWireMockOrgJObjectAndUseIMatcher(JObject items, Action<IMatcher> action)
+    {
+        if (items.First is not JProperty firstItem)
+        {
+            return;
+        }
+
+        IMatcher? matcher;
+        if (firstItem.Name == "equalToJson")
+        {
+            matcher = new JsonMatcher(firstItem.Value);
+        }
+        else
+        {
+            if ((firstItem.Value as JValue)?.Value is not string valueAsString)
             {
                 return;
             }
 
-            IMatcher matcher;
-            if (firstItem.Name == "equalToJson")
-            {
-                matcher = new JsonMatcher(firstItem.Value);
-            }
-            else
-            {
-                var valueAsString = (firstItem.Value as JValue)?.Value as string;
-                if (valueAsString == null)
-                {
-                    return;
-                }
-
-                matcher = ProcessAsStringMatcher(firstItem, valueAsString);
-            }
-
-            if (matcher != null)
-            {
-                action(matcher);
-            }
+            matcher = ProcessAsStringMatcher(firstItem, valueAsString);
         }
 
-        private static IStringMatcher ProcessAsStringMatcher(JProperty match, string valueAsString)
+        if (matcher != null)
         {
-            switch (match?.Name)
-            {
-                case "contains":
-                    return new WildcardMatcher(valueAsString);
-
-                case "matches":
-                    return new RegexMatcher(valueAsString);
-
-                case "equalTo":
-                    return new ExactMatcher(valueAsString);
-
-                default:
-                    return null;
-            }
+            action(matcher);
         }
     }
+
+    private static IStringMatcher? ProcessAsStringMatcher(JProperty match, string valueAsString)
+    {
+        return match.Name switch
+        {
+            "contains" => new WildcardMatcher(valueAsString),
+            "matches" => new RegexMatcher(valueAsString),
+            "equalTo" => new ExactMatcher(valueAsString),
+            _ => null,
+        };
+    }
 }

src/WireMock.Net/Settings/WireMockServerSettings.cs

@@ -9,9 +9,9 @@ using WireMock.Handlers;
 using WireMock.Logging;
 using WireMock.Matchers;
 using WireMock.RegularExpressions;
-using WireMock.Types;
 #if USE_ASPNETCORE
 using Microsoft.Extensions.DependencyInjection;
+using WireMock.Types;
 #endif
 
 namespace WireMock.Settings

src/WireMock.Net/Transformers/Scriban/WireMockListAccessor.cs

@@ -1,4 +1,4 @@
-using System;
+using System;
 using System.Collections.Generic;
 using Scriban;
 using Scriban.Parsing;
@@ -50,6 +50,20 @@ namespace WireMock.Transformers.Scriban
         {
             throw new NotImplementedException();
         }
+
+        public bool TryGetItem(TemplateContext context, SourceSpan span, object target, object index, out object value)
+        {
+            throw new NotImplementedException();
+        }
+
+        public bool TrySetItem(TemplateContext context, SourceSpan span, object target, object index, object value)
+        {
+            throw new NotImplementedException();
+        }
+
+        public bool HasIndexer => throw new NotImplementedException();
+
+        public Type IndexType => throw new NotImplementedException();
         #endregion
     }
 }

src/WireMock.Net/Transformers/Scriban/WireMockTemplateContext.cs

@@ -1,19 +1,15 @@
-using Scriban;
+using Scriban;
 using Scriban.Runtime;
 using WireMock.Types;
 
-namespace WireMock.Transformers.Scriban
-{
-    internal class WireMockTemplateContext: TemplateContext
-    {
-        protected override IObjectAccessor GetMemberAccessorImpl(object target)
-        {
-            if (target?.GetType().GetGenericTypeDefinition() == typeof(WireMockList<>))
-            {
-                return new WireMockListAccessor();
-            }
+namespace WireMock.Transformers.Scriban;
 
-            return base.GetMemberAccessorImpl(target);
-        }
+internal class WireMockTemplateContext : TemplateContext
+{
+    protected override IObjectAccessor GetMemberAccessorImpl(object target)
+    {
+        return target?.GetType().GetGenericTypeDefinition() == typeof(WireMockList<>) ?
+            new WireMockListAccessor() :
+            base.GetMemberAccessorImpl(target);
     }
 }

src/WireMock.Net/Util/BodyParser.cs

@@ -4,180 +4,176 @@ using System.Linq;
 using System.Net.Http.Headers;
 using System.Text;
 using System.Threading.Tasks;
-using JetBrains.Annotations;
+using Stef.Validation;
 using WireMock.Http;
 using WireMock.Matchers;
 using WireMock.Types;
-using Stef.Validation;
 
-namespace WireMock.Util
+namespace WireMock.Util;
+
+internal static class BodyParser
 {
-    internal static class BodyParser
+    private static readonly Encoding DefaultEncoding = new UTF8Encoding(encoderShouldEmitUTF8Identifier: false, throwOnInvalidBytes: true);
+    private static readonly Encoding[] SupportedBodyAsStringEncodingForMultipart = { DefaultEncoding, Encoding.ASCII };
+
+    /*
+        HEAD - No defined body semantics.
+        GET - No defined body semantics.
+        PUT - Body supported.
+        POST - Body supported.
+        DELETE - No defined body semantics.
+        TRACE - Body not supported.
+        OPTIONS - Body supported but no semantics on usage (maybe in the future).
+        CONNECT - No defined body semantics
+        PATCH - Body supported.
+    */
+    private static readonly IDictionary<string, bool> BodyAllowedForMethods = new Dictionary<string, bool>
     {
-        private static readonly Encoding DefaultEncoding = new UTF8Encoding(encoderShouldEmitUTF8Identifier: false, throwOnInvalidBytes: true);
-        private static readonly Encoding[] SupportedBodyAsStringEncodingForMultipart = { DefaultEncoding, Encoding.ASCII };
+        { HttpRequestMethods.HEAD, false },
+        { HttpRequestMethods.GET, false },
+        { HttpRequestMethods.PUT, true },
+        { HttpRequestMethods.POST, true },
+        { HttpRequestMethods.DELETE, true },
+        { HttpRequestMethods.TRACE, false },
+        { HttpRequestMethods.OPTIONS, true },
+        { HttpRequestMethods.CONNECT, false },
+        { HttpRequestMethods.PATCH, true }
+    };
 
-        /*
-            HEAD - No defined body semantics.
-            GET - No defined body semantics.
-            PUT - Body supported.
-            POST - Body supported.
-            DELETE - No defined body semantics.
-            TRACE - Body not supported.
-            OPTIONS - Body supported but no semantics on usage (maybe in the future).
-            CONNECT - No defined body semantics
-            PATCH - Body supported.
-        */
-        private static readonly IDictionary<string, bool> BodyAllowedForMethods = new Dictionary<string, bool>
+    private static readonly IStringMatcher[] MultipartContentTypesMatchers = {
+        new WildcardMatcher("multipart/*", true)
+    };
+
+    private static readonly IStringMatcher[] JsonContentTypesMatchers = {
+        new WildcardMatcher("application/json", true),
+        new WildcardMatcher("application/vnd.*+json", true)
+    };
+
+    private static readonly IStringMatcher[] TextContentTypeMatchers =
+    {
+        new WildcardMatcher("text/*", true),
+        new RegexMatcher("^application\\/(java|type)script$", true),
+        new WildcardMatcher("application/*xml", true),
+        new WildcardMatcher("application/x-www-form-urlencoded", true)
+    };
+
+    public static bool ShouldParseBody(string? httpMethod, bool allowBodyForAllHttpMethods)
+    {
+        if (string.IsNullOrEmpty(httpMethod))
         {
-            { HttpRequestMethods.HEAD, false },
-            { HttpRequestMethods.GET, false },
-            { HttpRequestMethods.PUT, true },
-            { HttpRequestMethods.POST, true },
-            { HttpRequestMethods.DELETE, true },
-            { HttpRequestMethods.TRACE, false },
-            { HttpRequestMethods.OPTIONS, true },
-            { HttpRequestMethods.CONNECT, false },
-            { HttpRequestMethods.PATCH, true }
-        };
+            return false;
+        }
 
-        private static readonly IStringMatcher[] MultipartContentTypesMatchers = {
-            new WildcardMatcher("multipart/*", true)
-        };
-
-        private static readonly IStringMatcher[] JsonContentTypesMatchers = {
-            new WildcardMatcher("application/json", true),
-            new WildcardMatcher("application/vnd.*+json", true)
-        };
-
-        private static readonly IStringMatcher[] TextContentTypeMatchers =
+        if (allowBodyForAllHttpMethods)
         {
-            new WildcardMatcher("text/*", true),
-            new RegexMatcher("^application\\/(java|type)script$", true),
-            new WildcardMatcher("application/*xml", true),
-            new WildcardMatcher("application/x-www-form-urlencoded", true)
-        };
-
-        public static bool ShouldParseBody([CanBeNull] string httpMethod, bool allowBodyForAllHttpMethods)
-        {
-            if (string.IsNullOrEmpty(httpMethod))
-            {
-                return false;
-            }
-
-            if (allowBodyForAllHttpMethods)
-            {
-                return true;
-            }
-
-            if (BodyAllowedForMethods.TryGetValue(httpMethod.ToUpper(), out bool allowed))
-            {
-                return allowed;
-            }
-
-            // If we don't have any knowledge of this method, we should assume that a body *may*
-            // be present, so we should parse it if it is. Therefore, if a new method is added to
-            // the HTTP Method Registry, we only really need to add it to BodyAllowedForMethods if
-            // we want to make it clear that a body is *not* allowed.
             return true;
         }
 
-        public static BodyType DetectBodyTypeFromContentType([CanBeNull] string contentTypeValue)
+        if (BodyAllowedForMethods.TryGetValue(httpMethod!.ToUpper(), out bool allowed))
         {
-            if (string.IsNullOrEmpty(contentTypeValue) || !MediaTypeHeaderValue.TryParse(contentTypeValue, out MediaTypeHeaderValue contentType))
-            {
-                return BodyType.Bytes;
-            }
+            return allowed;
+        }
 
-            if (TextContentTypeMatchers.Any(matcher => MatchScores.IsPerfect(matcher.IsMatch(contentType.MediaType))))
-            {
-                return BodyType.String;
-            }
-
-            if (JsonContentTypesMatchers.Any(matcher => MatchScores.IsPerfect(matcher.IsMatch(contentType.MediaType))))
-            {
-                return BodyType.Json;
-            }
-
-            if (MultipartContentTypesMatchers.Any(matcher => MatchScores.IsPerfect(matcher.IsMatch(contentType.MediaType))))
-            {
-                return BodyType.MultiPart;
-            }
+        // If we don't have any knowledge of this method, we should assume that a body *may*
+        // be present, so we should parse it if it is. Therefore, if a new method is added to
+        // the HTTP Method Registry, we only really need to add it to BodyAllowedForMethods if
+        // we want to make it clear that a body is *not* allowed.
+        return true;
+    }
 
+    public static BodyType DetectBodyTypeFromContentType(string? contentTypeValue)
+    {
+        if (string.IsNullOrEmpty(contentTypeValue) || !MediaTypeHeaderValue.TryParse(contentTypeValue, out MediaTypeHeaderValue contentType))
+        {
             return BodyType.Bytes;
         }
 
-        public static async Task<BodyData> ParseAsync([NotNull] BodyParserSettings settings)
+        if (TextContentTypeMatchers.Any(matcher => MatchScores.IsPerfect(matcher.IsMatch(contentType.MediaType))))
         {
-            Guard.NotNull(settings, nameof(settings));
+            return BodyType.String;
+        }
 
-            var bodyWithContentEncoding = await ReadBytesAsync(settings.Stream, settings.ContentEncoding, settings.DecompressGZipAndDeflate).ConfigureAwait(false);
-            var data = new BodyData
-            {
-                BodyAsBytes = bodyWithContentEncoding.Bytes,
-                DetectedCompression = bodyWithContentEncoding.ContentType,
-                DetectedBodyType = BodyType.Bytes,
-                DetectedBodyTypeFromContentType = DetectBodyTypeFromContentType(settings.ContentType)
-            };
+        if (JsonContentTypesMatchers.Any(matcher => MatchScores.IsPerfect(matcher.IsMatch(contentType.MediaType))))
+        {
+            return BodyType.Json;
+        }
 
-            // In case of MultiPart: check if the BodyAsBytes is a valid UTF8 or ASCII string, in that case read as String else keep as-is
-            if (data.DetectedBodyTypeFromContentType == BodyType.MultiPart)
-            {
-                if (BytesEncodingUtils.TryGetEncoding(data.BodyAsBytes, out Encoding encoding) &&
-                    SupportedBodyAsStringEncodingForMultipart.Select(x => x.Equals(encoding)).Any())
-                {
-                    data.BodyAsString = encoding.GetString(data.BodyAsBytes);
-                    data.Encoding = encoding;
-                    data.DetectedBodyType = BodyType.String;
-                }
-   
-                return data;
-            }
+        if (MultipartContentTypesMatchers.Any(matcher => MatchScores.IsPerfect(matcher.IsMatch(contentType.MediaType))))
+        {
+            return BodyType.MultiPart;
+        }
 
-            // Try to get the body as String
-            try
+        return BodyType.Bytes;
+    }
+
+    public static async Task<BodyData> ParseAsync(BodyParserSettings settings)
+    {
+        Guard.NotNull(settings);
+
+        var bodyWithContentEncoding = await ReadBytesAsync(settings.Stream, settings.ContentEncoding, settings.DecompressGZipAndDeflate).ConfigureAwait(false);
+        var data = new BodyData
+        {
+            BodyAsBytes = bodyWithContentEncoding.Bytes,
+            DetectedCompression = bodyWithContentEncoding.ContentType,
+            DetectedBodyType = BodyType.Bytes,
+            DetectedBodyTypeFromContentType = DetectBodyTypeFromContentType(settings.ContentType)
+        };
+
+        // In case of MultiPart: check if the BodyAsBytes is a valid UTF8 or ASCII string, in that case read as String else keep as-is
+        if (data.DetectedBodyTypeFromContentType == BodyType.MultiPart)
+        {
+            if (BytesEncodingUtils.TryGetEncoding(data.BodyAsBytes, out Encoding encoding) &&
+                SupportedBodyAsStringEncodingForMultipart.Select(x => x.Equals(encoding)).Any())
             {
-                data.BodyAsString = DefaultEncoding.GetString(data.BodyAsBytes);
-                data.Encoding = DefaultEncoding;
+                data.BodyAsString = encoding.GetString(data.BodyAsBytes);
+                data.Encoding = encoding;
                 data.DetectedBodyType = BodyType.String;
-
-                // If string is not null or empty, try to deserialize the string to a JObject
-                if (settings.DeserializeJson && !string.IsNullOrEmpty(data.BodyAsString))
-                {
-                    try
-                    {
-                        data.BodyAsJson = JsonUtils.DeserializeObject(data.BodyAsString);
-                        data.DetectedBodyType = BodyType.Json;
-                    }
-                    catch
-                    {
-                        // JsonConvert failed, just ignore.
-                    }
-                }
-            }
-            catch
-            {
-                // Reading as string failed, just ignore
             }
 
             return data;
         }
 
-        private static async Task<(string ContentType, byte[] Bytes)> ReadBytesAsync(Stream stream, string contentEncoding = null, bool decompressGZipAndDeflate = true)
+        // Try to get the body as String or Json
+        try
         {
-            using (var memoryStream = new MemoryStream())
+            data.BodyAsString = DefaultEncoding.GetString(data.BodyAsBytes);
+            data.Encoding = DefaultEncoding;
+            data.DetectedBodyType = BodyType.String;
+
+            // If string is not null or empty, try to deserialize the string to a JObject
+            if (settings.DeserializeJson && !string.IsNullOrEmpty(data.BodyAsString))
             {
-                await stream.CopyToAsync(memoryStream).ConfigureAwait(false);
-                byte[] data = memoryStream.ToArray();
-
-                string type = contentEncoding?.ToLowerInvariant();
-                if (decompressGZipAndDeflate && (type == "gzip" || type == "deflate"))
+                try
                 {
-                    return (type, CompressionUtils.Decompress(type, data));
+                    data.BodyAsJson = JsonUtils.DeserializeObject(data.BodyAsString);
+                    data.DetectedBodyType = BodyType.Json;
+                }
+                catch
+                {
+                    // JsonConvert failed, just ignore.
                 }
-
-                return (null, data);
             }
         }
+        catch
+        {
+            // Reading as string failed, just ignore
+        }
+
+        return data;
+    }
+
+    private static async Task<(string? ContentType, byte[] Bytes)> ReadBytesAsync(Stream stream, string? contentEncoding = null, bool decompressGZipAndDeflate = true)
+    {
+        using var memoryStream = new MemoryStream();
+        await stream.CopyToAsync(memoryStream).ConfigureAwait(false);
+        byte[] data = memoryStream.ToArray();
+
+        var type = contentEncoding?.ToLowerInvariant();
+        if (decompressGZipAndDeflate && type is "gzip" or "deflate")
+        {
+            return (type, CompressionUtils.Decompress(type, data));
+        }
+
+        return (null, data);
     }
 }

src/WireMock.Net/Util/BodyParserSettings.cs

@@ -1,17 +1,16 @@
-using System.IO;
+using System.IO;
 
-namespace WireMock.Util
+namespace WireMock.Util;
+
+internal class BodyParserSettings
 {
-    internal class BodyParserSettings
-    {
-        public Stream Stream { get; set; }
+    public Stream Stream { get; set; } = null!;
 
-        public string ContentType { get; set; }
+    public string? ContentType { get; set; }
 
-        public string ContentEncoding { get; set; }
+    public string? ContentEncoding { get; set; }
 
-        public bool DecompressGZipAndDeflate { get; set; } = true;
+    public bool DecompressGZipAndDeflate { get; set; } = true;
 
-        public bool DeserializeJson { get; set; } = true;
-    }
+    public bool DeserializeJson { get; set; } = true;
 }

src/WireMock.Net/Util/RegexUtils.cs

@@ -1,24 +1,53 @@
-using System.Collections.Generic;
+using System;
+using System.Collections.Generic;
 using System.Text.RegularExpressions;
+using WireMock.RegularExpressions;
 
-namespace WireMock.Util
+namespace WireMock.Util;
+
+internal static class RegexUtils
 {
-    internal static class RegexUtils
+    private static readonly TimeSpan RegexTimeOut = new(0, 0, 10);
+
+    public static Dictionary<string, string> GetNamedGroups(Regex regex, string input)
     {
-        public static Dictionary<string, string> GetNamedGroups(Regex regex, string input)
+        var namedGroupsDictionary = new Dictionary<string, string>();
+
+        GroupCollection groups = regex.Match(input).Groups;
+        foreach (string groupName in regex.GetGroupNames())
         {
-            var namedGroupsDictionary = new Dictionary<string, string>();
-
-            GroupCollection groups = regex.Match(input).Groups;
-            foreach (string groupName in regex.GetGroupNames())
+            if (groups[groupName].Captures.Count > 0)
             {
-                if (groups[groupName].Captures.Count > 0)
-                {
-                    namedGroupsDictionary.Add(groupName, groups[groupName].Value);
-                }
+                namedGroupsDictionary.Add(groupName, groups[groupName].Value);
             }
+        }
 
-            return namedGroupsDictionary;
+        return namedGroupsDictionary;
+    }
+
+    public static (bool IsValid, bool Result) MatchRegex(string pattern, string input, bool useRegexExtended = true)
+    {
+        if (string.IsNullOrEmpty(pattern))
+        {
+            return (false, false);
+        }
+
+        try
+        {
+            if (useRegexExtended)
+            {
+                var r = new RegexExtended(pattern, RegexOptions.None, RegexTimeOut);
+                return (true, r.IsMatch(input));
+            }
+            else
+            {
+                var r = new Regex(pattern, RegexOptions.None, RegexTimeOut);
+                return (true, r.IsMatch(input));
+            }
+        }
+        catch
+        {
+            return (false, false);
         }
     }
-}
+}

src/WireMock.Net/WireMock.Net.csproj

@@ -127,7 +127,7 @@
     </ItemGroup>
 
     <ItemGroup Condition=" '$(TargetFramework)' == 'netstandard2.0' or '$(TargetFramework)' == 'netstandard2.1' ">
-        <PackageReference Include="Scriban.Signed" Version="3.3.2" />
+        <PackageReference Include="Scriban.Signed" Version="5.5.0" />
         <PackageReference Include="Microsoft.AspNetCore" Version="2.2.0" />
         <PackageReference Include="Nullable" Version="1.3.0" />
 
@@ -137,7 +137,7 @@
 
     <ItemGroup Condition=" '$(TargetFramework)' == 'netcoreapp3.1' or '$(TargetFramework)' == 'net5.0' or '$(TargetFramework)' == 'net6.0' ">
         <FrameworkReference Include="Microsoft.AspNetCore.App" />
-        <PackageReference Include="Scriban.Signed" Version="3.3.2" />
+        <PackageReference Include="Scriban.Signed" Version="5.5.0" />
     </ItemGroup>
 
     <ItemGroup>

src/WireMock.Org.Abstractions/GetAdminMappingsByStubMappingIdResult.cs

@@ -0,0 +1,59 @@
+namespace WireMock.Org.Abstractions
+{
+    public class GetAdminMappingsByStubMappingIdResult
+    {
+        /// <summary>
+        /// This stub mapping's unique identifier
+        /// </summary>
+        public string Id { get; set; }
+
+        /// <summary>
+        /// Alias for the id
+        /// </summary>
+        public string Uuid { get; set; }
+
+        /// <summary>
+        /// The stub mapping's name
+        /// </summary>
+        public string Name { get; set; }
+
+        public WireMockOrgRequest Request { get; set; }
+
+        public WireMockOrgResponse Response { get; set; }
+
+        /// <summary>
+        /// Indicates that the stub mapping should be persisted immediately on create/update/delete and survive resets to default.
+        /// </summary>
+        public bool Persistent { get; set; }
+
+        /// <summary>
+        /// This stub mapping's priority relative to others. 1 is highest.
+        /// </summary>
+        public int Priority { get; set; }
+
+        /// <summary>
+        /// The name of the scenario that this stub mapping is part of
+        /// </summary>
+        public string ScenarioName { get; set; }
+
+        /// <summary>
+        /// The required state of the scenario in order for this stub to be matched.
+        /// </summary>
+        public string RequiredScenarioState { get; set; }
+
+        /// <summary>
+        /// The new state for the scenario to be updated to after this stub is served.
+        /// </summary>
+        public string NewScenarioState { get; set; }
+
+        /// <summary>
+        /// A map of the names of post serve action extensions to trigger and their parameters.
+        /// </summary>
+        public object PostServeActions { get; set; }
+
+        /// <summary>
+        /// Arbitrary metadata to be used for e.g. tagging, documentation. Can also be used to find and remove stubs.
+        /// </summary>
+        public object Metadata { get; set; }
+    }
+}

src/WireMock.Org.Abstractions/GetAdminMappingsResponse.cs

@@ -1,9 +0,0 @@
-namespace WireMock.Org.Abstractions
-{
-    public class GetAdminMappingsResponse
-    {
-        public Mapping[] Mappings { get; set; }
-
-        public Meta Meta { get; set; }
-    }
-}

src/WireMock.Org.Abstractions/GetAdminMappingsResult.cs

@@ -0,0 +1,9 @@
+namespace WireMock.Org.Abstractions
+{
+    public class GetAdminMappingsResult
+    {
+        public Mappings Mappings { get; set; }
+
+        public Meta Meta { get; set; }
+    }
+}

src/WireMock.Org.Abstractions/GetAdminRecordingsStatusResult.cs

@@ -1,7 +1,7 @@
 namespace WireMock.Org.Abstractions
 {
-    public class GetAdminRecordingsStatusResponse
+    public class GetAdminRecordingsStatusResult
     {
         public string Status { get; set; }
     }
-}
+}

src/WireMock.Org.Abstractions/GetAdminRequestsUnmatchedNearMissesResponse.cs

@@ -1,7 +0,0 @@
-namespace WireMock.Org.Abstractions
-{
-    public class GetAdminRequestsUnmatchedNearMissesResponse
-    {
-        public NearMiss[] NearMisses { get; set; }
-    }
-}

src/WireMock.Org.Abstractions/GetAdminRequestsUnmatchedNearMissesResult.cs

@@ -0,0 +1,7 @@
+namespace WireMock.Org.Abstractions
+{
+    public class GetAdminRequestsUnmatchedNearMissesResult
+    {
+        public NearMisses NearMisses { get; set; }
+    }
+}

src/WireMock.Org.Abstractions/GetAdminScenariosResponse.cs

@@ -1,7 +0,0 @@
-namespace WireMock.Org.Abstractions
-{
-    public class GetAdminScenariosResponse
-    {
-        public Scenario[] Scenarios { get; set; }
-    }
-}

src/WireMock.Org.Abstractions/GetAdminScenariosResult.cs

@@ -0,0 +1,7 @@
+namespace WireMock.Org.Abstractions
+{
+    public class GetAdminScenariosResult
+    {
+        public Scenarios Scenarios { get; set; }
+    }
+}

src/WireMock.Org.Abstractions/Mappings.cs

@@ -1,6 +1,6 @@
 namespace WireMock.Org.Abstractions
 {
-    public class Mapping
+    public class Mappings
     {
         /// <summary>
         /// This stub mapping's unique identifier
@@ -17,9 +17,9 @@ namespace WireMock.Org.Abstractions
         /// </summary>
         public string Name { get; set; }
 
-        public Request Request { get; set; }
+        public MappingsRequest Request { get; set; }
 
-        public Response Response { get; set; }
+        public MappingsResponse Response { get; set; }
 
         /// <summary>
         /// Indicates that the stub mapping should be persisted immediately on create/update/delete and survive resets to default.
@@ -56,4 +56,4 @@ namespace WireMock.Org.Abstractions
         /// </summary>
         public object Metadata { get; set; }
     }
-}
+}

src/WireMock.Org.Abstractions/MappingsRequest.cs

@@ -0,0 +1,55 @@
+namespace WireMock.Org.Abstractions
+{
+    public class MappingsRequest
+    {
+        /// <summary>
+        /// The HTTP request method e.g. GET
+        /// </summary>
+        public string Method { get; set; }
+
+        /// <summary>
+        /// The path and query to match exactly against. Only one of url, urlPattern, urlPath or urlPathPattern may be specified.
+        /// </summary>
+        public string Url { get; set; }
+
+        /// <summary>
+        /// The path to match exactly against. Only one of url, urlPattern, urlPath or urlPathPattern may be specified.
+        /// </summary>
+        public string UrlPath { get; set; }
+
+        /// <summary>
+        /// The path regex to match against. Only one of url, urlPattern, urlPath or urlPathPattern may be specified.
+        /// </summary>
+        public string UrlPathPattern { get; set; }
+
+        /// <summary>
+        /// The path and query regex to match against. Only one of url, urlPattern, urlPath or urlPathPattern may be specified.
+        /// </summary>
+        public string UrlPattern { get; set; }
+
+        /// <summary>
+        /// Query parameter patterns to match against in the : { "": "" } form
+        /// </summary>
+        public object QueryParameters { get; set; }
+
+        /// <summary>
+        /// Header patterns to match against in the : { "": "" } form
+        /// </summary>
+        public object Headers { get; set; }
+
+        /// <summary>
+        /// Pre-emptive basic auth credentials to match against
+        /// </summary>
+        public MappingsRequestBasicAuthCredentials BasicAuthCredentials { get; set; }
+
+        /// <summary>
+        /// Cookie patterns to match against in the : { "": "" } form
+        /// </summary>
+        public object Cookies { get; set; }
+
+        /// <summary>
+        /// Request body patterns to match against in the : { "": "" } form
+        /// </summary>
+        public object[] BodyPatterns { get; set; }
+    }
+}

src/WireMock.Org.Abstractions/MappingsRequestBasicAuthCredentials.cs

@@ -0,0 +1,12 @@
+namespace WireMock.Org.Abstractions
+{
+    /// <summary>
+    /// Pre-emptive basic auth credentials to match against
+    /// </summary>
+    public class MappingsRequestBasicAuthCredentials
+    {
+        public string Password { get; set; }
+
+        public string Username { get; set; }
+    }
+}

src/WireMock.Org.Abstractions/MappingsResponse.cs

@@ -0,0 +1,80 @@
+namespace WireMock.Org.Abstractions
+{
+    public class MappingsResponse
+    {
+        /// <summary>
+        /// The HTTP status code to be returned
+        /// </summary>
+        public int Status { get; set; }
+
+        /// <summary>
+        /// The HTTP status message to be returned
+        /// </summary>
+        public string StatusMessage { get; set; }
+
+        /// <summary>
+        /// Map of response headers to send
+        /// </summary>
+        public object Headers { get; set; }
+
+        /// <summary>
+        /// Extra request headers to send when proxying to another host.
+        /// </summary>
+        public object AdditionalProxyRequestHeaders { get; set; }
+
+        /// <summary>
+        /// The response body as a string. Only one of body, base64Body, jsonBody or bodyFileName may be specified.
+        /// </summary>
+        public string Body { get; set; }
+
+        /// <summary>
+        /// The response body as a base64 encoded string (useful for binary content). Only one of body, base64Body, jsonBody or bodyFileName may be specified.
+        /// </summary>
+        public string Base64Body { get; set; }
+
+        /// <summary>
+        /// The response body as a JSON object. Only one of body, base64Body, jsonBody or bodyFileName may be specified.
+        /// </summary>
+        public object JsonBody { get; set; }
+
+        /// <summary>
+        /// The path to the file containing the response body, relative to the configured file root. Only one of body, base64Body, jsonBody or bodyFileName may be specified.
+        /// </summary>
+        public string BodyFileName { get; set; }
+
+        /// <summary>
+        /// The fault to apply (instead of a full, valid response).
+        /// </summary>
+        public string Fault { get; set; }
+
+        /// <summary>
+        /// Number of milliseconds to delay be before sending the response.
+        /// </summary>
+        public int FixedDelayMilliseconds { get; set; }
+
+        /// <summary>
+        /// The delay distribution. Valid property configuration is either median/sigma/type or lower/type/upper.
+        /// </summary>
+        public object DelayDistribution { get; set; }
+
+        /// <summary>
+        /// Read-only flag indicating false if this was the default, unmatched response. Not present otherwise.
+        /// </summary>
+        public bool FromConfiguredStub { get; set; }
+
+        /// <summary>
+        /// The base URL of the target to proxy matching requests to.
+        /// </summary>
+        public string ProxyBaseUrl { get; set; }
+
+        /// <summary>
+        /// Parameters to apply to response transformers.
+        /// </summary>
+        public object TransformerParameters { get; set; }
+
+        /// <summary>
+        /// List of names of transformers to apply to this response.
+        /// </summary>
+        public string[] Transformers { get; set; }
+    }
+}

src/WireMock.Org.Abstractions/MappingsResponseFaultConstants.cs

@@ -0,0 +1,16 @@
+namespace WireMock.Org.Abstractions
+{
+    /// <summary>
+    /// The fault to apply (instead of a full, valid response).
+    /// </summary>
+    public static class MappingsResponseFaultConstants
+    {
+        public const string CONNECTIONRESETBYPEER = "CONNECTION_RESET_BY_PEER";
+
+        public const string EMPTYRESPONSE = "EMPTY_RESPONSE";
+
+        public const string MALFORMEDRESPONSECHUNK = "MALFORMED_RESPONSE_CHUNK";
+
+        public const string RANDOMDATATHENCLOSE = "RANDOM_DATA_THEN_CLOSE";
+    }
+}

src/WireMock.Org.Abstractions/Meta.cs

@@ -4,4 +4,4 @@ namespace WireMock.Org.Abstractions
     {
         public int Total { get; set; }
     }
-}
+}

src/WireMock.Org.Abstractions/NearMisses.cs

@@ -1,6 +1,6 @@
 namespace WireMock.Org.Abstractions
 {
-    public class NearMiss
+    public class NearMisses
     {
         /// <summary>
         /// The HTTP request method
@@ -18,12 +18,12 @@ namespace WireMock.Org.Abstractions
         public string AbsoluteUrl { get; set; }
 
         /// <summary>
-        /// Header patterns to match against in the &lt;key&gt;: { "&lt;predicate&gt;": "&lt;value&gt;" } form
+        /// Header patterns to match against in the : { "": "" } form
         /// </summary>
         public object Headers { get; set; }
 
         /// <summary>
-        /// Cookie patterns to match against in the &lt;key&gt;: { "&lt;predicate&gt;": "&lt;value&gt;" } form
+        /// Cookie patterns to match against in the : { "": "" } form
         /// </summary>
         public object Cookies { get; set; }
 
@@ -32,4 +32,4 @@ namespace WireMock.Org.Abstractions
         /// </summary>
         public string Body { get; set; }
     }
-}
+}

src/WireMock.Org.Abstractions/PostAdminMappingsFindByMetadataResult.cs

@@ -0,0 +1,9 @@
+namespace WireMock.Org.Abstractions
+{
+    public class PostAdminMappingsFindByMetadataResult
+    {
+        public Mappings Mappings { get; set; }
+
+        public Meta Meta { get; set; }
+    }
+}

src/WireMock.Org.Abstractions/PostAdminMappingsResult.cs

@@ -0,0 +1,59 @@
+namespace WireMock.Org.Abstractions
+{
+    public class PostAdminMappingsResult
+    {
+        /// <summary>
+        /// This stub mapping's unique identifier
+        /// </summary>
+        public string Id { get; set; }
+
+        /// <summary>
+        /// Alias for the id
+        /// </summary>
+        public string Uuid { get; set; }
+
+        /// <summary>
+        /// The stub mapping's name
+        /// </summary>
+        public string Name { get; set; }
+
+        public WireMockOrgRequest Request { get; set; }
+
+        public WireMockOrgResponse Response { get; set; }
+
+        /// <summary>
+        /// Indicates that the stub mapping should be persisted immediately on create/update/delete and survive resets to default.
+        /// </summary>
+        public bool Persistent { get; set; }
+
+        /// <summary>
+        /// This stub mapping's priority relative to others. 1 is highest.
+        /// </summary>
+        public int Priority { get; set; }
+
+        /// <summary>
+        /// The name of the scenario that this stub mapping is part of
+        /// </summary>
+        public string ScenarioName { get; set; }
+
+        /// <summary>
+        /// The required state of the scenario in order for this stub to be matched.
+        /// </summary>
+        public string RequiredScenarioState { get; set; }
+
+        /// <summary>
+        /// The new state for the scenario to be updated to after this stub is served.
+        /// </summary>
+        public string NewScenarioState { get; set; }
+
+        /// <summary>
+        /// A map of the names of post serve action extensions to trigger and their parameters.
+        /// </summary>
+        public object PostServeActions { get; set; }
+
+        /// <summary>
+        /// Arbitrary metadata to be used for e.g. tagging, documentation. Can also be used to find and remove stubs.
+        /// </summary>
+        public object Metadata { get; set; }
+    }
+}

src/WireMock.Org.Abstractions/PostAdminNearMissesRequestPatternResult.cs

@@ -0,0 +1,7 @@
+namespace WireMock.Org.Abstractions
+{
+    public class PostAdminNearMissesRequestPatternResult
+    {
+        public NearMisses NearMisses { get; set; }
+    }
+}

src/WireMock.Org.Abstractions/PostAdminNearMissesRequestResult.cs

@@ -0,0 +1,7 @@
+namespace WireMock.Org.Abstractions
+{
+    public class PostAdminNearMissesRequestResult
+    {
+        public NearMisses NearMisses { get; set; }
+    }
+}

src/WireMock.Org.Abstractions/PostAdminRecordingsSnapshotResult.cs

@@ -0,0 +1,9 @@
+namespace WireMock.Org.Abstractions
+{
+    public class PostAdminRecordingsSnapshotResult
+    {
+        public Mappings Mappings { get; set; }
+
+        public Meta Meta { get; set; }
+    }
+}

src/WireMock.Org.Abstractions/PostAdminRecordingsStopResult.cs

@@ -0,0 +1,9 @@
+namespace WireMock.Org.Abstractions
+{
+    public class PostAdminRecordingsStopResult
+    {
+        public Mappings Mappings { get; set; }
+
+        public Meta Meta { get; set; }
+    }
+}

src/WireMock.Org.Abstractions/PostAdminRequestsCountResult.cs

@@ -1,7 +1,7 @@
 namespace WireMock.Org.Abstractions
 {
-    public class PostAdminRequestsCountResponse
+    public class PostAdminRequestsCountResult
     {
         public int Count { get; set; }
     }
-}
+}

src/WireMock.Org.Abstractions/PutAdminMappingsByStubMappingIdResult.cs

@@ -0,0 +1,59 @@
+namespace WireMock.Org.Abstractions
+{
+    public class PutAdminMappingsByStubMappingIdResult
+    {
+        /// <summary>
+        /// This stub mapping's unique identifier
+        /// </summary>
+        public string Id { get; set; }
+
+        /// <summary>
+        /// Alias for the id
+        /// </summary>
+        public string Uuid { get; set; }
+
+        /// <summary>
+        /// The stub mapping's name
+        /// </summary>
+        public string Name { get; set; }
+
+        public WireMockOrgRequest Request { get; set; }
+
+        public WireMockOrgResponse Response { get; set; }
+
+        /// <summary>
+        /// Indicates that the stub mapping should be persisted immediately on create/update/delete and survive resets to default.
+        /// </summary>
+        public bool Persistent { get; set; }
+
+        /// <summary>
+        /// This stub mapping's priority relative to others. 1 is highest.
+        /// </summary>
+        public int Priority { get; set; }
+
+        /// <summary>
+        /// The name of the scenario that this stub mapping is part of
+        /// </summary>
+        public string ScenarioName { get; set; }
+
+        /// <summary>
+        /// The required state of the scenario in order for this stub to be matched.
+        /// </summary>
+        public string RequiredScenarioState { get; set; }
+
+        /// <summary>
+        /// The new state for the scenario to be updated to after this stub is served.
+        /// </summary>
+        public string NewScenarioState { get; set; }
+
+        /// <summary>
+        /// A map of the names of post serve action extensions to trigger and their parameters.
+        /// </summary>
+        public object PostServeActions { get; set; }
+
+        /// <summary>
+        /// Arbitrary metadata to be used for e.g. tagging, documentation. Can also be used to find and remove stubs.
+        /// </summary>
+        public object Metadata { get; set; }
+    }
+}

src/WireMock.Org.Abstractions/Request.cs

@@ -1,6 +1,6 @@
 namespace WireMock.Org.Abstractions
 {
-    public class Request
+    public class WireMockOrgRequest
     {
         /// <summary>
         /// The HTTP request method e.g. GET
@@ -28,28 +28,28 @@ namespace WireMock.Org.Abstractions
         public string UrlPattern { get; set; }
 
         /// <summary>
-        /// Query parameter patterns to match against in the &lt;key&gt;: { "&lt;predicate&gt;": "&lt;value&gt;" } form
+        /// Query parameter patterns to match against in the : { "": "" } form
         /// </summary>
         public object QueryParameters { get; set; }
 
         /// <summary>
-        /// Header patterns to match against in the &lt;key&gt;: { "&lt;predicate&gt;": "&lt;value&gt;" } form
+        /// Header patterns to match against in the : { "": "" } form
         /// </summary>
         public object Headers { get; set; }
 
         /// <summary>
         /// Pre-emptive basic auth credentials to match against
         /// </summary>
-        public BasicAuthCredentials BasicAuthCredentials { get; set; }
+        public RequestBasicAuthCredentials BasicAuthCredentials { get; set; }
 
         /// <summary>
-        /// Cookie patterns to match against in the &lt;key&gt;: { "&lt;predicate&gt;": "&lt;value&gt;" } form
+        /// Cookie patterns to match against in the : { "": "" } form
         /// </summary>
         public object Cookies { get; set; }
 
         /// <summary>
-        /// Request body patterns to match against in the &lt;key&gt;: { "&lt;predicate&gt;": "&lt;value&gt;" } form
+        /// Request body patterns to match against in the : { "": "" } form
         /// </summary>
         public object[] BodyPatterns { get; set; }
     }
-}
+}

src/WireMock.Org.Abstractions/RequestBasicAuthCredentials.cs

@@ -3,10 +3,10 @@ namespace WireMock.Org.Abstractions
     /// <summary>
     /// Pre-emptive basic auth credentials to match against
     /// </summary>
-    public class BasicAuthCredentials
+    public class RequestBasicAuthCredentials
     {
         public string Password { get; set; }
 
         public string Username { get; set; }
     }
-}
+}

src/WireMock.Org.Abstractions/Response.cs

@@ -1,6 +1,6 @@
 namespace WireMock.Org.Abstractions
 {
-    public class Response
+    public class WireMockOrgResponse
     {
         /// <summary>
         /// The HTTP status code to be returned
@@ -52,6 +52,11 @@ namespace WireMock.Org.Abstractions
         /// </summary>
         public int FixedDelayMilliseconds { get; set; }
 
+        /// <summary>
+        /// The delay distribution. Valid property configuration is either median/sigma/type or lower/type/upper.
+        /// </summary>
+        public object DelayDistribution { get; set; }
+
         /// <summary>
         /// Read-only flag indicating false if this was the default, unmatched response. Not present otherwise.
         /// </summary>
@@ -70,6 +75,6 @@ namespace WireMock.Org.Abstractions
         /// <summary>
         /// List of names of transformers to apply to this response.
         /// </summary>
-        public string Transformers { get; set; }
+        public string[] Transformers { get; set; }
     }
-}
+}

src/WireMock.Org.Abstractions/ResponseFaultConstants.cs

@@ -0,0 +1,16 @@
+namespace WireMock.Org.Abstractions
+{
+    /// <summary>
+    /// The fault to apply (instead of a full, valid response).
+    /// </summary>
+    public static class ResponseFaultConstants
+    {
+        public const string CONNECTIONRESETBYPEER = "CONNECTION_RESET_BY_PEER";
+
+        public const string EMPTYRESPONSE = "EMPTY_RESPONSE";
+
+        public const string MALFORMEDRESPONSECHUNK = "MALFORMED_RESPONSE_CHUNK";
+
+        public const string RANDOMDATATHENCLOSE = "RANDOM_DATA_THEN_CLOSE";
+    }
+}

src/WireMock.Org.Abstractions/ResponseLogNormal.cs

@@ -1,14 +0,0 @@
-namespace WireMock.Org.Abstractions
-{
-    /// <summary>
-    /// Log normal randomly distributed response delay.
-    /// </summary>
-    public class ResponseLogNormal
-    {
-        public int Median { get; set; }
-
-        public double Sigma { get; set; }
-
-        public string Type { get; set; }
-    }
-}

src/WireMock.Org.Abstractions/ResponseLogUniformlyDistributed.cs

@@ -1,14 +0,0 @@
-namespace WireMock.Org.Abstractions
-{
-    /// <summary>
-    /// Uniformly distributed random response delay.
-    /// </summary>
-    public class ResponseLogUniformlyDistributed
-    {
-        public int Lower { get; set; }
-
-        public string Type { get; set; }
-
-        public int Upper { get; set; }
-    }
-}

src/WireMock.Org.Abstractions/Scenarios.cs

@@ -1,6 +1,6 @@
 namespace WireMock.Org.Abstractions
 {
-    public class Scenario
+    public class Scenarios
     {
         /// <summary>
         /// The scenario ID
@@ -12,11 +12,14 @@ namespace WireMock.Org.Abstractions
         /// </summary>
         public string Name { get; set; }
 
-        public string PossibleStates { get; set; }
+        /// <summary>
+        /// All the states this scenario can be in
+        /// </summary>
+        public string[] PossibleStates { get; set; }
 
         /// <summary>
         /// The current state of this scenario
         /// </summary>
         public string State { get; set; }
     }
-}
+}

src/WireMock.Org.Abstractions/StatusConstants.cs

@@ -0,0 +1,11 @@
+namespace WireMock.Org.Abstractions
+{
+    public static class StatusConstants
+    {
+        public const string NeverStarted = "NeverStarted";
+
+        public const string Recording = "Recording";
+
+        public const string Stopped = "Stopped";
+    }
+}

src/WireMock.Org.RestClient/IWireMockOrgApi.cs

@@ -1,232 +1,299 @@
+using System;
+using System.Collections.Generic;
 using System.IO;
+using System.Net.Http;
+using System.Net.Http.Headers;
 using System.Threading.Tasks;
+using AnyOfTypes;
 using RestEase;
 using WireMock.Org.Abstractions;
 
 namespace WireMock.Org.RestClient
 {
     /// <summary>
-    /// WireMockOrg
+    /// Summary: WireMockOrg
+    ///
+    /// Title  : WireMock
+    /// Version: 2.33.2
     /// </summary>
     public interface IWireMockOrgApi
     {
         /// <summary>
         /// Get all stub mappings
+        ///
+        /// GetAdminMappings (/__admin/mappings)
         /// </summary>
         /// <param name="limit">The maximum number of results to return</param>
         /// <param name="offset">The start index of the results to return</param>
         [Get("/__admin/mappings")]
-        Task<GetAdminMappingsResponse> GetAdminMappingsAsync([Query] int? limit, [Query] int? offset);
+        Task<GetAdminMappingsResult> GetAdminMappingsAsync([Query] int? limit, [Query] int? offset);
 
         /// <summary>
         /// Create a new stub mapping
+        ///
+        /// PostAdminMappings (/__admin/mappings)
         /// </summary>
-        /// <param name="request"></param>
         [Post("/__admin/mappings")]
         [Header("Content-Type", "application/json")]
-        Task<Mapping> PostAdminMappingsAsync([Body] Mapping request);
+        Task<PostAdminMappingsResult> PostAdminMappingsAsync();
 
         /// <summary>
         /// Delete all stub mappings
+        ///
+        /// DeleteAdminMappings (/__admin/mappings)
         /// </summary>
         [Delete("/__admin/mappings")]
-        Task DeleteAdminMappingsAsync();
+        Task<object> DeleteAdminMappingsAsync();
 
         /// <summary>
         /// Reset stub mappings
+        ///
+        /// PostAdminMappingsReset (/__admin/mappings/reset)
         /// </summary>
         [Post("/__admin/mappings/reset")]
-        Task PostAdminMappingsResetAsync();
+        Task<object> PostAdminMappingsResetAsync();
 
         /// <summary>
         /// Persist stub mappings
+        ///
+        /// PostAdminMappingsSave (/__admin/mappings/save)
         /// </summary>
         [Post("/__admin/mappings/save")]
-        Task PostAdminMappingsSaveAsync();
+        Task<object> PostAdminMappingsSaveAsync();
 
         /// <summary>
         /// Get stub mapping by ID
+        ///
+        /// GetAdminMappingsByStubMappingId (/__admin/mappings/{stubMappingId})
         /// </summary>
+        /// <param name="stubMappingId">The UUID of stub mapping</param>
         [Get("/__admin/mappings/{stubMappingId}")]
-        Task<Mapping> GetAdminMappingsByStubMappingIdAsync();
+        Task<Response<AnyOf<GetAdminMappingsByStubMappingIdResult, object>>> GetAdminMappingsByStubMappingIdAsync([Path] string stubMappingId);
 
         /// <summary>
         /// Update a stub mapping
+        ///
+        /// PutAdminMappingsByStubMappingId (/__admin/mappings/{stubMappingId})
         /// </summary>
-        /// <param name="request"></param>
+        /// <param name="stubMappingId">The UUID of stub mapping</param>
         [Put("/__admin/mappings/{stubMappingId}")]
         [Header("Content-Type", "application/json")]
-        Task<Mapping> PutAdminMappingsByStubMappingIdAsync([Body] Mapping request);
+        Task<Response<AnyOf<PutAdminMappingsByStubMappingIdResult, object>>> PutAdminMappingsByStubMappingIdAsync([Path] string stubMappingId);
 
         /// <summary>
         /// Delete a stub mapping
+        ///
+        /// DeleteAdminMappingsByStubMappingId (/__admin/mappings/{stubMappingId})
         /// </summary>
+        /// <param name="stubMappingId">The UUID of stub mapping</param>
         [Delete("/__admin/mappings/{stubMappingId}")]
-        Task DeleteAdminMappingsByStubMappingIdAsync();
+        Task<object> DeleteAdminMappingsByStubMappingIdAsync([Path] string stubMappingId);
 
         /// <summary>
+        /// Find stubs by matching on their metadata
+        ///
         /// PostAdminMappingsFindByMetadata (/__admin/mappings/find-by-metadata)
         /// </summary>
         [Post("/__admin/mappings/find-by-metadata")]
         [Header("Content-Type", "application/json")]
-        Task<GetAdminMappingsResponse> PostAdminMappingsFindByMetadataAsync();
+        Task<PostAdminMappingsFindByMetadataResult> PostAdminMappingsFindByMetadataAsync();
 
         /// <summary>
         /// Delete stub mappings matching metadata
+        ///
+        /// PostAdminMappingsRemoveByMetadata (/__admin/mappings/remove-by-metadata)
         /// </summary>
         [Post("/__admin/mappings/remove-by-metadata")]
         [Header("Content-Type", "application/json")]
-        Task PostAdminMappingsRemoveByMetadataAsync();
+        Task<object> PostAdminMappingsRemoveByMetadataAsync();
 
         /// <summary>
         /// Get all requests in journal
+        ///
+        /// GetAdminRequests (/__admin/requests)
         /// </summary>
         /// <param name="limit">The maximum number of results to return</param>
         /// <param name="since">Only return logged requests after this date</param>
         [Get("/__admin/requests")]
-        Task GetAdminRequestsAsync([Query] string limit, [Query] string since);
+        Task<object> GetAdminRequestsAsync([Query] string limit, [Query] string since);
 
         /// <summary>
         /// Delete all requests in journal
+        ///
+        /// DeleteAdminRequests (/__admin/requests)
         /// </summary>
         [Delete("/__admin/requests")]
-        Task DeleteAdminRequestsAsync();
+        Task<object> DeleteAdminRequestsAsync();
 
         /// <summary>
         /// Get request by ID
+        ///
+        /// GetAdminRequestsByRequestId (/__admin/requests/{requestId})
         /// </summary>
         /// <param name="requestId">The UUID of the logged request</param>
         [Get("/__admin/requests/{requestId}")]
-        Task GetAdminRequestsByRequestIdAsync([Path] string requestId);
+        Task<object> GetAdminRequestsByRequestIdAsync([Path] string requestId);
 
         /// <summary>
         /// Delete request by ID
+        ///
+        /// DeleteAdminRequestsByRequestId (/__admin/requests/{requestId})
         /// </summary>
         /// <param name="requestId">The UUID of the logged request</param>
         [Delete("/__admin/requests/{requestId}")]
-        Task DeleteAdminRequestsByRequestIdAsync([Path] string requestId);
+        Task<object> DeleteAdminRequestsByRequestIdAsync([Path] string requestId);
 
         /// <summary>
         /// Empty the request journal
+        ///
+        /// PostAdminRequestsReset (/__admin/requests/reset)
         /// </summary>
         [Post("/__admin/requests/reset")]
-        Task PostAdminRequestsResetAsync();
+        Task<object> PostAdminRequestsResetAsync();
 
         /// <summary>
         /// Count requests by criteria
+        ///
+        /// PostAdminRequestsCount (/__admin/requests/count)
         /// </summary>
-        /// <param name="request"></param>
         [Post("/__admin/requests/count")]
         [Header("Content-Type", "application/json")]
-        Task<PostAdminRequestsCountResponse> PostAdminRequestsCountAsync([Body] Request request);
+        Task<PostAdminRequestsCountResult> PostAdminRequestsCountAsync();
 
         /// <summary>
         /// Remove requests by criteria
+        ///
+        /// PostAdminRequestsRemove (/__admin/requests/remove)
         /// </summary>
-        /// <param name="request"></param>
         [Post("/__admin/requests/remove")]
         [Header("Content-Type", "application/json")]
-        Task PostAdminRequestsRemoveAsync([Body] Request request);
+        Task<object> PostAdminRequestsRemoveAsync();
 
         /// <summary>
         /// Delete requests mappings matching metadata
+        ///
+        /// PostAdminRequestsRemoveByMetadata (/__admin/requests/remove-by-metadata)
         /// </summary>
         [Post("/__admin/requests/remove-by-metadata")]
         [Header("Content-Type", "application/json")]
-        Task PostAdminRequestsRemoveByMetadataAsync();
+        Task<object> PostAdminRequestsRemoveByMetadataAsync();
 
         /// <summary>
         /// Find requests by criteria
+        ///
+        /// PostAdminRequestsFind (/__admin/requests/find)
         /// </summary>
-        /// <param name="request"></param>
         [Post("/__admin/requests/find")]
         [Header("Content-Type", "application/json")]
-        Task PostAdminRequestsFindAsync([Body] Request request);
+        Task<object> PostAdminRequestsFindAsync();
 
         /// <summary>
         /// Find unmatched requests
+        ///
+        /// GetAdminRequestsUnmatched (/__admin/requests/unmatched)
         /// </summary>
         [Get("/__admin/requests/unmatched")]
-        Task GetAdminRequestsUnmatchedAsync();
+        Task<object> GetAdminRequestsUnmatchedAsync();
 
         /// <summary>
+        /// Retrieve near-misses for all unmatched requests
+        ///
         /// GetAdminRequestsUnmatchedNearMisses (/__admin/requests/unmatched/near-misses)
         /// </summary>
         [Get("/__admin/requests/unmatched/near-misses")]
-        Task<GetAdminRequestsUnmatchedNearMissesResponse> GetAdminRequestsUnmatchedNearMissesAsync();
+        Task<GetAdminRequestsUnmatchedNearMissesResult> GetAdminRequestsUnmatchedNearMissesAsync();
 
         /// <summary>
         /// Find near misses matching specific request
+        ///
+        /// PostAdminNearMissesRequest (/__admin/near-misses/request)
         /// </summary>
-        /// <param name="request"></param>
         [Post("/__admin/near-misses/request")]
         [Header("Content-Type", "application/json")]
-        Task<GetAdminRequestsUnmatchedNearMissesResponse> PostAdminNearMissesRequestAsync([Body] NearMiss request);
+        Task<PostAdminNearMissesRequestResult> PostAdminNearMissesRequestAsync();
 
         /// <summary>
         /// Find near misses matching request pattern
+        ///
+        /// PostAdminNearMissesRequestPattern (/__admin/near-misses/request-pattern)
         /// </summary>
-        /// <param name="request"></param>
         [Post("/__admin/near-misses/request-pattern")]
         [Header("Content-Type", "application/json")]
-        Task<GetAdminRequestsUnmatchedNearMissesResponse> PostAdminNearMissesRequestPatternAsync([Body] Request request);
+        Task<PostAdminNearMissesRequestPatternResult> PostAdminNearMissesRequestPatternAsync();
 
         /// <summary>
         /// Start recording
+        ///
+        /// PostAdminRecordingsStart (/__admin/recordings/start)
         /// </summary>
         [Post("/__admin/recordings/start")]
         [Header("Content-Type", "application/json")]
-        Task PostAdminRecordingsStartAsync();
+        Task<object> PostAdminRecordingsStartAsync();
 
         /// <summary>
         /// Stop recording
+        ///
+        /// PostAdminRecordingsStop (/__admin/recordings/stop)
         /// </summary>
         [Post("/__admin/recordings/stop")]
-        Task<GetAdminMappingsResponse> PostAdminRecordingsStopAsync();
+        Task<PostAdminRecordingsStopResult> PostAdminRecordingsStopAsync();
 
         /// <summary>
         /// Get recording status
+        ///
+        /// GetAdminRecordingsStatus (/__admin/recordings/status)
         /// </summary>
         [Get("/__admin/recordings/status")]
-        Task<GetAdminRecordingsStatusResponse> GetAdminRecordingsStatusAsync();
+        Task<GetAdminRecordingsStatusResult> GetAdminRecordingsStatusAsync();
 
         /// <summary>
         /// Take a snapshot recording
+        ///
+        /// PostAdminRecordingsSnapshot (/__admin/recordings/snapshot)
         /// </summary>
-        /// <param name="request"></param>
         [Post("/__admin/recordings/snapshot")]
         [Header("Content-Type", "application/json")]
-        Task<GetAdminMappingsResponse> PostAdminRecordingsSnapshotAsync([Body] object request);
+        Task<PostAdminRecordingsSnapshotResult> PostAdminRecordingsSnapshotAsync();
 
         /// <summary>
         /// Get all scenarios
+        ///
+        /// GetAdminScenarios (/__admin/scenarios)
         /// </summary>
         [Get("/__admin/scenarios")]
-        Task<GetAdminScenariosResponse> GetAdminScenariosAsync();
+        Task<GetAdminScenariosResult> GetAdminScenariosAsync();
 
         /// <summary>
         /// Reset the state of all scenarios
+        ///
+        /// PostAdminScenariosReset (/__admin/scenarios/reset)
         /// </summary>
         [Post("/__admin/scenarios/reset")]
-        Task PostAdminScenariosResetAsync();
+        Task<object> PostAdminScenariosResetAsync();
 
         /// <summary>
         /// Update global settings
+        ///
+        /// PostAdminSettings (/__admin/settings)
         /// </summary>
         [Post("/__admin/settings")]
         [Header("Content-Type", "application/json")]
-        Task PostAdminSettingsAsync();
+        Task<object> PostAdminSettingsAsync();
 
         /// <summary>
         /// Reset mappings and request journal
+        ///
+        /// PostAdminReset (/__admin/reset)
         /// </summary>
         [Post("/__admin/reset")]
-        Task PostAdminResetAsync();
+        Task<object> PostAdminResetAsync();
 
         /// <summary>
+        /// Shutdown the WireMock server
+        ///
         /// PostAdminShutdown (/__admin/shutdown)
         /// </summary>
         [Post("/__admin/shutdown")]
-        Task PostAdminShutdownAsync();
+        Task<object> PostAdminShutdownAsync();
     }
-}
+}

src/WireMock.Org.RestClient/WireMock.Org.RestClient.csproj

@@ -30,8 +30,9 @@
     </PropertyGroup>
 
     <ItemGroup>
+        <PackageReference Include="AnyOf" Version="0.3.0" />
         <PackageReference Include="Microsoft.SourceLink.GitHub" Version="1.1.1" PrivateAssets="All" />
-        <PackageReference Include="RestEase" Version="1.5.6" />
+        <PackageReference Include="RestEase" Version="1.5.7" />
     </ItemGroup>
 
     <ItemGroup>

test/WireMock.Net.Tests/Matchers/JsonMatcherTests.cs

@@ -1,299 +1,356 @@
-using System;
+using System;
 using System.IO;
 using FluentAssertions;
 using Newtonsoft.Json;
+using Newtonsoft.Json.Converters;
 using Newtonsoft.Json.Linq;
 using NFluent;
 using WireMock.Matchers;
 using Xunit;
 
-namespace WireMock.Net.Tests.Matchers
+namespace WireMock.Net.Tests.Matchers;
+
+public class JsonMatcherTests
 {
-    public class JsonMatcherTests
+    [JsonConverter(typeof(StringEnumConverter))]
+    public enum EnumWithJsonConverter
     {
-        [Fact]
-        public void JsonMatcher_GetName()
+        Type1
+    }
+
+    public enum NormalEnum
+    {
+        Abc
+    }
+
+    public class Test1
+    {
+        public NormalEnum NormalEnum { get; set; }
+    }
+
+    public class Test2
+    {
+        public EnumWithJsonConverter EnumWithJsonConverter { get; set; }
+    }
+
+    [Fact]
+    public void JsonMatcher_GetName()
+    {
+        // Assign
+        var matcher = new JsonMatcher("{}");
+
+        // Act
+        string name = matcher.Name;
+
+        // Assert
+        Check.That(name).Equals("JsonMatcher");
+    }
+
+    [Fact]
+    public void JsonMatcher_GetValue()
+    {
+        // Assign
+        var matcher = new JsonMatcher("{}");
+
+        // Act
+        object value = matcher.Value;
+
+        // Assert
+        Check.That(value).Equals("{}");
+    }
+
+    [Fact]
+    public void JsonMatcher_WithInvalidStringValue_Should_ThrowException()
+    {
+        // Act
+        // ReSharper disable once ObjectCreationAsStatement
+        Action action = () => new JsonMatcher(MatchBehaviour.AcceptOnMatch, "{ \"Id\"");
+
+        // Assert
+        action.Should().Throw<JsonException>();
+    }
+
+    [Fact]
+    public void JsonMatcher_WithInvalidObjectValue_Should_ThrowException()
+    {
+        // Act
+        // ReSharper disable once ObjectCreationAsStatement
+        Action action = () => new JsonMatcher(MatchBehaviour.AcceptOnMatch, new MemoryStream());
+
+        // Assert
+        action.Should().Throw<JsonException>();
+    }
+
+    [Fact]
+    public void JsonMatcher_IsMatch_WithInvalidValue_And_ThrowExceptionIsFalse_Should_ReturnMismatch()
+    {
+        // Assign
+        var matcher = new JsonMatcher("");
+
+        // Act
+        double match = matcher.IsMatch(new MemoryStream());
+
+        // Assert 
+        Check.That(match).IsEqualTo(0);
+    }
+
+    [Fact]
+    public void JsonMatcher_IsMatch_WithInvalidValue_And_ThrowExceptionIsTrue_Should_ReturnMismatch()
+    {
+        // Assign
+        var matcher = new JsonMatcher("", false, true);
+
+        // Act
+        Action action = () => matcher.IsMatch(new MemoryStream());
+
+        // Assert 
+        action.Should().Throw<JsonException>();
+    }
+
+    [Fact]
+    public void JsonMatcher_IsMatch_ByteArray()
+    {
+        // Assign
+        var bytes = new byte[0];
+        var matcher = new JsonMatcher("");
+
+        // Act 
+        double match = matcher.IsMatch(bytes);
+
+        // Assert 
+        Check.That(match).IsEqualTo(0);
+    }
+
+    [Fact]
+    public void JsonMatcher_IsMatch_NullString()
+    {
+        // Assign
+        string? s = null;
+        var matcher = new JsonMatcher("");
+
+        // Act 
+        double match = matcher.IsMatch(s);
+
+        // Assert 
+        Check.That(match).IsEqualTo(0);
+    }
+
+    [Fact]
+    public void JsonMatcher_IsMatch_NullObject()
+    {
+        // Assign
+        object? o = null;
+        var matcher = new JsonMatcher("");
+
+        // Act 
+        double match = matcher.IsMatch(o);
+
+        // Assert 
+        Check.That(match).IsEqualTo(0);
+    }
+
+    [Fact]
+    public void JsonMatcher_IsMatch_JArray()
+    {
+        // Assign 
+        var matcher = new JsonMatcher(new[] { "x", "y" });
+
+        // Act 
+        var jArray = new JArray
         {
-            // Assign
-            var matcher = new JsonMatcher("{}");
+            "x",
+            "y"
+        };
+        double match = matcher.IsMatch(jArray);
 
-            // Act
-            string name = matcher.Name;
+        // Assert 
+        Assert.Equal(1.0, match);
+    }
 
-            // Assert
-            Check.That(name).Equals("JsonMatcher");
-        }
+    [Fact]
+    public void JsonMatcher_IsMatch_JObject()
+    {
+        // Assign 
+        var matcher = new JsonMatcher(new { Id = 1, Name = "Test" });
 
-        [Fact]
-        public void JsonMatcher_GetValue()
+        // Act 
+        var jObject = new JObject
         {
-            // Assign
-            var matcher = new JsonMatcher("{}");
+            { "Id", new JValue(1) },
+            { "Name", new JValue("Test") }
+        };
+        double match = matcher.IsMatch(jObject);
 
-            // Act
-            object value = matcher.Value;
+        // Assert 
+        Assert.Equal(1.0, match);
+    }
 
-            // Assert
-            Check.That(value).Equals("{}");
-        }
+    [Fact]
+    public void JsonMatcher_IsMatch_WithIgnoreCaseTrue_JObject()
+    {
+        // Assign 
+        var matcher = new JsonMatcher(new { id = 1, Name = "test" }, true);
 
-        [Fact]
-        public void JsonMatcher_WithInvalidStringValue_Should_ThrowException()
+        // Act 
+        var jObject = new JObject
         {
-            // Act
-            Action action = () => new JsonMatcher(MatchBehaviour.AcceptOnMatch, "{ \"Id\"");
+            { "Id", new JValue(1) },
+            { "NaMe", new JValue("Test") }
+        };
+        double match = matcher.IsMatch(jObject);
 
-            // Assert
-            action.Should().Throw<JsonException>();
-        }
+        // Assert 
+        Assert.Equal(1.0, match);
+    }
 
-        [Fact]
-        public void JsonMatcher_WithInvalidObjectValue_Should_ThrowException()
+    [Fact]
+    public void JsonMatcher_IsMatch_JObjectParsed()
+    {
+        // Assign 
+        var matcher = new JsonMatcher(new { Id = 1, Name = "Test" });
+
+        // Act 
+        var jObject = JObject.Parse("{ \"Id\" : 1, \"Name\" : \"Test\" }");
+        double match = matcher.IsMatch(jObject);
+
+        // Assert 
+        Assert.Equal(1.0, match);
+    }
+
+    [Fact]
+    public void JsonMatcher_IsMatch_WithIgnoreCaseTrue_JObjectParsed()
+    {
+        // Assign 
+        var matcher = new JsonMatcher(new { Id = 1, Name = "TESt" }, true);
+
+        // Act 
+        var jObject = JObject.Parse("{ \"Id\" : 1, \"Name\" : \"Test\" }");
+        double match = matcher.IsMatch(jObject);
+
+        // Assert 
+        Assert.Equal(1.0, match);
+    }
+
+    [Fact]
+    public void JsonMatcher_IsMatch_JArrayAsString()
+    {
+        // Assign 
+        var matcher = new JsonMatcher("[ \"x\", \"y\" ]");
+
+        // Act 
+        var jArray = new JArray
         {
-            // Act
-            Action action = () => new JsonMatcher(MatchBehaviour.AcceptOnMatch, new MemoryStream());
+            "x",
+            "y"
+        };
+        double match = matcher.IsMatch(jArray);
 
-            // Assert
-            action.Should().Throw<JsonException>();
-        }
+        // Assert 
+        Assert.Equal(1.0, match);
+    }
 
-        [Fact]
-        public void JsonMatcher_IsMatch_WithInvalidValue_And_ThrowExceptionIsFalse_Should_ReturnMismatch()
+    [Fact]
+    public void JsonMatcher_IsMatch_JObjectAsString()
+    {
+        // Assign 
+        var matcher = new JsonMatcher("{ \"Id\" : 1, \"Name\" : \"Test\" }");
+
+        // Act 
+        var jObject = new JObject
         {
-            // Assign
-            var matcher = new JsonMatcher("");
+            { "Id", new JValue(1) },
+            { "Name", new JValue("Test") }
+        };
+        double match = matcher.IsMatch(jObject);
 
-            // Act
-            double match = matcher.IsMatch(new MemoryStream());
+        // Assert 
+        Assert.Equal(1.0, match);
+    }
 
-            // Assert 
-            Check.That(match).IsEqualTo(0);
-        }
+    [Fact]
+    public void JsonMatcher_IsMatch_WithIgnoreCaseTrue_JObjectAsString()
+    {
+        // Assign 
+        var matcher = new JsonMatcher("{ \"Id\" : 1, \"Name\" : \"test\" }", true);
 
-        [Fact]
-        public void JsonMatcher_IsMatch_WithInvalidValue_And_ThrowExceptionIsTrue_Should_ReturnMismatch()
+        // Act 
+        var jObject = new JObject
         {
-            // Assign
-            var matcher = new JsonMatcher("", false, true);
+            { "Id", new JValue(1) },
+            { "Name", new JValue("Test") }
+        };
+        double match = matcher.IsMatch(jObject);
 
-            // Act
-            Action action = () => matcher.IsMatch(new MemoryStream());
+        // Assert 
+        Assert.Equal(1.0, match);
+    }
 
-            // Assert 
-            action.Should().Throw<JsonException>();
-        }
+    [Fact]
+    public void JsonMatcher_IsMatch_JObjectAsString_RejectOnMatch()
+    {
+        // Assign 
+        var matcher = new JsonMatcher(MatchBehaviour.RejectOnMatch, "{ \"Id\" : 1, \"Name\" : \"Test\" }");
 
-        [Fact]
-        public void JsonMatcher_IsMatch_ByteArray()
+        // Act 
+        var jObject = new JObject
         {
-            // Assign
-            var bytes = new byte[0];
-            var matcher = new JsonMatcher("");
+            { "Id", new JValue(1) },
+            { "Name", new JValue("Test") }
+        };
+        double match = matcher.IsMatch(jObject);
 
-            // Act 
-            double match = matcher.IsMatch(bytes);
+        // Assert 
+        Assert.Equal(0.0, match);
+    }
 
-            // Assert 
-            Check.That(match).IsEqualTo(0);
-        }
+    [Fact]
+    public void JsonMatcher_IsMatch_JObjectWithDateTimeOffsetAsString()
+    {
+        // Assign 
+        var matcher = new JsonMatcher("{ \"preferredAt\" : \"2019-11-21T10:32:53.2210009+00:00\" }");
 
-        [Fact]
-        public void JsonMatcher_IsMatch_NullString()
+        // Act 
+        var jObject = new JObject
         {
-            // Assign
-            string s = null;
-            var matcher = new JsonMatcher("");
+            { "preferredAt", new JValue("2019-11-21T10:32:53.2210009+00:00") }
+        };
+        double match = matcher.IsMatch(jObject);
 
-            // Act 
-            double match = matcher.IsMatch(s);
+        // Assert 
+        Assert.Equal(1.0, match);
+    }
 
-            // Assert 
-            Check.That(match).IsEqualTo(0);
-        }
+    [Fact]
+    public void JsonMatcher_IsMatch_NormalEnum()
+    {
+        // Assign 
+        var matcher = new JsonMatcher(new Test1 { NormalEnum = NormalEnum.Abc});
 
-        [Fact]
-        public void JsonMatcher_IsMatch_NullObject()
+        // Act 
+        var jObject = new JObject
         {
-            // Assign
-            object o = null;
-            var matcher = new JsonMatcher("");
+            { "NormalEnum", new JValue(0) }
+        };
+        double match = matcher.IsMatch(jObject);
 
-            // Act 
-            double match = matcher.IsMatch(o);
+        // Assert 
+        match.Should().Be(1.0);
+    }
 
-            // Assert 
-            Check.That(match).IsEqualTo(0);
-        }
+    [Fact]
+    public void JsonMatcher_IsMatch_EnumWithJsonConverter()
+    {
+        // Assign 
+        var matcher = new JsonMatcher(new Test2 { EnumWithJsonConverter = EnumWithJsonConverter.Type1 });
 
-        [Fact]
-        public void JsonMatcher_IsMatch_JArray()
+        // Act 
+        var jObject = new JObject
         {
-            // Assign 
-            var matcher = new JsonMatcher(new[] { "x", "y" });
+            { "EnumWithJsonConverter", new JValue("Type1") }
+        };
+        double match = matcher.IsMatch(jObject);
 
-            // Act 
-            var jArray = new JArray
-            {
-                "x",
-                "y"
-            };
-            double match = matcher.IsMatch(jArray);
-
-            // Assert 
-            Assert.Equal(1.0, match);
-        }
-
-        [Fact]
-        public void JsonMatcher_IsMatch_JObject()
-        {
-            // Assign 
-            var matcher = new JsonMatcher(new { Id = 1, Name = "Test" });
-
-            // Act 
-            var jobject = new JObject
-            {
-                { "Id", new JValue(1) },
-                { "Name", new JValue("Test") }
-            };
-            double match = matcher.IsMatch(jobject);
-
-            // Assert 
-            Assert.Equal(1.0, match);
-        }
-
-        [Fact]
-        public void JsonMatcher_IsMatch_WithIgnoreCaseTrue_JObject()
-        {
-            // Assign 
-            var matcher = new JsonMatcher(new { id = 1, Name = "test" }, true);
-
-            // Act 
-            var jobject = new JObject
-            {
-                { "Id", new JValue(1) },
-                { "NaMe", new JValue("Test") }
-            };
-            double match = matcher.IsMatch(jobject);
-
-            // Assert 
-            Assert.Equal(1.0, match);
-        }
-
-        [Fact]
-        public void JsonMatcher_IsMatch_JObjectParsed()
-        {
-            // Assign 
-            var matcher = new JsonMatcher(new { Id = 1, Name = "Test" });
-
-            // Act 
-            var jobject = JObject.Parse("{ \"Id\" : 1, \"Name\" : \"Test\" }");
-            double match = matcher.IsMatch(jobject);
-
-            // Assert 
-            Assert.Equal(1.0, match);
-        }
-
-        [Fact]
-        public void JsonMatcher_IsMatch_WithIgnoreCaseTrue_JObjectParsed()
-        {
-            // Assign 
-            var matcher = new JsonMatcher(new { Id = 1, Name = "TESt" }, true);
-
-            // Act 
-            var jobject = JObject.Parse("{ \"Id\" : 1, \"Name\" : \"Test\" }");
-            double match = matcher.IsMatch(jobject);
-
-            // Assert 
-            Assert.Equal(1.0, match);
-        }
-
-        [Fact]
-        public void JsonMatcher_IsMatch_JArrayAsString()
-        {
-            // Assign 
-            var matcher = new JsonMatcher("[ \"x\", \"y\" ]");
-
-            // Act 
-            var jArray = new JArray
-            {
-                "x",
-                "y"
-            };
-            double match = matcher.IsMatch(jArray);
-
-            // Assert 
-            Assert.Equal(1.0, match);
-        }
-
-        [Fact]
-        public void JsonMatcher_IsMatch_JObjectAsString()
-        {
-            // Assign 
-            var matcher = new JsonMatcher("{ \"Id\" : 1, \"Name\" : \"Test\" }");
-
-            // Act 
-            var jobject = new JObject
-            {
-                { "Id", new JValue(1) },
-                { "Name", new JValue("Test") }
-            };
-            double match = matcher.IsMatch(jobject);
-
-            // Assert 
-            Assert.Equal(1.0, match);
-        }
-
-        [Fact]
-        public void JsonMatcher_IsMatch_WithIgnoreCaseTrue_JObjectAsString()
-        {
-            // Assign 
-            var matcher = new JsonMatcher("{ \"Id\" : 1, \"Name\" : \"test\" }", true);
-
-            // Act 
-            var jobject = new JObject
-            {
-                { "Id", new JValue(1) },
-                { "Name", new JValue("Test") }
-            };
-            double match = matcher.IsMatch(jobject);
-
-            // Assert 
-            Assert.Equal(1.0, match);
-        }
-
-        [Fact]
-        public void JsonMatcher_IsMatch_JObjectAsString_RejectOnMatch()
-        {
-            // Assign 
-            var matcher = new JsonMatcher(MatchBehaviour.RejectOnMatch, "{ \"Id\" : 1, \"Name\" : \"Test\" }");
-
-            // Act 
-            var jobject = new JObject
-            {
-                { "Id", new JValue(1) },
-                { "Name", new JValue("Test") }
-            };
-            double match = matcher.IsMatch(jobject);
-
-            // Assert 
-            Assert.Equal(0.0, match);
-        }
-
-        [Fact]
-        public void JsonMatcher_IsMatch_JObjectWithDateTimeOffsetAsString()
-        {
-            // Assign 
-            var matcher = new JsonMatcher("{ \"preferredAt\" : \"2019-11-21T10:32:53.2210009+00:00\" }");
-
-            // Act 
-            var jobject = new JObject
-            {
-                { "preferredAt", new JValue("2019-11-21T10:32:53.2210009+00:00") }
-            };
-            double match = matcher.IsMatch(jobject);
-
-            // Assert 
-            Assert.Equal(1.0, match);
-        }
+        // Assert 
+        match.Should().Be(1.0);
     }
 }

test/WireMock.Net.Tests/Matchers/JsonPartialMatcherTests.cs

@@ -1,5 +1,4 @@
-using System;
-using System.Collections.Generic;
+using System;
 using System.IO;
 using FluentAssertions;
 using Newtonsoft.Json;
@@ -42,6 +41,7 @@ namespace WireMock.Net.Tests.Matchers
         public void JsonPartialMatcher_WithInvalidStringValue_Should_ThrowException()
         {
             // Act
+            // ReSharper disable once ObjectCreationAsStatement
             Action action = () => new JsonPartialMatcher(MatchBehaviour.AcceptOnMatch, "{ \"Id\"");
 
             // Assert
@@ -52,6 +52,7 @@ namespace WireMock.Net.Tests.Matchers
         public void JsonPartialMatcher_WithInvalidObjectValue_Should_ThrowException()
         {
             // Act
+            // ReSharper disable once ObjectCreationAsStatement
             Action action = () => new JsonPartialMatcher(MatchBehaviour.AcceptOnMatch, new MemoryStream());
 
             // Assert
@@ -102,7 +103,7 @@ namespace WireMock.Net.Tests.Matchers
         public void JsonPartialMatcher_IsMatch_NullString()
         {
             // Assign
-            string s = null;
+            string? s = null;
             var matcher = new JsonPartialMatcher("");
 
             // Act 
@@ -116,7 +117,7 @@ namespace WireMock.Net.Tests.Matchers
         public void JsonPartialMatcher_IsMatch_NullObject()
         {
             // Assign
-            object o = null;
+            object? o = null;
             var matcher = new JsonPartialMatcher("");
 
             // Act 
@@ -151,17 +152,53 @@ namespace WireMock.Net.Tests.Matchers
             var matcher = new JsonPartialMatcher(new { Id = 1, Name = "Test" });
 
             // Act 
-            var jobject = new JObject
+            var jObject = new JObject
             {
                 { "Id", new JValue(1) },
                 { "Name", new JValue("Test") }
             };
-            double match = matcher.IsMatch(jobject);
+            double match = matcher.IsMatch(jObject);
 
             // Assert 
             Assert.Equal(1.0, match);
         }
 
+        [Fact]
+        public void JsonPartialMatcher_IsMatch_WithRegexTrue()
+        {
+            // Assign 
+            var matcher = new JsonPartialMatcher(new { Id = "^\\d+$", Name = "Test" }, false, false, true);
+
+            // Act 
+            var jObject = new JObject
+            {
+                { "Id", new JValue(1) },
+                { "Name", new JValue("Test") }
+            };
+            double match = matcher.IsMatch(jObject);
+
+            // Assert 
+            Assert.Equal(1.0, match);
+        }
+
+        [Fact]
+        public void JsonPartialMatcher_IsMatch_WithRegexFalse()
+        {
+            // Assign 
+            var matcher = new JsonPartialMatcher(new { Id = "^\\d+$", Name = "Test" });
+
+            // Act 
+            var jObject = new JObject
+            {
+                { "Id", new JValue(1) },
+                { "Name", new JValue("Test") }
+            };
+            double match = matcher.IsMatch(jObject);
+
+            // Assert 
+            Assert.Equal(0.0, match);
+        }
+
         [Fact]
         public void JsonPartialMatcher_IsMatch_WithIgnoreCaseTrue_JObject()
         {
@@ -169,12 +206,12 @@ namespace WireMock.Net.Tests.Matchers
             var matcher = new JsonPartialMatcher(new { id = 1, Name = "test" }, true);
 
             // Act 
-            var jobject = new JObject
+            var jObject = new JObject
             {
                 { "Id", new JValue(1) },
                 { "NaMe", new JValue("Test") }
             };
-            double match = matcher.IsMatch(jobject);
+            double match = matcher.IsMatch(jObject);
 
             // Assert 
             Assert.Equal(1.0, match);
@@ -187,8 +224,8 @@ namespace WireMock.Net.Tests.Matchers
             var matcher = new JsonPartialMatcher(new { Id = 1, Name = "Test" });
 
             // Act 
-            var jobject = JObject.Parse("{ \"Id\" : 1, \"Name\" : \"Test\" }");
-            double match = matcher.IsMatch(jobject);
+            var jObject = JObject.Parse("{ \"Id\" : 1, \"Name\" : \"Test\" }");
+            double match = matcher.IsMatch(jObject);
 
             // Assert 
             Assert.Equal(1.0, match);
@@ -201,8 +238,8 @@ namespace WireMock.Net.Tests.Matchers
             var matcher = new JsonPartialMatcher(new { Id = 1, Name = "TESt" }, true);
 
             // Act 
-            var jobject = JObject.Parse("{ \"Id\" : 1, \"Name\" : \"Test\" }");
-            double match = matcher.IsMatch(jobject);
+            var jObject = JObject.Parse("{ \"Id\" : 1, \"Name\" : \"Test\" }");
+            double match = matcher.IsMatch(jObject);
 
             // Assert 
             Assert.Equal(1.0, match);
@@ -233,12 +270,12 @@ namespace WireMock.Net.Tests.Matchers
             var matcher = new JsonPartialMatcher("{ \"Id\" : 1, \"Name\" : \"Test\" }");
 
             // Act 
-            var jobject = new JObject
+            var jObject = new JObject
             {
                 { "Id", new JValue(1) },
                 { "Name", new JValue("Test") }
             };
-            double match = matcher.IsMatch(jobject);
+            double match = matcher.IsMatch(jObject);
 
             // Assert 
             Assert.Equal(1.0, match);
@@ -251,12 +288,12 @@ namespace WireMock.Net.Tests.Matchers
             var matcher = new JsonPartialMatcher("{ \"Id\" : 1, \"Name\" : \"test\" }", true);
 
             // Act 
-            var jobject = new JObject
+            var jObject = new JObject
             {
                 { "Id", new JValue(1) },
                 { "Name", new JValue("Test") }
             };
-            double match = matcher.IsMatch(jobject);
+            double match = matcher.IsMatch(jObject);
 
             // Assert 
             Assert.Equal(1.0, match);
@@ -269,12 +306,12 @@ namespace WireMock.Net.Tests.Matchers
             var matcher = new JsonPartialMatcher(MatchBehaviour.RejectOnMatch, "{ \"Id\" : 1, \"Name\" : \"Test\" }");
 
             // Act 
-            var jobject = new JObject
+            var jObject = new JObject
             {
                 { "Id", new JValue(1) },
                 { "Name", new JValue("Test") }
             };
-            double match = matcher.IsMatch(jobject);
+            double match = matcher.IsMatch(jObject);
 
             // Assert 
             Assert.Equal(0.0, match);
@@ -287,11 +324,11 @@ namespace WireMock.Net.Tests.Matchers
             var matcher = new JsonPartialMatcher("{ \"preferredAt\" : \"2019-11-21T10:32:53.2210009+00:00\" }");
 
             // Act 
-            var jobject = new JObject
+            var jObject = new JObject
             {
                 { "preferredAt", new JValue("2019-11-21T10:32:53.2210009+00:00") }
             };
-            double match = matcher.IsMatch(jobject);
+            double match = matcher.IsMatch(jObject);
 
             // Assert 
             Assert.Equal(1.0, match);

test/WireMock.Net.Tests/Matchers/JsonPartialWildcardMatcherTests.cs

@@ -1,5 +1,4 @@
 using System;
-using System.Collections.Generic;
 using System.IO;
 using FluentAssertions;
 using Newtonsoft.Json;
@@ -8,393 +7,394 @@ using NFluent;
 using WireMock.Matchers;
 using Xunit;
 
-namespace WireMock.Net.Tests.Matchers
+namespace WireMock.Net.Tests.Matchers;
+
+public class JsonPartialWildcardMatcherTests
 {
-    public class JsonPartialWildcardMatcherTests
+    [Fact]
+    public void JsonPartialWildcardMatcher_GetName()
     {
-        [Fact]
-        public void JsonPartialWildcardMatcher_GetName()
-        {
-            // Assign
-            var matcher = new JsonPartialWildcardMatcher("{}");
+        // Assign
+        var matcher = new JsonPartialWildcardMatcher("{}");
 
-            // Act
-            string name = matcher.Name;
+        // Act
+        string name = matcher.Name;
 
-            // Assert
-            Check.That(name).Equals("JsonPartialWildcardMatcher");
-        }
-
-        [Fact]
-        public void JsonPartialWildcardMatcher_GetValue()
-        {
-            // Assign
-            var matcher = new JsonPartialWildcardMatcher("{}");
-
-            // Act
-            object value = matcher.Value;
-
-            // Assert
-            Check.That(value).Equals("{}");
-        }
-
-        [Fact]
-        public void JsonPartialWildcardMatcher_WithInvalidStringValue_Should_ThrowException()
-        {
-            // Act
-            Action action = () => new JsonPartialWildcardMatcher(MatchBehaviour.AcceptOnMatch, "{ \"Id\"");
-
-            // Assert
-            action.Should().Throw<JsonException>();
-        }
-
-        [Fact]
-        public void JsonPartialWildcardMatcher_WithInvalidObjectValue_Should_ThrowException()
-        {
-            // Act
-            Action action = () => new JsonPartialWildcardMatcher(MatchBehaviour.AcceptOnMatch, new MemoryStream());
-
-            // Assert
-            action.Should().Throw<JsonException>();
-        }
-
-        [Fact]
-        public void JsonPartialWildcardMatcher_IsMatch_WithInvalidValue_And_ThrowExceptionIsFalse_Should_ReturnMismatch()
-        {
-            // Assign
-            var matcher = new JsonPartialWildcardMatcher("");
-
-            // Act
-            double match = matcher.IsMatch(new MemoryStream());
-
-            // Assert 
-            Check.That(match).IsEqualTo(0);
-        }
-
-        [Fact]
-        public void JsonPartialWildcardMatcher_IsMatch_WithInvalidValue_And_ThrowExceptionIsTrue_Should_ReturnMismatch()
-        {
-            // Assign
-            var matcher = new JsonPartialWildcardMatcher("", false, true);
-
-            // Act
-            Action action = () => matcher.IsMatch(new MemoryStream());
-
-            // Assert 
-            action.Should().Throw<JsonException>();
-        }
-
-        [Fact]
-        public void JsonPartialWildcardMatcher_IsMatch_ByteArray()
-        {
-            // Assign
-            var bytes = new byte[0];
-            var matcher = new JsonPartialWildcardMatcher("");
-
-            // Act 
-            double match = matcher.IsMatch(bytes);
-
-            // Assert 
-            Check.That(match).IsEqualTo(0);
-        }
-
-        [Fact]
-        public void JsonPartialWildcardMatcher_IsMatch_NullString()
-        {
-            // Assign
-            string s = null;
-            var matcher = new JsonPartialWildcardMatcher("");
-
-            // Act 
-            double match = matcher.IsMatch(s);
-
-            // Assert 
-            Check.That(match).IsEqualTo(0);
-        }
-
-        [Fact]
-        public void JsonPartialWildcardMatcher_IsMatch_NullObject()
-        {
-            // Assign
-            object o = null;
-            var matcher = new JsonPartialWildcardMatcher("");
-
-            // Act 
-            double match = matcher.IsMatch(o);
-
-            // Assert 
-            Check.That(match).IsEqualTo(0);
-        }
-
-        [Fact]
-        public void JsonPartialWildcardMatcher_IsMatch_JArray()
-        {
-            // Assign 
-            var matcher = new JsonPartialWildcardMatcher(new[] { "x", "y" });
-
-            // Act 
-            var jArray = new JArray
-            {
-                "x",
-                "y"
-            };
-            double match = matcher.IsMatch(jArray);
-
-            // Assert 
-            Assert.Equal(1.0, match);
-        }
-
-        [Fact]
-        public void JsonPartialWildcardMatcher_IsMatch_JObject()
-        {
-            // Assign 
-            var matcher = new JsonPartialWildcardMatcher(new { Id = 1, Name = "Test" });
-
-            // Act 
-            var jobject = new JObject
-            {
-                { "Id", new JValue(1) },
-                { "Name", new JValue("Test") }
-            };
-            double match = matcher.IsMatch(jobject);
-
-            // Assert 
-            Assert.Equal(1.0, match);
-        }
-
-        [Fact]
-        public void JsonPartialWildcardMatcher_IsMatch_WithIgnoreCaseTrue_JObject()
-        {
-            // Assign 
-            var matcher = new JsonPartialWildcardMatcher(new { id = 1, Name = "test" }, true);
-
-            // Act 
-            var jobject = new JObject
-            {
-                { "Id", new JValue(1) },
-                { "NaMe", new JValue("Test") }
-            };
-            double match = matcher.IsMatch(jobject);
-
-            // Assert 
-            Assert.Equal(1.0, match);
-        }
-
-        [Fact]
-        public void JsonPartialWildcardMatcher_IsMatch_JObjectParsed()
-        {
-            // Assign 
-            var matcher = new JsonPartialWildcardMatcher(new { Id = 1, Name = "Test" });
-
-            // Act 
-            var jobject = JObject.Parse("{ \"Id\" : 1, \"Name\" : \"Test\" }");
-            double match = matcher.IsMatch(jobject);
-
-            // Assert 
-            Assert.Equal(1.0, match);
-        }
-
-        [Fact]
-        public void JsonPartialWildcardMatcher_IsMatch_WithIgnoreCaseTrue_JObjectParsed()
-        {
-            // Assign 
-            var matcher = new JsonPartialWildcardMatcher(new { Id = 1, Name = "TESt" }, true);
-
-            // Act 
-            var jobject = JObject.Parse("{ \"Id\" : 1, \"Name\" : \"Test\" }");
-            double match = matcher.IsMatch(jobject);
-
-            // Assert 
-            Assert.Equal(1.0, match);
-        }
-
-        [Fact]
-        public void JsonPartialWildcardMatcher_IsMatch_JArrayAsString()
-        {
-            // Assign 
-            var matcher = new JsonPartialWildcardMatcher("[ \"x\", \"y\" ]");
-
-            // Act 
-            var jArray = new JArray
-            {
-                "x",
-                "y"
-            };
-            double match = matcher.IsMatch(jArray);
-
-            // Assert 
-            Assert.Equal(1.0, match);
-        }
-
-        [Fact]
-        public void JsonPartialWildcardMatcher_IsMatch_JObjectAsString()
-        {
-            // Assign 
-            var matcher = new JsonPartialWildcardMatcher("{ \"Id\" : 1, \"Name\" : \"Test\" }");
-
-            // Act 
-            var jobject = new JObject
-            {
-                { "Id", new JValue(1) },
-                { "Name", new JValue("Test") }
-            };
-            double match = matcher.IsMatch(jobject);
-
-            // Assert 
-            Assert.Equal(1.0, match);
-        }
-
-        [Fact]
-        public void JsonPartialWildcardMatcher_IsMatch_WithIgnoreCaseTrue_JObjectAsString()
-        {
-            // Assign 
-            var matcher = new JsonPartialWildcardMatcher("{ \"Id\" : 1, \"Name\" : \"test\" }", true);
-
-            // Act 
-            var jobject = new JObject
-            {
-                { "Id", new JValue(1) },
-                { "Name", new JValue("Test") }
-            };
-            double match = matcher.IsMatch(jobject);
-
-            // Assert 
-            Assert.Equal(1.0, match);
-        }
-
-        [Fact]
-        public void JsonPartialWildcardMatcher_IsMatch_JObjectAsString_RejectOnMatch()
-        {
-            // Assign 
-            var matcher = new JsonPartialWildcardMatcher(MatchBehaviour.RejectOnMatch, "{ \"Id\" : 1, \"Name\" : \"Test\" }");
-
-            // Act 
-            var jobject = new JObject
-            {
-                { "Id", new JValue(1) },
-                { "Name", new JValue("Test") }
-            };
-            double match = matcher.IsMatch(jobject);
-
-            // Assert 
-            Assert.Equal(0.0, match);
-        }
-
-        [Fact]
-        public void JsonPartialWildcardMatcher_IsMatch_JObjectWithDateTimeOffsetAsString()
-        {
-            // Assign 
-            var matcher = new JsonPartialWildcardMatcher("{ \"preferredAt\" : \"2019-11-21T10:32:53.2210009+00:00\" }");
-
-            // Act 
-            var jobject = new JObject
-            {
-                { "preferredAt", new JValue("2019-11-21T10:32:53.2210009+00:00") }
-            };
-            double match = matcher.IsMatch(jobject);
-
-            // Assert 
-            Assert.Equal(1.0, match);
-        }
-
-        [Theory]
-        [InlineData("{\"test\":\"abc\"}", "{\"test\":\"abc\",\"other\":\"xyz\"}")]
-        [InlineData("\"test\"", "\"test\"")]
-        [InlineData("123", "123")]
-        [InlineData("[\"test\"]", "[\"test\"]")]
-        [InlineData("[\"test\"]", "[\"test\", \"other\"]")]
-        [InlineData("[123]", "[123]")]
-        [InlineData("[123]", "[123, 456]")]
-        [InlineData("{ \"test\":\"value\" }", "{\"test\":\"value\",\"other\":123}")]
-        [InlineData("{ \"test\":\"value\" }", "{\"test\":\"value\"}")]
-        [InlineData("{\"test\":{\"nested\":\"value\"}}", "{\"test\":{\"nested\":\"value\"}}")]
-        public void JsonPartialWildcardMatcher_IsMatch_StringInput_IsValidMatch(string value, string input)
-        {
-            // Assign
-            var matcher = new JsonPartialWildcardMatcher(value);
-
-            // Act
-            double match = matcher.IsMatch(input);
-
-            // Assert
-            Assert.Equal(1.0, match);
-        }
-
-        [Theory]
-        [InlineData("{\"test\":\"*\"}", "{\"test\":\"xxx\",\"other\":\"xyz\"}")]
-        [InlineData("\"t*t\"", "\"test\"")]
-        public void JsonPartialWildcardMatcher_IsMatch_StringInputWithWildcard_IsValidMatch(string value, string input)
-        {
-            // Assign
-            var matcher = new JsonPartialWildcardMatcher(value);
-
-            // Act
-            double match = matcher.IsMatch(input);
-
-            // Assert
-            match.Should().Be(1.0);
-        }
-
-        [Theory]
-        [InlineData("\"test\"", null)]
-        [InlineData("\"test1\"", "\"test2\"")]
-        [InlineData("123", "1234")]
-        [InlineData("[\"test\"]", "[\"test1\"]")]
-        [InlineData("[\"test\"]", "[\"test1\", \"test2\"]")]
-        [InlineData("[123]", "[1234]")]
-        [InlineData("{}", "\"test\"")]
-        [InlineData("{ \"test\":\"value\" }", "{\"test\":\"value2\"}")]
-        [InlineData("{ \"test.nested\":\"value\" }", "{\"test\":{\"nested\":\"value1\"}}")]
-        [InlineData("{\"test\":{\"test1\":\"value\"}}", "{\"test\":{\"test1\":\"value1\"}}")]
-        [InlineData("[{ \"test.nested\":\"value\" }]", "[{\"test\":{\"nested\":\"value1\"}}]")]
-        public void JsonPartialWildcardMatcher_IsMatch_StringInputWithInvalidMatch(string value, string input)
-        {
-            // Assign
-            var matcher = new JsonPartialWildcardMatcher(value);
-
-            // Act
-            double match = matcher.IsMatch(input);
-
-            // Assert
-            Assert.Equal(0.0, match);
-        }
-
-        [Theory]
-        [InlineData("{ \"test.nested\":123 }", "{\"test\":{\"nested\":123}}")]
-        [InlineData("{ \"test.nested\":[123, 456] }", "{\"test\":{\"nested\":[123, 456]}}")]
-        [InlineData("{ \"test.nested\":\"value\" }", "{\"test\":{\"nested\":\"value\"}}")]
-        [InlineData("{ \"['name.with.dot']\":\"value\" }", "{\"name.with.dot\":\"value\"}")]
-        [InlineData("[{ \"test.nested\":\"value\" }]", "[{\"test\":{\"nested\":\"value\"}}]")]
-        [InlineData("[{ \"['name.with.dot']\":\"value\" }]", "[{\"name.with.dot\":\"value\"}]")]
-        public void JsonPartialWildcardMatcher_IsMatch_ValueAsJPathValidMatch(string value, string input)
-        {
-            // Assign
-            var matcher = new JsonPartialWildcardMatcher(value);
-
-            // Act
-            double match = matcher.IsMatch(input);
-
-            // Assert
-            Assert.Equal(1.0, match);
-        }
-
-        [Theory]
-        [InlineData("{ \"test.nested\":123 }", "{\"test\":{\"nested\":456}}")]
-        [InlineData("{ \"test.nested\":[123, 456] }", "{\"test\":{\"nested\":[1, 2]}}")]
-        [InlineData("{ \"test.nested\":\"value\" }", "{\"test\":{\"nested\":\"value1\"}}")]
-        [InlineData("{ \"['name.with.dot']\":\"value\" }", "{\"name.with.dot\":\"value1\"}")]
-        [InlineData("[{ \"test.nested\":\"value\" }]", "[{\"test\":{\"nested\":\"value1\"}}]")]
-        [InlineData("[{ \"['name.with.dot']\":\"value\" }]", "[{\"name.with.dot\":\"value1\"}]")]
-        public void JsonPartialWildcardMatcher_IsMatch_ValueAsJPathInvalidMatch(string value, string input)
-        {
-            // Assign
-            var matcher = new JsonPartialWildcardMatcher(value);
-
-            // Act
-            double match = matcher.IsMatch(input);
-
-            // Assert
-            Assert.Equal(0.0, match);
-        }
+        // Assert
+        Check.That(name).Equals("JsonPartialWildcardMatcher");
     }
-}
+
+    [Fact]
+    public void JsonPartialWildcardMatcher_GetValue()
+    {
+        // Assign
+        var matcher = new JsonPartialWildcardMatcher("{}");
+
+        // Act
+        object value = matcher.Value;
+
+        // Assert
+        Check.That(value).Equals("{}");
+    }
+
+    [Fact]
+    public void JsonPartialWildcardMatcher_WithInvalidStringValue_Should_ThrowException()
+    {
+        // Act
+        // ReSharper disable once ObjectCreationAsStatement
+        Action action = () => new JsonPartialWildcardMatcher(MatchBehaviour.AcceptOnMatch, "{ \"Id\"");
+
+        // Assert
+        action.Should().Throw<JsonException>();
+    }
+
+    [Fact]
+    public void JsonPartialWildcardMatcher_WithInvalidObjectValue_Should_ThrowException()
+    {
+        // Act
+        // ReSharper disable once ObjectCreationAsStatement
+        Action action = () => new JsonPartialWildcardMatcher(MatchBehaviour.AcceptOnMatch, new MemoryStream());
+
+        // Assert
+        action.Should().Throw<JsonException>();
+    }
+
+    [Fact]
+    public void JsonPartialWildcardMatcher_IsMatch_WithInvalidValue_And_ThrowExceptionIsFalse_Should_ReturnMismatch()
+    {
+        // Assign
+        var matcher = new JsonPartialWildcardMatcher("");
+
+        // Act
+        double match = matcher.IsMatch(new MemoryStream());
+
+        // Assert 
+        Check.That(match).IsEqualTo(0);
+    }
+
+    [Fact]
+    public void JsonPartialWildcardMatcher_IsMatch_WithInvalidValue_And_ThrowExceptionIsTrue_Should_ReturnMismatch()
+    {
+        // Assign
+        var matcher = new JsonPartialWildcardMatcher("", false, true);
+
+        // Act
+        Action action = () => matcher.IsMatch(new MemoryStream());
+
+        // Assert 
+        action.Should().Throw<JsonException>();
+    }
+
+    [Fact]
+    public void JsonPartialWildcardMatcher_IsMatch_ByteArray()
+    {
+        // Assign
+        var bytes = new byte[0];
+        var matcher = new JsonPartialWildcardMatcher("");
+
+        // Act 
+        double match = matcher.IsMatch(bytes);
+
+        // Assert 
+        Check.That(match).IsEqualTo(0);
+    }
+
+    [Fact]
+    public void JsonPartialWildcardMatcher_IsMatch_NullString()
+    {
+        // Assign
+        string? s = null;
+        var matcher = new JsonPartialWildcardMatcher("");
+
+        // Act 
+        double match = matcher.IsMatch(s);
+
+        // Assert 
+        Check.That(match).IsEqualTo(0);
+    }
+
+    [Fact]
+    public void JsonPartialWildcardMatcher_IsMatch_NullObject()
+    {
+        // Assign
+        object? o = null;
+        var matcher = new JsonPartialWildcardMatcher("");
+
+        // Act 
+        double match = matcher.IsMatch(o);
+
+        // Assert 
+        Check.That(match).IsEqualTo(0);
+    }
+
+    [Fact]
+    public void JsonPartialWildcardMatcher_IsMatch_JArray()
+    {
+        // Assign 
+        var matcher = new JsonPartialWildcardMatcher(new[] { "x", "y" });
+
+        // Act 
+        var jArray = new JArray
+        {
+            "x",
+            "y"
+        };
+        double match = matcher.IsMatch(jArray);
+
+        // Assert 
+        Assert.Equal(1.0, match);
+    }
+
+    [Fact]
+    public void JsonPartialWildcardMatcher_IsMatch_JObject()
+    {
+        // Assign 
+        var matcher = new JsonPartialWildcardMatcher(new { Id = 1, Name = "Test" });
+
+        // Act 
+        var jObject = new JObject
+        {
+            { "Id", new JValue(1) },
+            { "Name", new JValue("Test") }
+        };
+        double match = matcher.IsMatch(jObject);
+
+        // Assert 
+        Assert.Equal(1.0, match);
+    }
+
+    [Fact]
+    public void JsonPartialWildcardMatcher_IsMatch_WithIgnoreCaseTrue_JObject()
+    {
+        // Assign 
+        var matcher = new JsonPartialWildcardMatcher(new { id = 1, Name = "test" }, true);
+
+        // Act 
+        var jObject = new JObject
+        {
+            { "Id", new JValue(1) },
+            { "NaMe", new JValue("Test") }
+        };
+        double match = matcher.IsMatch(jObject);
+
+        // Assert 
+        Assert.Equal(1.0, match);
+    }
+
+    [Fact]
+    public void JsonPartialWildcardMatcher_IsMatch_JObjectParsed()
+    {
+        // Assign 
+        var matcher = new JsonPartialWildcardMatcher(new { Id = 1, Name = "Test" });
+
+        // Act 
+        var jObject = JObject.Parse("{ \"Id\" : 1, \"Name\" : \"Test\" }");
+        double match = matcher.IsMatch(jObject);
+
+        // Assert 
+        Assert.Equal(1.0, match);
+    }
+
+    [Fact]
+    public void JsonPartialWildcardMatcher_IsMatch_WithIgnoreCaseTrue_JObjectParsed()
+    {
+        // Assign 
+        var matcher = new JsonPartialWildcardMatcher(new { Id = 1, Name = "TESt" }, true);
+
+        // Act 
+        var jObject = JObject.Parse("{ \"Id\" : 1, \"Name\" : \"Test\" }");
+        double match = matcher.IsMatch(jObject);
+
+        // Assert 
+        Assert.Equal(1.0, match);
+    }
+
+    [Fact]
+    public void JsonPartialWildcardMatcher_IsMatch_JArrayAsString()
+    {
+        // Assign 
+        var matcher = new JsonPartialWildcardMatcher("[ \"x\", \"y\" ]");
+
+        // Act 
+        var jArray = new JArray
+        {
+            "x",
+            "y"
+        };
+        double match = matcher.IsMatch(jArray);
+
+        // Assert 
+        Assert.Equal(1.0, match);
+    }
+
+    [Fact]
+    public void JsonPartialWildcardMatcher_IsMatch_JObjectAsString()
+    {
+        // Assign 
+        var matcher = new JsonPartialWildcardMatcher("{ \"Id\" : 1, \"Name\" : \"Test\" }");
+
+        // Act 
+        var jObject = new JObject
+        {
+            { "Id", new JValue(1) },
+            { "Name", new JValue("Test") }
+        };
+        double match = matcher.IsMatch(jObject);
+
+        // Assert 
+        Assert.Equal(1.0, match);
+    }
+
+    [Fact]
+    public void JsonPartialWildcardMatcher_IsMatch_WithIgnoreCaseTrue_JObjectAsString()
+    {
+        // Assign 
+        var matcher = new JsonPartialWildcardMatcher("{ \"Id\" : 1, \"Name\" : \"test\" }", true);
+
+        // Act 
+        var jObject = new JObject
+        {
+            { "Id", new JValue(1) },
+            { "Name", new JValue("Test") }
+        };
+        double match = matcher.IsMatch(jObject);
+
+        // Assert 
+        Assert.Equal(1.0, match);
+    }
+
+    [Fact]
+    public void JsonPartialWildcardMatcher_IsMatch_JObjectAsString_RejectOnMatch()
+    {
+        // Assign 
+        var matcher = new JsonPartialWildcardMatcher(MatchBehaviour.RejectOnMatch, "{ \"Id\" : 1, \"Name\" : \"Test\" }");
+
+        // Act 
+        var jObject = new JObject
+        {
+            { "Id", new JValue(1) },
+            { "Name", new JValue("Test") }
+        };
+        double match = matcher.IsMatch(jObject);
+
+        // Assert 
+        Assert.Equal(0.0, match);
+    }
+
+    [Fact]
+    public void JsonPartialWildcardMatcher_IsMatch_JObjectWithDateTimeOffsetAsString()
+    {
+        // Assign 
+        var matcher = new JsonPartialWildcardMatcher("{ \"preferredAt\" : \"2019-11-21T10:32:53.2210009+00:00\" }");
+
+        // Act 
+        var jObject = new JObject
+        {
+            { "preferredAt", new JValue("2019-11-21T10:32:53.2210009+00:00") }
+        };
+        double match = matcher.IsMatch(jObject);
+
+        // Assert 
+        Assert.Equal(1.0, match);
+    }
+
+    [Theory]
+    [InlineData("{\"test\":\"abc\"}", "{\"test\":\"abc\",\"other\":\"xyz\"}")]
+    [InlineData("\"test\"", "\"test\"")]
+    [InlineData("123", "123")]
+    [InlineData("[\"test\"]", "[\"test\"]")]
+    [InlineData("[\"test\"]", "[\"test\", \"other\"]")]
+    [InlineData("[123]", "[123]")]
+    [InlineData("[123]", "[123, 456]")]
+    [InlineData("{ \"test\":\"value\" }", "{\"test\":\"value\",\"other\":123}")]
+    [InlineData("{ \"test\":\"value\" }", "{\"test\":\"value\"}")]
+    [InlineData("{\"test\":{\"nested\":\"value\"}}", "{\"test\":{\"nested\":\"value\"}}")]
+    public void JsonPartialWildcardMatcher_IsMatch_StringInput_IsValidMatch(string value, string input)
+    {
+        // Assign
+        var matcher = new JsonPartialWildcardMatcher(value);
+
+        // Act
+        double match = matcher.IsMatch(input);
+
+        // Assert
+        Assert.Equal(1.0, match);
+    }
+
+    [Theory]
+    [InlineData("{\"test\":\"*\"}", "{\"test\":\"xxx\",\"other\":\"xyz\"}")]
+    [InlineData("\"t*t\"", "\"test\"")]
+    public void JsonPartialWildcardMatcher_IsMatch_StringInputWithWildcard_IsValidMatch(string value, string input)
+    {
+        // Assign
+        var matcher = new JsonPartialWildcardMatcher(value);
+
+        // Act
+        double match = matcher.IsMatch(input);
+
+        // Assert
+        match.Should().Be(1.0);
+    }
+
+    [Theory]
+    [InlineData("\"test\"", null)]
+    [InlineData("\"test1\"", "\"test2\"")]
+    [InlineData("123", "1234")]
+    [InlineData("[\"test\"]", "[\"test1\"]")]
+    [InlineData("[\"test\"]", "[\"test1\", \"test2\"]")]
+    [InlineData("[123]", "[1234]")]
+    [InlineData("{}", "\"test\"")]
+    [InlineData("{ \"test\":\"value\" }", "{\"test\":\"value2\"}")]
+    [InlineData("{ \"test.nested\":\"value\" }", "{\"test\":{\"nested\":\"value1\"}}")]
+    [InlineData("{\"test\":{\"test1\":\"value\"}}", "{\"test\":{\"test1\":\"value1\"}}")]
+    [InlineData("[{ \"test.nested\":\"value\" }]", "[{\"test\":{\"nested\":\"value1\"}}]")]
+    public void JsonPartialWildcardMatcher_IsMatch_StringInputWithInvalidMatch(string value, string input)
+    {
+        // Assign
+        var matcher = new JsonPartialWildcardMatcher(value);
+
+        // Act
+        double match = matcher.IsMatch(input);
+
+        // Assert
+        Assert.Equal(0.0, match);
+    }
+
+    [Theory]
+    [InlineData("{ \"test.nested\":123 }", "{\"test\":{\"nested\":123}}")]
+    [InlineData("{ \"test.nested\":[123, 456] }", "{\"test\":{\"nested\":[123, 456]}}")]
+    [InlineData("{ \"test.nested\":\"value\" }", "{\"test\":{\"nested\":\"value\"}}")]
+    [InlineData("{ \"['name.with.dot']\":\"value\" }", "{\"name.with.dot\":\"value\"}")]
+    [InlineData("[{ \"test.nested\":\"value\" }]", "[{\"test\":{\"nested\":\"value\"}}]")]
+    [InlineData("[{ \"['name.with.dot']\":\"value\" }]", "[{\"name.with.dot\":\"value\"}]")]
+    public void JsonPartialWildcardMatcher_IsMatch_ValueAsJPathValidMatch(string value, string input)
+    {
+        // Assign
+        var matcher = new JsonPartialWildcardMatcher(value);
+
+        // Act
+        double match = matcher.IsMatch(input);
+
+        // Assert
+        Assert.Equal(1.0, match);
+    }
+
+    [Theory]
+    [InlineData("{ \"test.nested\":123 }", "{\"test\":{\"nested\":456}}")]
+    [InlineData("{ \"test.nested\":[123, 456] }", "{\"test\":{\"nested\":[1, 2]}}")]
+    [InlineData("{ \"test.nested\":\"value\" }", "{\"test\":{\"nested\":\"value1\"}}")]
+    [InlineData("{ \"['name.with.dot']\":\"value\" }", "{\"name.with.dot\":\"value1\"}")]
+    [InlineData("[{ \"test.nested\":\"value\" }]", "[{\"test\":{\"nested\":\"value1\"}}]")]
+    [InlineData("[{ \"['name.with.dot']\":\"value\" }]", "[{\"name.with.dot\":\"value1\"}]")]
+    public void JsonPartialWildcardMatcher_IsMatch_ValueAsJPathInvalidMatch(string value, string input)
+    {
+        // Assign
+        var matcher = new JsonPartialWildcardMatcher(value);
+
+        // Act
+        double match = matcher.IsMatch(input);
+
+        // Assert
+        Assert.Equal(0.0, match);
+    }
+}

test/WireMock.Net.Tests/RequestMatchers/RequestMessageHeaderMatcherTests.cs

@@ -5,165 +5,164 @@ using WireMock.Matchers.Request;
 using WireMock.Models;
 using Xunit;
 
-namespace WireMock.Net.Tests.RequestMatchers
+namespace WireMock.Net.Tests.RequestMatchers;
+
+public class RequestMessageHeaderMatcherTests
 {
-    public class RequestMessageHeaderMatcherTests
+    [Fact]
+    public void RequestMessageHeaderMatcher_GetMatchingScore_AcceptOnMatch_HeaderDoesNotExists()
     {
-        [Fact]
-        public void RequestMessageHeaderMatcher_GetMatchingScore_AcceptOnMatch_HeaderDoesNotExists()
-        {
-            // Assign
-            var requestMessage = new RequestMessage(new UrlDetails("http://localhost"), "GET", "127.0.0.1");
-            var matcher = new RequestMessageHeaderMatcher(MatchBehaviour.AcceptOnMatch, "h", "x", true);
+        // Assign
+        var requestMessage = new RequestMessage(new UrlDetails("http://localhost"), "GET", "127.0.0.1");
+        var matcher = new RequestMessageHeaderMatcher(MatchBehaviour.AcceptOnMatch, "h", "x", true);
 
-            // Act
-            var result = new RequestMatchResult();
-            double score = matcher.GetMatchingScore(requestMessage, result);
+        // Act
+        var result = new RequestMatchResult();
+        double score = matcher.GetMatchingScore(requestMessage, result);
 
-            // Assert
-            Check.That(score).IsEqualTo(0.0d);
-        }
+        // Assert
+        Check.That(score).IsEqualTo(0.0d);
+    }
 
-        [Fact]
-        public void RequestMessageHeaderMatcher_GetMatchingScore_RejectOnMatch_HeaderDoesNotExists()
-        {
-            // Assign
-            var requestMessage = new RequestMessage(new UrlDetails("http://localhost"), "GET", "127.0.0.1");
-            var matcher = new RequestMessageHeaderMatcher(MatchBehaviour.RejectOnMatch, "h", "x", true);
+    [Fact]
+    public void RequestMessageHeaderMatcher_GetMatchingScore_RejectOnMatch_HeaderDoesNotExists()
+    {
+        // Assign
+        var requestMessage = new RequestMessage(new UrlDetails("http://localhost"), "GET", "127.0.0.1");
+        var matcher = new RequestMessageHeaderMatcher(MatchBehaviour.RejectOnMatch, "h", "x", true);
 
-            // Act
-            var result = new RequestMatchResult();
-            double score = matcher.GetMatchingScore(requestMessage, result);
+        // Act
+        var result = new RequestMatchResult();
+        double score = matcher.GetMatchingScore(requestMessage, result);
 
-            // Assert
-            Check.That(score).IsEqualTo(1.0d);
-        }
+        // Assert
+        Check.That(score).IsEqualTo(1.0d);
+    }
 
-        [Fact]
-        public void RequestMessageHeaderMatcher_GetMatchingScore_AcceptOnMatch_HeaderDoesNotMatchPattern()
-        {
-            // Assign
-            var headers = new Dictionary<string, string[]> { { "h", new[] { "x" } } };
-            var requestMessage = new RequestMessage(new UrlDetails("http://localhost"), "GET", "127.0.0.1", null, headers);
-            var matcher = new RequestMessageHeaderMatcher(MatchBehaviour.AcceptOnMatch, "no-match", "123", true);
+    [Fact]
+    public void RequestMessageHeaderMatcher_GetMatchingScore_AcceptOnMatch_HeaderDoesNotMatchPattern()
+    {
+        // Assign
+        var headers = new Dictionary<string, string[]> { { "h", new[] { "x" } } };
+        var requestMessage = new RequestMessage(new UrlDetails("http://localhost"), "GET", "127.0.0.1", null, headers);
+        var matcher = new RequestMessageHeaderMatcher(MatchBehaviour.AcceptOnMatch, "no-match", "123", true);
 
-            // Act
-            var result = new RequestMatchResult();
-            double score = matcher.GetMatchingScore(requestMessage, result);
+        // Act
+        var result = new RequestMatchResult();
+        double score = matcher.GetMatchingScore(requestMessage, result);
 
-            // Assert
-            Check.That(score).IsEqualTo(0.0d);
-        }
-        [Fact]
-        public void RequestMessageHeaderMatcher_GetMatchingScore_RejectOnMatch_HeaderDoesNotMatchPattern()
-        {
-            // Assign
-            var headers = new Dictionary<string, string[]> { { "h", new[] { "x" } } };
-            var requestMessage = new RequestMessage(new UrlDetails("http://localhost"), "GET", "127.0.0.1", null, headers);
-            var matcher = new RequestMessageHeaderMatcher(MatchBehaviour.RejectOnMatch, "no-match", "123", true);
+        // Assert
+        Check.That(score).IsEqualTo(0.0d);
+    }
+    [Fact]
+    public void RequestMessageHeaderMatcher_GetMatchingScore_RejectOnMatch_HeaderDoesNotMatchPattern()
+    {
+        // Assign
+        var headers = new Dictionary<string, string[]> { { "h", new[] { "x" } } };
+        var requestMessage = new RequestMessage(new UrlDetails("http://localhost"), "GET", "127.0.0.1", null, headers);
+        var matcher = new RequestMessageHeaderMatcher(MatchBehaviour.RejectOnMatch, "no-match", "123", true);
 
-            // Act
-            var result = new RequestMatchResult();
-            double score = matcher.GetMatchingScore(requestMessage, result);
+        // Act
+        var result = new RequestMatchResult();
+        double score = matcher.GetMatchingScore(requestMessage, result);
 
-            // Assert
-            Check.That(score).IsEqualTo(1.0d);
-        }
+        // Assert
+        Check.That(score).IsEqualTo(1.0d);
+    }
 
-        [Fact]
-        public void RequestMessageHeaderMatcher_GetMatchingScore_AcceptOnMatch()
-        {
-            // Assign
-            var headers = new Dictionary<string, string[]> { { "h", new[] { "x" } } };
-            var requestMessage = new RequestMessage(new UrlDetails("http://localhost"), "GET", "127.0.0.1", null, headers);
-            var matcher = new RequestMessageHeaderMatcher(MatchBehaviour.AcceptOnMatch, "h", "x", true);
+    [Fact]
+    public void RequestMessageHeaderMatcher_GetMatchingScore_AcceptOnMatch()
+    {
+        // Assign
+        var headers = new Dictionary<string, string[]> { { "h", new[] { "x" } } };
+        var requestMessage = new RequestMessage(new UrlDetails("http://localhost"), "GET", "127.0.0.1", null, headers);
+        var matcher = new RequestMessageHeaderMatcher(MatchBehaviour.AcceptOnMatch, "h", "x", true);
 
-            // Act
-            var result = new RequestMatchResult();
-            double score = matcher.GetMatchingScore(requestMessage, result);
+        // Act
+        var result = new RequestMatchResult();
+        double score = matcher.GetMatchingScore(requestMessage, result);
 
-            // Assert
-            Check.That(score).IsEqualTo(1.0d);
-        }
+        // Assert
+        Check.That(score).IsEqualTo(1.0d);
+    }
 
-        [Fact(Skip = "does not work anymore since 'and'/'or'/'average'")]
-        public void RequestMessageHeaderMatcher_GetMatchingScore_RejectOnMatch()
-        {
-            // Assign
-            var headers = new Dictionary<string, string[]> { { "h", new[] { "x" } } };
-            var requestMessage = new RequestMessage(new UrlDetails("http://localhost"), "GET", "127.0.0.1", null, headers);
-            var matcher = new RequestMessageHeaderMatcher(MatchBehaviour.RejectOnMatch, "h", "x", true);
+    [Fact(Skip = "does not work anymore since 'and'/'or'/'average'")]
+    public void RequestMessageHeaderMatcher_GetMatchingScore_RejectOnMatch()
+    {
+        // Assign
+        var headers = new Dictionary<string, string[]> { { "h", new[] { "x" } } };
+        var requestMessage = new RequestMessage(new UrlDetails("http://localhost"), "GET", "127.0.0.1", null, headers);
+        var matcher = new RequestMessageHeaderMatcher(MatchBehaviour.RejectOnMatch, "h", "x", true);
 
-            // Act
-            var result = new RequestMatchResult();
-            double score = matcher.GetMatchingScore(requestMessage, result);
+        // Act
+        var result = new RequestMatchResult();
+        double score = matcher.GetMatchingScore(requestMessage, result);
 
-            // Assert
-            Check.That(score).IsEqualTo(0.0d);
-        }
+        // Assert
+        Check.That(score).IsEqualTo(0.0d);
+    }
 
-        [Fact]
-        public void RequestMessageHeaderMatcher_GetMatchingScore_IStringMatcher_Match()
-        {
-            // Assign
-            var headers = new Dictionary<string, string[]> { { "h", new[] { "x" } } };
-            var requestMessage = new RequestMessage(new UrlDetails("http://localhost"), "GET", "127.0.0.1", null, headers);
-            var matcher = new RequestMessageHeaderMatcher(MatchBehaviour.AcceptOnMatch, MatchOperator.Or, "h", false, new ExactMatcher("x"));
+    [Fact]
+    public void RequestMessageHeaderMatcher_GetMatchingScore_IStringMatcher_Match()
+    {
+        // Assign
+        var headers = new Dictionary<string, string[]> { { "h", new[] { "x" } } };
+        var requestMessage = new RequestMessage(new UrlDetails("http://localhost"), "GET", "127.0.0.1", null, headers);
+        var matcher = new RequestMessageHeaderMatcher(MatchBehaviour.AcceptOnMatch, MatchOperator.Or, "h", false, new ExactMatcher("x"));
 
-            // Act
-            var result = new RequestMatchResult();
-            double score = matcher.GetMatchingScore(requestMessage, result);
+        // Act
+        var result = new RequestMatchResult();
+        double score = matcher.GetMatchingScore(requestMessage, result);
 
-            // Assert
-            Check.That(score).IsEqualTo(1.0d);
-        }
+        // Assert
+        Check.That(score).IsEqualTo(1.0d);
+    }
 
-        [Fact]
-        public void RequestMessageHeaderMatcher_GetMatchingScore_Func_Match()
-        {
-            // Assign
-            var headers = new Dictionary<string, string[]> { { "h", new[] { "x" } } };
-            var requestMessage = new RequestMessage(new UrlDetails("http://localhost"), "GET", "127.0.0.1", null, headers);
-            var matcher = new RequestMessageHeaderMatcher(x => x.ContainsKey("h"));
+    [Fact]
+    public void RequestMessageHeaderMatcher_GetMatchingScore_Func_Match()
+    {
+        // Assign
+        var headers = new Dictionary<string, string[]> { { "h", new[] { "x" } } };
+        var requestMessage = new RequestMessage(new UrlDetails("http://localhost"), "GET", "127.0.0.1", null, headers);
+        var matcher = new RequestMessageHeaderMatcher(x => x.ContainsKey("h"));
 
-            // Act
-            var result = new RequestMatchResult();
-            double score = matcher.GetMatchingScore(requestMessage, result);
+        // Act
+        var result = new RequestMatchResult();
+        double score = matcher.GetMatchingScore(requestMessage, result);
 
-            // Assert
-            Check.That(score).IsEqualTo(1.0d);
-        }
+        // Assert
+        Check.That(score).IsEqualTo(1.0d);
+    }
 
-        [Fact]
-        public void RequestMessageHeaderMatcher_GetMatchingScore_CaseIgnoreForHeaderValue()
-        {
-            // Assign
-            var headers = new Dictionary<string, string[]> { { "h", new[] { "teST" } } };
-            var requestMessage = new RequestMessage(new UrlDetails("http://localhost"), "GET", "127.0.0.1", null, headers);
-            var matcher = new RequestMessageHeaderMatcher(MatchBehaviour.AcceptOnMatch, "h", "test", true);
+    [Fact]
+    public void RequestMessageHeaderMatcher_GetMatchingScore_CaseIgnoreForHeaderValue()
+    {
+        // Assign
+        var headers = new Dictionary<string, string[]> { { "h", new[] { "teST" } } };
+        var requestMessage = new RequestMessage(new UrlDetails("http://localhost"), "GET", "127.0.0.1", null, headers);
+        var matcher = new RequestMessageHeaderMatcher(MatchBehaviour.AcceptOnMatch, "h", "test", true);
 
-            // Act
-            var result = new RequestMatchResult();
-            double score = matcher.GetMatchingScore(requestMessage, result);
+        // Act
+        var result = new RequestMatchResult();
+        double score = matcher.GetMatchingScore(requestMessage, result);
 
-            // Assert
-            Check.That(score).IsEqualTo(1.0d);
-        }
+        // Assert
+        Check.That(score).IsEqualTo(1.0d);
+    }
 
-        [Fact]
-        public void RequestMessageHeaderMatcher_GetMatchingScore_CaseIgnoreForHeaderName()
-        {
-            // Assign
-            var headers = new Dictionary<string, string[]> { { "teST", new[] { "x" } } };
-            var requestMessage = new RequestMessage(new UrlDetails("http://localhost"), "GET", "127.0.0.1", null, headers);
-            var matcher = new RequestMessageHeaderMatcher(MatchBehaviour.AcceptOnMatch, "TEST", "x", true);
+    [Fact]
+    public void RequestMessageHeaderMatcher_GetMatchingScore_CaseIgnoreForHeaderName()
+    {
+        // Assign
+        var headers = new Dictionary<string, string[]> { { "teST", new[] { "x" } } };
+        var requestMessage = new RequestMessage(new UrlDetails("http://localhost"), "GET", "127.0.0.1", null, headers);
+        var matcher = new RequestMessageHeaderMatcher(MatchBehaviour.AcceptOnMatch, "TEST", "x", true);
 
-            // Act
-            var result = new RequestMatchResult();
-            double score = matcher.GetMatchingScore(requestMessage, result);
+        // Act
+        var result = new RequestMatchResult();
+        double score = matcher.GetMatchingScore(requestMessage, result);
 
-            // Assert
-            Check.That(score).IsEqualTo(1.0d);
-        }
+        // Assert
+        Check.That(score).IsEqualTo(1.0d);
     }
 }

test/WireMock.Net.Tests/RequestMessageTests.cs

@@ -1,107 +1,106 @@
-using NFluent;
+using NFluent;
 using WireMock.Models;
 using WireMock.Util;
 using Xunit;
 
-namespace WireMock.Net.Tests
+namespace WireMock.Net.Tests;
+
+public class RequestMessageTests
 {
-    public class RequestMessageTests
+    private const string ClientIp = "::1";
+
+    [Fact]
+    public void RequestMessage_Method_Should_BeSame()
     {
-        private const string ClientIp = "::1";
+        // given
+        var request = new RequestMessage(new UrlDetails("http://localhost/foo"), "posT", ClientIp);
 
-        [Fact]
-        public void RequestMessage_Method_Should_BeSame()
-        {
-            // given
-            var request = new RequestMessage(new UrlDetails("http://localhost/foo"), "posT", ClientIp);
+        // then
+        Check.That(request.Method).IsEqualTo("posT");
+    }
 
-            // then
-            Check.That(request.Method).IsEqualTo("posT");
-        }
+    [Fact]
+    public void RequestMessage_ParseQuery_NoKeys()
+    {
+        // given
+        var request = new RequestMessage(new UrlDetails("http://localhost/foo"), "POST", ClientIp);
 
-        [Fact]
-        public void RequestMessage_ParseQuery_NoKeys()
-        {
-            // given
-            var request = new RequestMessage(new UrlDetails("http://localhost/foo"), "POST", ClientIp);
+        // then
+        Check.That(request.GetParameter("not_there")).IsNull();
+    }
 
-            // then
-            Check.That(request.GetParameter("not_there")).IsNull();
-        }
+    [Fact]
+    public void RequestMessage_ParseQuery_SingleKey_SingleValue()
+    {
+        // Assign
+        var request = new RequestMessage(new UrlDetails("http://localhost?foo=bar"), "POST", ClientIp);
 
-        [Fact]
-        public void RequestMessage_ParseQuery_SingleKey_SingleValue()
-        {
-            // Assign
-            var request = new RequestMessage(new UrlDetails("http://localhost?foo=bar"), "POST", ClientIp);
+        // Assert
+        Check.That(request.GetParameter("foo")).ContainsExactly("bar");
+    }
 
-            // Assert
-            Check.That(request.GetParameter("foo")).ContainsExactly("bar");
-        }
+    [Fact]
+    public void RequestMessage_ParseQuery_SingleKey_SingleValue_WithIgnoreCase()
+    {
+        // Assign
+        var request = new RequestMessage(new UrlDetails("http://localhost?foo=bar"), "POST", ClientIp);
 
-        [Fact]
-        public void RequestMessage_ParseQuery_SingleKey_SingleValue_WithIgnoreCase()
-        {
-            // Assign
-            var request = new RequestMessage(new UrlDetails("http://localhost?foo=bar"), "POST", ClientIp);
+        // Assert
+        Check.That(request.GetParameter("FoO", true)).ContainsExactly("bar");
+    }
 
-            // Assert
-            Check.That(request.GetParameter("FoO", true)).ContainsExactly("bar");
-        }
+    [Fact]
+    public void RequestMessage_ParseQuery_MultipleKeys_MultipleValues()
+    {
+        // Assign
+        var request = new RequestMessage(new UrlDetails("http://localhost?key=1&key=2"), "POST", ClientIp);
 
-        [Fact]
-        public void RequestMessage_ParseQuery_MultipleKeys_MultipleValues()
-        {
-            // Assign
-            var request = new RequestMessage(new UrlDetails("http://localhost?key=1&key=2"), "POST", ClientIp);
+        // Assert
+        Check.That(request.GetParameter("key")).Contains("1");
+        Check.That(request.GetParameter("key")).Contains("2");
+    }
 
-            // Assert
-            Check.That(request.GetParameter("key")).Contains("1");
-            Check.That(request.GetParameter("key")).Contains("2");
-        }
+    [Fact]
+    public void RequestMessage_ParseQuery_SingleKey_MultipleValuesCommaSeparated()
+    {
+        // Assign
+        var request = new RequestMessage(new UrlDetails("http://localhost?key=1,2,3"), "POST", ClientIp);
 
-        [Fact]
-        public void RequestMessage_ParseQuery_SingleKey_MultipleValuesCommaSeparated()
-        {
-            // Assign
-            var request = new RequestMessage(new UrlDetails("http://localhost?key=1,2,3"), "POST", ClientIp);
+        // Assert
+        Check.That(request.GetParameter("key")).Contains("1");
+        Check.That(request.GetParameter("key")).Contains("2");
+        Check.That(request.GetParameter("key")).Contains("3");
+    }
 
-            // Assert
-            Check.That(request.GetParameter("key")).Contains("1");
-            Check.That(request.GetParameter("key")).Contains("2");
-            Check.That(request.GetParameter("key")).Contains("3");
-        }
+    [Fact]
+    public void RequestMessage_ParseQuery_SingleKey_MultipleValues()
+    {
+        // Assign
+        var request = new RequestMessage(new UrlDetails("http://localhost?key=1,2&foo=bar&key=3"), "POST", ClientIp);
 
-        [Fact]
-        public void RequestMessage_ParseQuery_SingleKey_MultipleValues()
-        {
-            // Assign
-            var request = new RequestMessage(new UrlDetails("http://localhost?key=1,2&foo=bar&key=3"), "POST", ClientIp);
+        // Assert
+        Check.That(request.GetParameter("key")).Contains("1");
+        Check.That(request.GetParameter("key")).Contains("2");
+        Check.That(request.GetParameter("key")).Contains("3");
+    }
 
-            // Assert
-            Check.That(request.GetParameter("key")).Contains("1");
-            Check.That(request.GetParameter("key")).Contains("2");
-            Check.That(request.GetParameter("key")).Contains("3");
-        }
+    [Fact]
+    public void RequestMessage_Constructor1_PathSegments()
+    {
+        // Assign
+        var request = new RequestMessage(new UrlDetails("http://localhost/a/b/c"), "POST", ClientIp);
 
-        [Fact]
-        public void RequestMessage_Constructor1_PathSegments()
-        {
-            // Assign
-            var request = new RequestMessage(new UrlDetails("http://localhost/a/b/c"), "POST", ClientIp);
+        // Assert
+        Check.That(request.PathSegments).ContainsExactly("a", "b", "c");
+    }
 
-            // Assert
-            Check.That(request.PathSegments).ContainsExactly("a", "b", "c");
-        }
+    [Fact]
+    public void RequestMessage_Constructor2_PathSegments()
+    {
+        // Assign
+        var request = new RequestMessage(new UrlDetails("http://localhost/a/b/c"), "POST", ClientIp, new BodyData());
 
-        [Fact]
-        public void RequestMessage_Constructor2_PathSegments()
-        {
-            // Assign
-            var request = new RequestMessage(new UrlDetails("http://localhost/a/b/c"), "POST", ClientIp, new BodyData());
-
-            // Assert
-            Check.That(request.PathSegments).ContainsExactly("a", "b", "c");
-        }
+        // Assert
+        Check.That(request.PathSegments).ContainsExactly("a", "b", "c");
     }
 }

test/WireMock.Net.Tests/Serialization/CustomPathParamMatcher.cs

@@ -41,7 +41,7 @@ public class CustomPathParamMatcher : IStringMatcher
         MatchOperator = matchOperator;
     }
 
-    public double IsMatch(string input)
+    public double IsMatch(string? input)
     {
         var inputParts = GetPathParts(input);
         if (inputParts.Length != _pathParts.Length)
@@ -97,8 +97,13 @@ public class CustomPathParamMatcher : IStringMatcher
 
     public MatchOperator MatchOperator { get; }
 
-    private static string[] GetPathParts(string path)
+    private static string[] GetPathParts(string? path)
     {
+        if (path is null)
+        {
+            return new string[0];
+        }
+
         var hashMarkIndex = path.IndexOf('#');
         if (hashMarkIndex != -1)
         {

test/WireMock.Net.Tests/Serialization/MatcherMapperTests.cs

@@ -10,399 +10,402 @@ using WireMock.Serialization;
 using WireMock.Settings;
 using Xunit;
 
-namespace WireMock.Net.Tests.Serialization
+namespace WireMock.Net.Tests.Serialization;
+
+public class MatcherMapperTests
 {
-    public class MatcherMapperTests
+    private readonly WireMockServerSettings _settings = new();
+    private readonly MatcherMapper _sut;
+
+    public MatcherMapperTests()
     {
-        private readonly WireMockServerSettings _settings = new WireMockServerSettings();
-        private readonly MatcherMapper _sut;
-
-        public MatcherMapperTests()
-        {
-            _sut = new MatcherMapper(_settings);
-        }
-
-        [Fact]
-        public void MatcherMapper_Map_IMatcher_Null()
-        {
-            // Act
-            var model = _sut.Map((IMatcher)null);
-
-            // Assert
-            model.Should().BeNull();
-        }
-
-        [Fact]
-        public void MatcherMapper_Map_IMatchers_Null()
-        {
-            // Act
-            var model = _sut.Map((IMatcher[])null);
-
-            // Assert
-            model.Should().BeNull();
-        }
-
-        [Fact]
-        public void MatcherMapper_Map_IMatchers()
-        {
-            // Assign
-            var matcherMock1 = new Mock<IStringMatcher>();
-            var matcherMock2 = new Mock<IStringMatcher>();
-
-            // Act
-            var models = _sut.Map(new[] { matcherMock1.Object, matcherMock2.Object });
-
-            // Assert
-            models.Should().HaveCount(2);
-        }
-
-        [Fact]
-        public void MatcherMapper_Map_IStringMatcher()
-        {
-            // Assign
-            var matcherMock = new Mock<IStringMatcher>();
-            matcherMock.Setup(m => m.Name).Returns("test");
-            matcherMock.Setup(m => m.GetPatterns()).Returns(new AnyOf<string, StringPattern>[] { "p1", "p2" });
-
-            // Act
-            var model = _sut.Map(matcherMock.Object);
-
-            // Assert
-            model.IgnoreCase.Should().BeNull();
-            model.Name.Should().Be("test");
-            model.Pattern.Should().BeNull();
-            model.Patterns.Should().HaveCount(2)
-                .And.Contain("p1")
-                .And.Contain("p2");
-        }
-
-        [Fact]
-        public void MatcherMapper_Map_IStringMatcher_With_PatternAsFile()
-        {
-            // Arrange
-            var pattern = new StringPattern { Pattern = "p", PatternAsFile = "pf" };
-
-            var matcherMock = new Mock<IStringMatcher>();
-            matcherMock.Setup(m => m.Name).Returns("test");
-            matcherMock.Setup(m => m.GetPatterns()).Returns(new AnyOf<string, StringPattern>[] { pattern });
-
-            // Act
-            var model = _sut.Map(matcherMock.Object);
-
-            // Assert
-            model.IgnoreCase.Should().BeNull();
-            model.Name.Should().Be("test");
-            model.Pattern.Should().Be("p");
-            model.Patterns.Should().BeNull();
-            model.PatternAsFile.Should().Be("pf");
-        }
-
-        [Fact]
-        public void MatcherMapper_Map_IIgnoreCaseMatcher()
-        {
-            // Assign
-            var matcherMock = new Mock<IIgnoreCaseMatcher>();
-            matcherMock.Setup(m => m.IgnoreCase).Returns(true);
-
-            // Act
-            var model = _sut.Map(matcherMock.Object);
-
-            // Assert
-            model.IgnoreCase.Should().BeTrue();
-        }
-
-        [Fact]
-        public void MatcherMapper_Map_MatcherModel_Null()
-        {
-            // Act
-            var result = _sut.Map((MatcherModel)null);
-
-            // Assert
-            result.Should().BeNull();
-        }
-
-        [Fact]
-        public void MatcherMapper_Map_MatcherModel_Exception()
-        {
-            // Assign
-            var model = new MatcherModel { Name = "test" };
-
-            // Act and Assert
-            Check.ThatCode(() => _sut.Map(model)).Throws<NotSupportedException>();
-        }
-
-        [Fact]
-        public void MatcherMapper_Map_MatcherModel_LinqMatcher_Pattern()
-        {
-            // Assign
-            var model = new MatcherModel
-            {
-                Name = "LinqMatcher",
-                Pattern = "p"
-            };
-
-            // Act
-            var matcher = (LinqMatcher)_sut.Map(model);
-
-            // Assert
-            matcher.MatchBehaviour.Should().Be(MatchBehaviour.AcceptOnMatch);
-            matcher.GetPatterns().Should().Contain("p");
-        }
-
-        [Fact]
-        public void MatcherMapper_Map_MatcherModel_LinqMatcher_Patterns()
-        {
-            // Assign
-            var model = new MatcherModel
-            {
-                Name = "LinqMatcher",
-                Patterns = new[] { "p1", "p2" }
-            };
-
-            // Act
-            var matcher = (LinqMatcher)_sut.Map(model);
-
-            // Assert
-            matcher.MatchBehaviour.Should().Be(MatchBehaviour.AcceptOnMatch);
-            matcher.GetPatterns().Should().Contain("p1", "p2");
-        }
-
-        [Fact]
-        public void MatcherMapper_Map_MatcherModel_JsonMatcher_Pattern_As_String()
-        {
-            // Assign
-            var pattern = "{ \"AccountIds\": [ 1, 2, 3 ] }";
-            var model = new MatcherModel
-            {
-                Name = "JsonMatcher",
-                Pattern = pattern
-            };
-
-            // Act
-            var matcher = (JsonMatcher)_sut.Map(model);
-
-            // Assert
-            matcher.MatchBehaviour.Should().Be(MatchBehaviour.AcceptOnMatch);
-            matcher.Value.Should().BeEquivalentTo(pattern);
-        }
-
-        [Fact]
-        public void MatcherMapper_Map_MatcherModel_JsonMatcher_Patterns_1_Value_As_String()
-        {
-            // Assign
-            var pattern = "{ \"post1\": \"value1\", \"post2\": \"value2\" }";
-            var patterns = new[] { pattern };
-            var model = new MatcherModel
-            {
-                Name = "JsonMatcher",
-                Patterns = patterns
-            };
-
-            // Act
-            var matcher = (JsonMatcher)_sut.Map(model);
-
-            // Assert
-            matcher.MatchBehaviour.Should().Be(MatchBehaviour.AcceptOnMatch);
-            matcher.Value.Should().BeEquivalentTo(patterns);
-        }
-
-        [Fact]
-        public void MatcherMapper_Map_MatcherModel_JsonMatcher_Patterns_2_Values_As_String()
-        {
-            // Assign
-            var pattern1 = "{ \"AccountIds\": [ 1, 2, 3 ] }";
-            var pattern2 = "{ \"post1\": \"value1\", \"post2\": \"value2\" }";
-            var patterns = new[] { pattern1, pattern2 };
-            var model = new MatcherModel
-            {
-                Name = "JsonMatcher",
-                Patterns = patterns
-            };
-
-            // Act
-            var matcher = (JsonMatcher)_sut.Map(model);
-
-            // Assert
-            matcher.MatchBehaviour.Should().Be(MatchBehaviour.AcceptOnMatch);
-            matcher.Value.Should().BeEquivalentTo(patterns);
-        }
-
-        [Fact]
-        public void MatcherMapper_Map_MatcherModel_JsonMatcher_Pattern_As_Object()
-        {
-            // Assign
-            var pattern = new { AccountIds = new[] { 1, 2, 3 } };
-            var model = new MatcherModel
-            {
-                Name = "JsonMatcher",
-                Pattern = pattern
-            };
-
-            // Act
-            var matcher = (JsonMatcher)_sut.Map(model);
-
-            // Assert
-            matcher.MatchBehaviour.Should().Be(MatchBehaviour.AcceptOnMatch);
-            matcher.Value.Should().BeEquivalentTo(pattern);
-        }
-
-        [Fact]
-        public void MatcherMapper_Map_MatcherModel_JsonMatcher_Patterns_1_Value_As_Object()
-        {
-            // Assign
-            object pattern = new { post1 = "value1", post2 = "value2" };
-            var patterns = new[] { pattern };
-            var model = new MatcherModel
-            {
-                Name = "JsonMatcher",
-                Patterns = patterns
-            };
-
-            // Act
-            var matcher = (JsonMatcher)_sut.Map(model);
-
-            // Assert
-            matcher.MatchBehaviour.Should().Be(MatchBehaviour.AcceptOnMatch);
-            matcher.Value.Should().BeEquivalentTo(patterns);
-        }
-
-        [Fact]
-        public void MatcherMapper_Map_MatcherModel_JsonMatcher_Patterns_2_Values_As_Object()
-        {
-            // Assign
-            object pattern1 = new { AccountIds = new[] { 1, 2, 3 } };
-            object pattern2 = new { post1 = "value1", post2 = "value2" };
-            var patterns = new[] { pattern1, pattern2 };
-            var model = new MatcherModel
-            {
-                Name = "JsonMatcher",
-                Patterns = patterns
-            };
-
-            // Act
-            var matcher = (JsonMatcher)_sut.Map(model);
-
-            // Assert
-            matcher.MatchBehaviour.Should().Be(MatchBehaviour.AcceptOnMatch);
-            matcher.Value.Should().BeEquivalentTo(patterns);
-        }
-
-        [Fact]
-        public void MatcherMapper_Map_MatcherModel_JsonPartialMatcher_Pattern_As_String()
-        {
-            // Assign
-            var pattern = "{ \"AccountIds\": [ 1, 2, 3 ] }";
-            var model = new MatcherModel
-            {
-                Name = "JsonPartialMatcher",
-                Pattern = pattern
-            };
-
-            // Act
-            var matcher = (JsonPartialMatcher)_sut.Map(model);
-
-            // Assert
-            matcher.MatchBehaviour.Should().Be(MatchBehaviour.AcceptOnMatch);
-            matcher.Value.Should().BeEquivalentTo(pattern);
-        }
-
-        [Fact]
-        public void MatcherMapper_Map_MatcherModel_JsonPartialMatcher_Patterns_As_String()
-        {
-            // Assign
-            var pattern1 = "{ \"AccountIds\": [ 1, 2, 3 ] }";
-            var pattern2 = "{ \"X\": \"x\" }";
-            var patterns = new[] { pattern1, pattern2 };
-            var model = new MatcherModel
-            {
-                Name = "JsonPartialMatcher",
-                Pattern = patterns
-            };
-
-            // Act
-            var matcher = (JsonPartialMatcher)_sut.Map(model);
-
-            // Assert
-            matcher.MatchBehaviour.Should().Be(MatchBehaviour.AcceptOnMatch);
-            matcher.Value.Should().BeEquivalentTo(patterns);
-        }
-
-        [Fact]
-        public void MatcherMapper_Map_MatcherModel_JsonPartialMatcher_Pattern_As_Object()
-        {
-            // Assign
-            var pattern = new { AccountIds = new[] { 1, 2, 3 } };
-            var model = new MatcherModel
-            {
-                Name = "JsonPartialMatcher",
-                Pattern = pattern
-            };
-
-            // Act
-            var matcher = (JsonPartialMatcher)_sut.Map(model);
-
-            // Assert
-            matcher.MatchBehaviour.Should().Be(MatchBehaviour.AcceptOnMatch);
-            matcher.Value.Should().BeEquivalentTo(pattern);
-        }
-
-        [Fact]
-        public void MatcherMapper_Map_MatcherModel_JsonPartialMatcher_Patterns_As_Object()
-        {
-            // Assign
-            object pattern1 = new { AccountIds = new[] { 1, 2, 3 } };
-            object pattern2 = new { X = "x" };
-            var patterns = new[] { pattern1, pattern2 };
-            var model = new MatcherModel
-            {
-                Name = "JsonPartialMatcher",
-                Patterns = patterns
-            };
-
-            // Act
-            var matcher = (JsonMatcher)_sut.Map(model);
-
-            // Assert
-            matcher.MatchBehaviour.Should().Be(MatchBehaviour.AcceptOnMatch);
-            matcher.Value.Should().BeEquivalentTo(patterns);
-        }
-
-        [Fact]
-        public void MatcherMapper_Map_MatcherModel_JsonPartialMatcher_StringPattern_With_PatternAsFile()
-        {
-            // Assign
-            var pattern = new StringPattern { Pattern = "{ \"AccountIds\": [ 1, 2, 3 ] }", PatternAsFile = "pf" };
-            var model = new MatcherModel
-            {
-                Name = "JsonPartialMatcher",
-                Pattern = pattern
-            };
-
-            // Act
-            var matcher = (JsonPartialMatcher)_sut.Map(model);
-
-            // Assert
-            matcher.MatchBehaviour.Should().Be(MatchBehaviour.AcceptOnMatch);
-            matcher.Value.Should().BeEquivalentTo(pattern);
-        }
-
-        [Fact]
-        public void MatcherMapper_Map_MatcherModel_JsonPartialWilcardMatcher_Patterns_As_Object()
-        {
-            // Assign
-            object pattern = new { X = "*" };
-            var model = new MatcherModel
-            {
-                Name = "JsonPartialWildcardMatcher",
-                Pattern = pattern
-            };
-
-            // Act
-            var matcher = (JsonPartialWildcardMatcher)_sut.Map(model);
-
-            // Assert
-            matcher.MatchBehaviour.Should().Be(MatchBehaviour.AcceptOnMatch);
-            matcher.Value.Should().BeEquivalentTo(pattern);
-        }
+        _sut = new MatcherMapper(_settings);
     }
-}
+
+    [Fact]
+    public void MatcherMapper_Map_IMatcher_Null()
+    {
+        // Act
+        var model = _sut.Map((IMatcher?)null);
+
+        // Assert
+        model.Should().BeNull();
+    }
+
+    [Fact]
+    public void MatcherMapper_Map_IMatchers_Null()
+    {
+        // Act
+        var model = _sut.Map((IMatcher[]?)null);
+
+        // Assert
+        model.Should().BeNull();
+    }
+
+    [Fact]
+    public void MatcherMapper_Map_IMatchers()
+    {
+        // Assign
+        var matcherMock1 = new Mock<IStringMatcher>();
+        var matcherMock2 = new Mock<IStringMatcher>();
+
+        // Act
+        var models = _sut.Map(new[] { matcherMock1.Object, matcherMock2.Object });
+
+        // Assert
+        models.Should().HaveCount(2);
+    }
+
+    [Fact]
+    public void MatcherMapper_Map_IStringMatcher()
+    {
+        // Assign
+        var matcherMock = new Mock<IStringMatcher>();
+        matcherMock.Setup(m => m.Name).Returns("test");
+        matcherMock.Setup(m => m.GetPatterns()).Returns(new AnyOf<string, StringPattern>[] { "p1", "p2" });
+
+        // Act
+        var model = _sut.Map(matcherMock.Object)!;
+
+        // Assert
+        model.IgnoreCase.Should().BeNull();
+        model.Name.Should().Be("test");
+        model.Pattern.Should().BeNull();
+        model.Patterns.Should().HaveCount(2)
+            .And.Contain("p1")
+            .And.Contain("p2");
+    }
+
+    [Fact]
+    public void MatcherMapper_Map_IStringMatcher_With_PatternAsFile()
+    {
+        // Arrange
+        var pattern = new StringPattern { Pattern = "p", PatternAsFile = "pf" };
+
+        var matcherMock = new Mock<IStringMatcher>();
+        matcherMock.Setup(m => m.Name).Returns("test");
+        matcherMock.Setup(m => m.GetPatterns()).Returns(new AnyOf<string, StringPattern>[] { pattern });
+
+        // Act
+        var model = _sut.Map(matcherMock.Object)!;
+
+        // Assert
+        model.IgnoreCase.Should().BeNull();
+        model.Name.Should().Be("test");
+        model.Pattern.Should().Be("p");
+        model.Patterns.Should().BeNull();
+        model.PatternAsFile.Should().Be("pf");
+    }
+
+    [Fact]
+    public void MatcherMapper_Map_IIgnoreCaseMatcher()
+    {
+        // Assign
+        var matcherMock = new Mock<IIgnoreCaseMatcher>();
+        matcherMock.Setup(m => m.IgnoreCase).Returns(true);
+
+        // Act
+        var model = _sut.Map(matcherMock.Object)!;
+
+        // Assert
+        model.IgnoreCase.Should().BeTrue();
+    }
+
+    [Fact]
+    public void MatcherMapper_Map_MatcherModel_Null()
+    {
+        // Act
+        var result = _sut.Map((MatcherModel?)null);
+
+        // Assert
+        result.Should().BeNull();
+    }
+
+    [Fact]
+    public void MatcherMapper_Map_MatcherModel_Exception()
+    {
+        // Assign
+        var model = new MatcherModel { Name = "test" };
+
+        // Act and Assert
+        Check.ThatCode(() => _sut.Map(model)).Throws<NotSupportedException>();
+    }
+
+    [Fact]
+    public void MatcherMapper_Map_MatcherModel_LinqMatcher_Pattern()
+    {
+        // Assign
+        var model = new MatcherModel
+        {
+            Name = "LinqMatcher",
+            Pattern = "p"
+        };
+
+        // Act
+        var matcher = (LinqMatcher)_sut.Map(model)!;
+
+        // Assert
+        matcher.MatchBehaviour.Should().Be(MatchBehaviour.AcceptOnMatch);
+        matcher.GetPatterns().Should().Contain("p");
+    }
+
+    [Fact]
+    public void MatcherMapper_Map_MatcherModel_LinqMatcher_Patterns()
+    {
+        // Assign
+        var model = new MatcherModel
+        {
+            Name = "LinqMatcher",
+            Patterns = new[] { "p1", "p2" }
+        };
+
+        // Act
+        var matcher = (LinqMatcher)_sut.Map(model)!;
+
+        // Assert
+        matcher.MatchBehaviour.Should().Be(MatchBehaviour.AcceptOnMatch);
+        matcher.GetPatterns().Should().Contain("p1", "p2");
+    }
+
+    [Fact]
+    public void MatcherMapper_Map_MatcherModel_JsonMatcher_Pattern_As_String()
+    {
+        // Assign
+        var pattern = "{ \"AccountIds\": [ 1, 2, 3 ] }";
+        var model = new MatcherModel
+        {
+            Name = "JsonMatcher",
+            Pattern = pattern
+        };
+
+        // Act
+        var matcher = (JsonMatcher)_sut.Map(model)!;
+
+        // Assert
+        matcher.MatchBehaviour.Should().Be(MatchBehaviour.AcceptOnMatch);
+        matcher.Value.Should().BeEquivalentTo(pattern);
+    }
+
+    [Fact]
+    public void MatcherMapper_Map_MatcherModel_JsonMatcher_Patterns_1_Value_As_String()
+    {
+        // Assign
+        var pattern = "{ \"post1\": \"value1\", \"post2\": \"value2\" }";
+        var patterns = new[] { pattern };
+        var model = new MatcherModel
+        {
+            Name = "JsonMatcher",
+            Patterns = patterns
+        };
+
+        // Act
+        var matcher = (JsonMatcher)_sut.Map(model)!;
+
+        // Assert
+        matcher.MatchBehaviour.Should().Be(MatchBehaviour.AcceptOnMatch);
+        matcher.Value.Should().BeEquivalentTo(patterns);
+    }
+
+    [Fact]
+    public void MatcherMapper_Map_MatcherModel_JsonMatcher_Patterns_2_Values_As_String()
+    {
+        // Assign
+        var pattern1 = "{ \"AccountIds\": [ 1, 2, 3 ] }";
+        var pattern2 = "{ \"post1\": \"value1\", \"post2\": \"value2\" }";
+        var patterns = new[] { pattern1, pattern2 };
+        var model = new MatcherModel
+        {
+            Name = "JsonMatcher",
+            Patterns = patterns
+        };
+
+        // Act
+        var matcher = (JsonMatcher)_sut.Map(model)!;
+
+        // Assert
+        matcher.MatchBehaviour.Should().Be(MatchBehaviour.AcceptOnMatch);
+        matcher.Value.Should().BeEquivalentTo(patterns);
+    }
+
+    [Fact]
+    public void MatcherMapper_Map_MatcherModel_JsonMatcher_Pattern_As_Object()
+    {
+        // Assign
+        var pattern = new { AccountIds = new[] { 1, 2, 3 } };
+        var model = new MatcherModel
+        {
+            Name = "JsonMatcher",
+            Pattern = pattern
+        };
+
+        // Act
+        var matcher = (JsonMatcher)_sut.Map(model)!;
+
+        // Assert
+        matcher.MatchBehaviour.Should().Be(MatchBehaviour.AcceptOnMatch);
+        matcher.Value.Should().BeEquivalentTo(pattern);
+    }
+
+    [Fact]
+    public void MatcherMapper_Map_MatcherModel_JsonMatcher_Patterns_1_Value_As_Object()
+    {
+        // Assign
+        object pattern = new { post1 = "value1", post2 = "value2" };
+        var patterns = new[] { pattern };
+        var model = new MatcherModel
+        {
+            Name = "JsonMatcher",
+            Patterns = patterns
+        };
+
+        // Act
+        var matcher = (JsonMatcher)_sut.Map(model)!;
+
+        // Assert
+        matcher.MatchBehaviour.Should().Be(MatchBehaviour.AcceptOnMatch);
+        matcher.Value.Should().BeEquivalentTo(patterns);
+    }
+
+    [Fact]
+    public void MatcherMapper_Map_MatcherModel_JsonMatcher_Patterns_2_Values_As_Object()
+    {
+        // Assign
+        object pattern1 = new { AccountIds = new[] { 1, 2, 3 } };
+        object pattern2 = new { post1 = "value1", post2 = "value2" };
+        var patterns = new[] { pattern1, pattern2 };
+        var model = new MatcherModel
+        {
+            Name = "JsonMatcher",
+            Patterns = patterns
+        };
+
+        // Act
+        var matcher = (JsonMatcher)_sut.Map(model)!;
+
+        // Assert
+        matcher.MatchBehaviour.Should().Be(MatchBehaviour.AcceptOnMatch);
+        matcher.Value.Should().BeEquivalentTo(patterns);
+    }
+
+    [Fact]
+    public void MatcherMapper_Map_MatcherModel_JsonPartialMatcher_Pattern_As_String()
+    {
+        // Assign
+        var pattern = "{ \"AccountIds\": [ 1, 2, 3 ] }";
+        var model = new MatcherModel
+        {
+            Name = "JsonPartialMatcher",
+            Pattern = pattern
+        };
+
+        // Act
+        var matcher = (JsonPartialMatcher)_sut.Map(model)!;
+
+        // Assert
+        matcher.MatchBehaviour.Should().Be(MatchBehaviour.AcceptOnMatch);
+        matcher.Value.Should().BeEquivalentTo(pattern);
+    }
+
+    [Fact]
+    public void MatcherMapper_Map_MatcherModel_JsonPartialMatcher_Patterns_As_String()
+    {
+        // Assign
+        var pattern1 = "{ \"AccountIds\": [ 1, 2, 3 ] }";
+        var pattern2 = "{ \"X\": \"x\" }";
+        var patterns = new[] { pattern1, pattern2 };
+        var model = new MatcherModel
+        {
+            Name = "JsonPartialMatcher",
+            Pattern = patterns
+        };
+
+        // Act
+        var matcher = (JsonPartialMatcher)_sut.Map(model)!;
+
+        // Assert
+        matcher.MatchBehaviour.Should().Be(MatchBehaviour.AcceptOnMatch);
+        matcher.Value.Should().BeEquivalentTo(patterns);
+    }
+
+    [Fact]
+    public void MatcherMapper_Map_MatcherModel_JsonPartialMatcher_Pattern_As_Object()
+    {
+        // Assign
+        var pattern = new { AccountIds = new[] { 1, 2, 3 } };
+        var model = new MatcherModel
+        {
+            Name = "JsonPartialMatcher",
+            Pattern = pattern
+        };
+
+        // Act
+        var matcher = (JsonPartialMatcher)_sut.Map(model)!;
+
+        // Assert
+        matcher.MatchBehaviour.Should().Be(MatchBehaviour.AcceptOnMatch);
+        matcher.Value.Should().BeEquivalentTo(pattern);
+    }
+
+    [Fact]
+    public void MatcherMapper_Map_MatcherModel_JsonPartialMatcher_Patterns_As_Object()
+    {
+        // Assign
+        object pattern1 = new { AccountIds = new[] { 1, 2, 3 } };
+        object pattern2 = new { X = "x" };
+        var patterns = new[] { pattern1, pattern2 };
+        var model = new MatcherModel
+        {
+            Name = "JsonPartialMatcher",
+            Patterns = patterns
+        };
+
+        // Act
+        var matcher = (JsonMatcher)_sut.Map(model)!;
+
+        // Assert
+        matcher.MatchBehaviour.Should().Be(MatchBehaviour.AcceptOnMatch);
+        matcher.Value.Should().BeEquivalentTo(patterns);
+    }
+
+    [Fact]
+    public void MatcherMapper_Map_MatcherModel_JsonPartialMatcher_StringPattern_With_PatternAsFile()
+    {
+        // Assign
+        var pattern = new StringPattern { Pattern = "{ \"AccountIds\": [ 1, 2, 3 ] }", PatternAsFile = "pf" };
+        var model = new MatcherModel
+        {
+            Name = "JsonPartialMatcher",
+            Pattern = pattern,
+            Regex = true
+        };
+
+        // Act
+        var matcher = (JsonPartialMatcher)_sut.Map(model)!;
+
+        // Assert
+        matcher.MatchBehaviour.Should().Be(MatchBehaviour.AcceptOnMatch);
+        matcher.Value.Should().BeEquivalentTo(pattern);
+        matcher.Regex.Should().BeTrue();
+    }
+
+    [Fact]
+    public void MatcherMapper_Map_MatcherModel_JsonPartialWildcardMatcher_Patterns_As_Object()
+    {
+        // Assign
+        object pattern = new { X = "*" };
+        var model = new MatcherModel
+        {
+            Name = "JsonPartialWildcardMatcher",
+            Pattern = pattern,
+            Regex = false
+        };
+
+        // Act
+        var matcher = (JsonPartialWildcardMatcher)_sut.Map(model)!;
+
+        // Assert
+        matcher.MatchBehaviour.Should().Be(MatchBehaviour.AcceptOnMatch);
+        matcher.Value.Should().BeEquivalentTo(pattern);
+        matcher.Regex.Should().BeFalse();
+    }
+}

test/WireMock.Net.Tests/Serialization/MatcherModelMapperTests.cs

@@ -14,378 +14,427 @@ using WireMock.Serialization;
 using WireMock.Settings;
 using Xunit;
 
-namespace WireMock.Net.Tests.Serialization
+namespace WireMock.Net.Tests.Serialization;
+
+public class MatcherModelMapperTests
 {
-    public class MatcherModelMapperTests
+    private readonly WireMockServerSettings _settings = new();
+
+    private readonly MatcherMapper _sut;
+
+    public MatcherModelMapperTests()
     {
-        private readonly WireMockServerSettings _settings = new WireMockServerSettings();
+        _sut = new MatcherMapper(_settings);
+    }
 
-        private readonly MatcherMapper _sut;
-
-        public MatcherModelMapperTests()
+    [Fact]
+    public void MatcherModelMapper_Map_CSharpCodeMatcher()
+    {
+        // Assign
+        var model = new MatcherModel
         {
-            _sut = new MatcherMapper(_settings);
-        }
+            Name = "CSharpCodeMatcher",
+            Patterns = new[] { "return it == \"x\";" }
+        };
+        var sut = new MatcherMapper(new WireMockServerSettings { AllowCSharpCodeMatcher = true });
 
-        [Fact]
-        public void MatcherModelMapper_Map_CSharpCodeMatcher()
+        // Act 1
+        var matcher1 = (ICSharpCodeMatcher)sut.Map(model)!;
+
+        // Assert 1
+        matcher1.Should().NotBeNull();
+        matcher1.IsMatch("x").Should().Be(1.0d);
+
+        // Act 2
+        var matcher2 = (ICSharpCodeMatcher)sut.Map(model)!;
+
+        // Assert 2
+        matcher2.Should().NotBeNull();
+        matcher2.IsMatch("x").Should().Be(1.0d);
+    }
+
+    [Fact]
+    public void MatcherModelMapper_Map_CSharpCodeMatcher_NotAllowed_ThrowsException()
+    {
+        // Assign
+        var model = new MatcherModel
         {
-            // Assign
-            var model = new MatcherModel
-            {
-                Name = "CSharpCodeMatcher",
-                Patterns = new[] { "return it == \"x\";" }
-            };
-            var sut = new MatcherMapper(new WireMockServerSettings { AllowCSharpCodeMatcher = true });
+            Name = "CSharpCodeMatcher",
+            Patterns = new[] { "x" }
+        };
+        var sut = new MatcherMapper(new WireMockServerSettings { AllowCSharpCodeMatcher = false });
 
-            // Act 1
-            var matcher1 = (ICSharpCodeMatcher)sut.Map(model);
+        // Act
+        Action action = () => sut.Map(model);
 
-            // Assert 1
-            matcher1.Should().NotBeNull();
-            matcher1.IsMatch("x").Should().Be(1.0d);
+        // Assert
+        action.Should().Throw<NotSupportedException>();
+    }
 
-            // Act 2
-            var matcher2 = (ICSharpCodeMatcher)sut.Map(model);
+    [Fact]
+    public void MatcherModelMapper_Map_Null()
+    {
+        // Act
+        IMatcher matcher = _sut.Map((MatcherModel?)null)!;
 
-            // Assert 2
-            matcher2.Should().NotBeNull();
-            matcher2.IsMatch("x").Should().Be(1.0d);
-        }
+        // Assert
+        Check.That(matcher).IsNull();
+    }
 
-        [Fact]
-        public void MatcherModelMapper_Map_CSharpCodeMatcher_NotAllowed_ThrowsException()
+    [Fact]
+    public void MatcherModelMapper_Map_ExactMatcher_Pattern()
+    {
+        // Assign
+        var model = new MatcherModel
         {
-            // Assign
-            var model = new MatcherModel
-            {
-                Name = "CSharpCodeMatcher",
-                Patterns = new[] { "x" }
-            };
-            var sut = new MatcherMapper(new WireMockServerSettings { AllowCSharpCodeMatcher = false });
+            Name = "ExactMatcher",
+            Patterns = new[] { "x" }
+        };
 
-            // Act
-            Action action = () => sut.Map(model);
+        // Act
+        var matcher = (ExactMatcher)_sut.Map(model)!;
 
-            // Assert
-            action.Should().Throw<NotSupportedException>();
-        }
+        // Assert
+        matcher.GetPatterns().Should().ContainSingle("x");
+        matcher.ThrowException.Should().BeFalse();
+    }
 
-        [Fact]
-        public void MatcherModelMapper_Map_Null()
+    [Fact]
+    public void MatcherModelMapper_Map_ExactMatcher_Patterns()
+    {
+        // Assign
+        var model = new MatcherModel
         {
-            // Act
-            IMatcher matcher = _sut.Map((MatcherModel)null);
+            Name = "ExactMatcher",
+            Patterns = new[] { "x", "y" }
+        };
 
-            // Assert
-            Check.That(matcher).IsNull();
-        }
+        // Act
+        var matcher = (ExactMatcher)_sut.Map(model)!;
 
-        [Fact]
-        public void MatcherModelMapper_Map_ExactMatcher_Pattern()
+        // Assert
+        Check.That(matcher.GetPatterns()).ContainsExactly("x", "y");
+    }
+
+    [Fact]
+    public void MatcherModelMapper_Map_JsonPartialMatcher_RegexFalse()
+    {
+        // Assign
+        var pattern = "{ \"x\": 1 }";
+        var model = new MatcherModel
         {
-            // Assign
-            var model = new MatcherModel
-            {
-                Name = "ExactMatcher",
-                Patterns = new[] { "x" }
-            };
+            Name = "JsonPartialMatcher",
+            Regex = false,
+            Pattern = pattern
+        };
 
-            // Act
-            var matcher = (ExactMatcher)_sut.Map(model);
+        // Act
+        var matcher = (JsonPartialMatcher)_sut.Map(model)!;
 
-            // Assert
-            matcher.GetPatterns().Should().ContainSingle("x");
-            matcher.ThrowException.Should().BeFalse();
-        }
+        // Assert
+        matcher.MatchBehaviour.Should().Be(MatchBehaviour.AcceptOnMatch);
+        matcher.IgnoreCase.Should().BeFalse();
+        matcher.Value.Should().Be(pattern);
+        matcher.Regex.Should().BeFalse();
+        matcher.ThrowException.Should().BeFalse();
+    }
 
-        [Fact]
-        public void MatcherModelMapper_Map_ExactMatcher_Patterns()
+    [Fact]
+    public void MatcherModelMapper_Map_JsonPartialMatcher_RegexTrue()
+    {
+        // Assign
+        var pattern = "{ \"x\": 1 }";
+        var model = new MatcherModel
         {
-            // Assign
-            var model = new MatcherModel
-            {
-                Name = "ExactMatcher",
-                Patterns = new[] { "x", "y" }
-            };
+            Name = "JsonPartialMatcher",
+            Regex = true,
+            Pattern = pattern
+        };
 
-            // Act
-            var matcher = (ExactMatcher)_sut.Map(model);
+        // Act
+        var matcher = (JsonPartialMatcher)_sut.Map(model)!;
 
-            // Assert
-            Check.That(matcher.GetPatterns()).ContainsExactly("x", "y");
-        }
+        // Assert
+        matcher.MatchBehaviour.Should().Be(MatchBehaviour.AcceptOnMatch);
+        matcher.IgnoreCase.Should().BeFalse();
+        matcher.Value.Should().Be(pattern);
+        matcher.Regex.Should().BeTrue();
+        matcher.ThrowException.Should().BeFalse();
+    }
 
-        [Theory]
-        [InlineData(nameof(LinqMatcher))]
-        [InlineData(nameof(ExactMatcher))]
-        [InlineData(nameof(ExactObjectMatcher))]
-        [InlineData(nameof(RegexMatcher))]
-        [InlineData(nameof(JsonMatcher))]
-        [InlineData(nameof(JsonPathMatcher))]
-        [InlineData(nameof(JmesPathMatcher))]
-        [InlineData(nameof(XPathMatcher))]
-        [InlineData(nameof(WildcardMatcher))]
-        [InlineData(nameof(ContentTypeMatcher))]
-        [InlineData(nameof(SimMetricsMatcher))]
-        public void MatcherModelMapper_Map_ThrowExceptionWhenMatcherFails_True(string name)
+    [Theory]
+    [InlineData(nameof(LinqMatcher))]
+    [InlineData(nameof(ExactMatcher))]
+    [InlineData(nameof(ExactObjectMatcher))]
+    [InlineData(nameof(RegexMatcher))]
+    [InlineData(nameof(JsonMatcher))]
+    [InlineData(nameof(JsonPartialMatcher))]
+    [InlineData(nameof(JsonPartialWildcardMatcher))]
+    [InlineData(nameof(JsonPathMatcher))]
+    [InlineData(nameof(JmesPathMatcher))]
+    [InlineData(nameof(XPathMatcher))]
+    [InlineData(nameof(WildcardMatcher))]
+    [InlineData(nameof(ContentTypeMatcher))]
+    [InlineData(nameof(SimMetricsMatcher))]
+    public void MatcherModelMapper_Map_ThrowExceptionWhenMatcherFails_True(string name)
+    {
+        // Assign
+        var settings = new WireMockServerSettings
         {
-            // Assign
-            var settings = new WireMockServerSettings
-            {
-                ThrowExceptionWhenMatcherFails = true
-            };
-            var sut = new MatcherMapper(settings);
-            var model = new MatcherModel
-            {
-                Name = name,
-                Patterns = new[] { "" }
-            };
-
-            // Act
-            var matcher = sut.Map(model);
-
-            // Assert
-            matcher.ThrowException.Should().BeTrue();
-        }
-
-        [Fact]
-        public void MatcherModelMapper_Map_ExactObjectMatcher_ValidBase64StringPattern()
+            ThrowExceptionWhenMatcherFails = true
+        };
+        var sut = new MatcherMapper(settings);
+        var model = new MatcherModel
         {
-            // Assign
-            var model = new MatcherModel
-            {
-                Name = "ExactObjectMatcher",
-                Patterns = new object[] { "c3RlZg==" }
-            };
+            Name = name,
+            Patterns = new[] { "" }
+        };
 
-            // Act
-            var matcher = (ExactObjectMatcher)_sut.Map(model);
+        // Act
+        var matcher = sut.Map(model)!;
 
-            // Assert
-            Check.That(matcher.ValueAsBytes).ContainsExactly(new byte[] { 115, 116, 101, 102 });
-        }
+        // Assert
+        matcher.Should().NotBeNull();
+        matcher.ThrowException.Should().BeTrue();
+    }
 
-        [Fact]
-        public void MatcherModelMapper_Map_ExactObjectMatcher_InvalidBase64StringPattern()
+    [Fact]
+    public void MatcherModelMapper_Map_ExactObjectMatcher_ValidBase64StringPattern()
+    {
+        // Assign
+        var model = new MatcherModel
         {
-            // Assign
-            var model = new MatcherModel
-            {
-                Name = "ExactObjectMatcher",
-                Patterns = new object[] { "_" }
-            };
+            Name = "ExactObjectMatcher",
+            Patterns = new object[] { "c3RlZg==" }
+        };
 
-            // Act & Assert
-            Check.ThatCode(() => _sut.Map(model)).Throws<ArgumentException>();
-        }
+        // Act
+        var matcher = (ExactObjectMatcher)_sut.Map(model)!;
 
-        [Theory]
-        [InlineData(MatchOperator.Or, 1.0d)]
-        [InlineData(MatchOperator.And, 0.0d)]
-        [InlineData(MatchOperator.Average, 0.5d)]
-        public void MatcherModelMapper_Map_RegexMatcher(MatchOperator matchOperator, double expected)
+        // Assert
+        Check.That(matcher.ValueAsBytes).ContainsExactly(new byte[] { 115, 116, 101, 102 });
+    }
+
+    [Fact]
+    public void MatcherModelMapper_Map_ExactObjectMatcher_InvalidBase64StringPattern()
+    {
+        // Assign
+        var model = new MatcherModel
         {
-            // Assign
-            var model = new MatcherModel
-            {
-                Name = "RegexMatcher",
-                Patterns = new[] { "x", "y" },
-                IgnoreCase = true,
-                MatchOperator = matchOperator.ToString()
-            };
+            Name = "ExactObjectMatcher",
+            Patterns = new object[] { "_" }
+        };
 
-            // Act
-            var matcher = (RegexMatcher)_sut.Map(model)!;
+        // Act & Assert
+        Check.ThatCode(() => _sut.Map(model)).Throws<ArgumentException>();
+    }
 
-            // Assert
-            Check.That(matcher.GetPatterns()).ContainsExactly("x", "y");
-            Check.That(matcher.IsMatch("X")).IsEqualTo(expected);
-        }
-
-        [Theory]
-        [InlineData(MatchOperator.Or, 1.0d)]
-        [InlineData(MatchOperator.And, 0.0d)]
-        [InlineData(MatchOperator.Average, 0.5d)]
-        public void MatcherModelMapper_Map_WildcardMatcher_IgnoreCase(MatchOperator matchOperator, double expected)
+    [Theory]
+    [InlineData(MatchOperator.Or, 1.0d)]
+    [InlineData(MatchOperator.And, 0.0d)]
+    [InlineData(MatchOperator.Average, 0.5d)]
+    public void MatcherModelMapper_Map_RegexMatcher(MatchOperator matchOperator, double expected)
+    {
+        // Assign
+        var model = new MatcherModel
         {
-            // Assign
-            var model = new MatcherModel
-            {
-                Name = "WildcardMatcher",
-                Patterns = new[] { "x", "y" },
-                IgnoreCase = true,
-                MatchOperator = matchOperator.ToString()
-            };
+            Name = "RegexMatcher",
+            Patterns = new[] { "x", "y" },
+            IgnoreCase = true,
+            MatchOperator = matchOperator.ToString()
+        };
 
-            // Act
-            var matcher = (WildcardMatcher)_sut.Map(model)!;
+        // Act
+        var matcher = (RegexMatcher)_sut.Map(model)!;
 
-            // Assert
-            Check.That(matcher.GetPatterns()).ContainsExactly("x", "y");
-            Check.That(matcher.IsMatch("X")).IsEqualTo(expected);
-        }
+        // Assert
+        Check.That(matcher.GetPatterns()).ContainsExactly("x", "y");
+        Check.That(matcher.IsMatch("X")).IsEqualTo(expected);
+    }
 
-        [Fact]
-        public void MatcherModelMapper_Map_WildcardMatcher_With_PatternAsFile()
+    [Theory]
+    [InlineData(MatchOperator.Or, 1.0d)]
+    [InlineData(MatchOperator.And, 0.0d)]
+    [InlineData(MatchOperator.Average, 0.5d)]
+    public void MatcherModelMapper_Map_WildcardMatcher_IgnoreCase(MatchOperator matchOperator, double expected)
+    {
+        // Assign
+        var model = new MatcherModel
         {
-            // Arrange
-            var file = "c:\\test.txt";
-            var fileContent = "c";
-            var stringPattern = new StringPattern
-            {
-                Pattern = fileContent,
-                PatternAsFile = file
-            };
-            var fileSystemHandleMock = new Mock<IFileSystemHandler>();
-            fileSystemHandleMock.Setup(f => f.ReadFileAsString(file)).Returns(fileContent);
+            Name = "WildcardMatcher",
+            Patterns = new[] { "x", "y" },
+            IgnoreCase = true,
+            MatchOperator = matchOperator.ToString()
+        };
 
-            var model = new MatcherModel
-            {
-                Name = "WildcardMatcher",
-                PatternAsFile = file
-            };
+        // Act
+        var matcher = (WildcardMatcher)_sut.Map(model)!;
 
-            var settings = new WireMockServerSettings
-            {
-                FileSystemHandler = fileSystemHandleMock.Object
-            };
-            var sut = new MatcherMapper(settings);
+        // Assert
+        Check.That(matcher.GetPatterns()).ContainsExactly("x", "y");
+        Check.That(matcher.IsMatch("X")).IsEqualTo(expected);
+    }
 
-            // Act
-            var matcher = (WildcardMatcher)sut.Map(model);
-
-            // Assert
-            matcher.GetPatterns().Should().HaveCount(1).And.Contain(new AnyOf<string, StringPattern>(stringPattern));
-            matcher.IsMatch("c").Should().Be(1.0d);
-        }
-
-        [Fact]
-        public void MatcherModelMapper_Map_SimMetricsMatcher()
+    [Fact]
+    public void MatcherModelMapper_Map_WildcardMatcher_With_PatternAsFile()
+    {
+        // Arrange
+        var file = "c:\\test.txt";
+        var fileContent = "c";
+        var stringPattern = new StringPattern
         {
-            // Assign
-            var model = new MatcherModel
-            {
-                Name = "SimMetricsMatcher",
-                Pattern = "x"
-            };
+            Pattern = fileContent,
+            PatternAsFile = file
+        };
+        var fileSystemHandleMock = new Mock<IFileSystemHandler>();
+        fileSystemHandleMock.Setup(f => f.ReadFileAsString(file)).Returns(fileContent);
 
-            // Act
-            var matcher = (SimMetricsMatcher)_sut.Map(model);
-
-            // Assert
-            Check.That(matcher.GetPatterns()).ContainsExactly("x");
-        }
-
-        [Fact]
-        public void MatcherModelMapper_Map_SimMetricsMatcher_BlockDistance()
+        var model = new MatcherModel
         {
-            // Assign
-            var model = new MatcherModel
-            {
-                Name = "SimMetricsMatcher.BlockDistance",
-                Pattern = "x"
-            };
+            Name = "WildcardMatcher",
+            PatternAsFile = file
+        };
 
-            // Act
-            var matcher = (SimMetricsMatcher)_sut.Map(model);
-
-            // Assert
-            Check.That(matcher.GetPatterns()).ContainsExactly("x");
-        }
-
-        [Fact]
-        public void MatcherModelMapper_Map_SimMetricsMatcher_Throws1()
+        var settings = new WireMockServerSettings
         {
-            // Assign
-            var model = new MatcherModel
-            {
-                Name = "error",
-                Pattern = "x"
-            };
+            FileSystemHandler = fileSystemHandleMock.Object
+        };
+        var sut = new MatcherMapper(settings);
 
-            // Act
-            Check.ThatCode(() => _sut.Map(model)).Throws<NotSupportedException>();
-        }
+        // Act
+        var matcher = (WildcardMatcher)sut.Map(model)!;
 
-        [Fact]
-        public void MatcherModelMapper_Map_SimMetricsMatcher_Throws2()
+        // Assert
+        matcher.GetPatterns().Should().HaveCount(1).And.Contain(new AnyOf<string, StringPattern>(stringPattern));
+        matcher.IsMatch("c").Should().Be(1.0d);
+    }
+
+    [Fact]
+    public void MatcherModelMapper_Map_SimMetricsMatcher()
+    {
+        // Assign
+        var model = new MatcherModel
         {
-            // Assign
-            var model = new MatcherModel
-            {
-                Name = "SimMetricsMatcher.error",
-                Pattern = "x"
-            };
+            Name = "SimMetricsMatcher",
+            Pattern = "x"
+        };
 
-            // Act
-            Check.ThatCode(() => _sut.Map(model)).Throws<NotSupportedException>();
-        }
+        // Act
+        var matcher = (SimMetricsMatcher)_sut.Map(model)!;
 
-        [Fact]
-        public void MatcherModelMapper_Map_MatcherModelToCustomMatcher()
+        // Assert
+        Check.That(matcher.GetPatterns()).ContainsExactly("x");
+    }
+
+    [Fact]
+    public void MatcherModelMapper_Map_SimMetricsMatcher_BlockDistance()
+    {
+        // Assign
+        var model = new MatcherModel
         {
-            // Arrange
-            var patternModel = new CustomPathParamMatcherModel("/customer/{customerId}/document/{documentId}",
-                new Dictionary<string, string>(2)
-                {
-                    { "customerId", @"^[0-9]+$" },
-                    { "documentId", @"^[0-9a-zA-Z\-\_]+\.[a-zA-Z]+$" }
-                });
-            var model = new MatcherModel
-            {
-                Name = nameof(CustomPathParamMatcher),
-                Pattern = JsonConvert.SerializeObject(patternModel)
-            };
+            Name = "SimMetricsMatcher.BlockDistance",
+            Pattern = "x"
+        };
 
-            var settings = new WireMockServerSettings();
-            settings.CustomMatcherMappings = settings.CustomMatcherMappings ?? new Dictionary<string, Func<MatcherModel, IMatcher>>();
-            settings.CustomMatcherMappings[nameof(CustomPathParamMatcher)] = matcherModel =>
-            {
-                var matcherParams = JsonConvert.DeserializeObject<CustomPathParamMatcherModel>((string)matcherModel.Pattern);
-                return new CustomPathParamMatcher(
-                    matcherModel.RejectOnMatch == true ? MatchBehaviour.RejectOnMatch : MatchBehaviour.AcceptOnMatch,
-                    matcherParams.Path, matcherParams.PathParams,
-                    settings.ThrowExceptionWhenMatcherFails == true
-                );
-            };
-            var sut = new MatcherMapper(settings);
+        // Act
+        var matcher = (SimMetricsMatcher)_sut.Map(model)!;
 
-            // Act
-            var matcher = sut.Map(model) as CustomPathParamMatcher;
+        // Assert
+        Check.That(matcher.GetPatterns()).ContainsExactly("x");
+    }
 
-            // Assert
-            matcher.Should().NotBeNull();
-        }
-
-        [Fact]
-        public void MatcherModelMapper_Map_CustomMatcherToMatcherModel()
+    [Fact]
+    public void MatcherModelMapper_Map_SimMetricsMatcher_Throws1()
+    {
+        // Assign
+        var model = new MatcherModel
         {
-            // Arrange
-            var matcher = new CustomPathParamMatcher("/customer/{customerId}/document/{documentId}",
-                new Dictionary<string, string>(2)
-                {
-                    { "customerId", @"^[0-9]+$" },
-                    { "documentId", @"^[0-9a-zA-Z\-\_]+\.[a-zA-Z]+$" }
-                });
+            Name = "error",
+            Pattern = "x"
+        };
 
-            // Act
-            var model = _sut.Map(matcher);
+        // Act
+        Check.ThatCode(() => _sut.Map(model)).Throws<NotSupportedException>();
+    }
 
-            // Assert
-            using (new AssertionScope())
+    [Fact]
+    public void MatcherModelMapper_Map_SimMetricsMatcher_Throws2()
+    {
+        // Assign
+        var model = new MatcherModel
+        {
+            Name = "SimMetricsMatcher.error",
+            Pattern = "x"
+        };
+
+        // Act
+        Check.ThatCode(() => _sut.Map(model)).Throws<NotSupportedException>();
+    }
+
+    [Fact]
+    public void MatcherModelMapper_Map_MatcherModelToCustomMatcher()
+    {
+        // Arrange
+        var patternModel = new CustomPathParamMatcherModel("/customer/{customerId}/document/{documentId}",
+            new Dictionary<string, string>(2)
             {
-                model.Should().NotBeNull();
-                model.Name.Should().Be(nameof(CustomPathParamMatcher));
+                { "customerId", @"^[0-9]+$" },
+                { "documentId", @"^[0-9a-zA-Z\-\_]+\.[a-zA-Z]+$" }
+            });
+        var model = new MatcherModel
+        {
+            Name = nameof(CustomPathParamMatcher),
+            Pattern = JsonConvert.SerializeObject(patternModel)
+        };
 
-                var matcherParams = JsonConvert.DeserializeObject<CustomPathParamMatcherModel>((string)model.Pattern);
-                matcherParams.Path.Should().Be("/customer/{customerId}/document/{documentId}");
-                matcherParams.PathParams.Should().BeEquivalentTo(new Dictionary<string, string>(2)
-                {
-                    { "customerId", @"^[0-9]+$" },
-                    { "documentId", @"^[0-9a-zA-Z\-\_]+\.[a-zA-Z]+$" }
-                });
-            }
+        var settings = new WireMockServerSettings();
+        settings.CustomMatcherMappings = settings.CustomMatcherMappings ?? new Dictionary<string, Func<MatcherModel, IMatcher>>();
+        settings.CustomMatcherMappings[nameof(CustomPathParamMatcher)] = matcherModel =>
+        {
+            var matcherParams = JsonConvert.DeserializeObject<CustomPathParamMatcherModel>((string)matcherModel.Pattern!)!;
+            return new CustomPathParamMatcher(
+                matcherModel.RejectOnMatch == true ? MatchBehaviour.RejectOnMatch : MatchBehaviour.AcceptOnMatch,
+                matcherParams.Path,
+                matcherParams.PathParams,
+                settings.ThrowExceptionWhenMatcherFails == true
+            );
+        };
+        var sut = new MatcherMapper(settings);
+
+        // Act
+        var matcher = sut.Map(model) as CustomPathParamMatcher;
+
+        // Assert
+        matcher.Should().NotBeNull();
+    }
+
+    [Fact]
+    public void MatcherModelMapper_Map_CustomMatcherToMatcherModel()
+    {
+        // Arrange
+        var matcher = new CustomPathParamMatcher("/customer/{customerId}/document/{documentId}",
+            new Dictionary<string, string>(2)
+            {
+                { "customerId", @"^[0-9]+$" },
+                { "documentId", @"^[0-9a-zA-Z\-\_]+\.[a-zA-Z]+$" }
+            });
+
+        // Act
+        var model = _sut.Map(matcher)!;
+
+        // Assert
+        using (new AssertionScope())
+        {
+            model.Should().NotBeNull();
+            model.Name.Should().Be(nameof(CustomPathParamMatcher));
+
+            var matcherParams = JsonConvert.DeserializeObject<CustomPathParamMatcherModel>((string)model.Pattern!)!;
+            matcherParams.Path.Should().Be("/customer/{customerId}/document/{documentId}");
+            matcherParams.PathParams.Should().BeEquivalentTo(new Dictionary<string, string>(2)
+            {
+                { "customerId", @"^[0-9]+$" },
+                { "documentId", @"^[0-9a-zA-Z\-\_]+\.[a-zA-Z]+$" }
+            });
         }
     }
 }

test/WireMock.Net.Tests/WireMock.Net.Tests.csproj

@@ -52,7 +52,7 @@
 
         <PackageReference Include="Moq" Version="4.17.2" />
         <PackageReference Include="System.Threading" Version="4.3.0" />
-        <PackageReference Include="RestEase" Version="1.5.6" />
+        <PackageReference Include="RestEase" Version="1.5.7" />
         <!--<PackageReference Include="RandomDataGenerator.Net" Version="1.0.14" />-->
         <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.5.0" />
         <PackageReference Include="Newtonsoft.Json" Version="13.0.1" />