diff --git a/YamlDotNet.Test/Serialization/BufferedDeserialization/KeyValueTypeDiscriminatorTests.cs b/YamlDotNet.Test/Serialization/BufferedDeserialization/KeyValueTypeDiscriminatorTests.cs
new file mode 100644
index 00000000..cf7f14f6
--- /dev/null
+++ b/YamlDotNet.Test/Serialization/BufferedDeserialization/KeyValueTypeDiscriminatorTests.cs
@@ -0,0 +1,265 @@
+// This file is part of YamlDotNet - A .NET library for YAML.
+// Copyright (c) Antoine Aubry and contributors
+//
+// 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.
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using FluentAssertions;
+using Xunit;
+using YamlDotNet.Core;
+using YamlDotNet.Serialization;
+using YamlDotNet.Serialization.NamingConventions;
+
+namespace YamlDotNet.Test.Serialization.BufferedDeserialization
+{
+    public class KeyValueTypeDiscriminatorTests
+    {
+        [Fact]
+        public void KeyValueTypeDiscriminator_WithParentBaseType_Single()
+        {
+            var bufferedDeserializer = new DeserializerBuilder()
+                .WithNamingConvention(CamelCaseNamingConvention.Instance)
+                .WithTypeDiscriminatingNodeDeserializer(options => {
+                    options.AddKeyValueTypeDiscriminator<KubernetesResource>(
+                        "kind",
+                        new Dictionary<string, Type>()
+                        {
+                            { "Namespace", typeof(KubernetesNamespace) },
+                            { "Service", typeof(KubernetesService) }
+                        });
+                    },
+                    maxDepth: 3,
+                    maxLength: 40)
+                .Build();
+
+            var service = bufferedDeserializer.Deserialize<KubernetesResource>(KubernetesServiceYaml);
+            service.Should().BeOfType<KubernetesService>();
+        }
+
+        [Fact]
+        public void KeyValueTypeDiscriminator_WithParentBaseType_List()
+        {
+            var bufferedDeserializer = new DeserializerBuilder()
+                .WithNamingConvention(CamelCaseNamingConvention.Instance)
+                .WithTypeDiscriminatingNodeDeserializer(options => {
+                    options.AddKeyValueTypeDiscriminator<KubernetesResource>(
+                        "kind",
+                        new Dictionary<string, Type>()
+                        {
+                            { "Namespace", typeof(KubernetesNamespace) },
+                            { "Service", typeof(KubernetesService) }
+                        });
+                    },
+                    maxDepth: 3,
+                    maxLength: 40)
+                .Build();
+
+            var resources = bufferedDeserializer.Deserialize<List<KubernetesResource>>(ListOfKubernetesYaml);
+            resources[0].Should().BeOfType<KubernetesNamespace>();
+            resources[1].Should().BeOfType<KubernetesService>();
+        }
+        
+        [Fact]
+        public void KeyValueTypeDiscriminator_WithObjectBaseType_Single()
+        {
+            var bufferedDeserializer = new DeserializerBuilder()
+                .WithNamingConvention(CamelCaseNamingConvention.Instance)
+                .WithTypeDiscriminatingNodeDeserializer(options => {
+                    options.AddKeyValueTypeDiscriminator<object>(
+                        "kind",
+                        new Dictionary<string, Type>()
+                        {
+                            { "Namespace", typeof(KubernetesNamespace) },
+                            { "Service", typeof(KubernetesService) }
+                        });
+                    },
+                    maxDepth: 3,
+                    maxLength: 40)
+                .Build();
+
+            var service = bufferedDeserializer.Deserialize<object>(KubernetesServiceYaml);
+            service.Should().BeOfType<KubernetesService>();
+        }
+
+        [Fact]
+        public void KeyValueTypeDiscriminator_WithObjectBaseType_List()
+        {
+            var bufferedDeserializer = new DeserializerBuilder()
+                .WithNamingConvention(CamelCaseNamingConvention.Instance)
+                .WithTypeDiscriminatingNodeDeserializer(options => {
+                    options.AddKeyValueTypeDiscriminator<object>(
+                        "kind",
+                        new Dictionary<string, Type>()
+                        {
+                            { "Namespace", typeof(KubernetesNamespace) },
+                            { "Service", typeof(KubernetesService) }
+                        });
+                    },
+                    maxDepth: 3,
+                    maxLength: 30)
+                .Build();
+
+            var resources = bufferedDeserializer.Deserialize<List<object>>(ListOfKubernetesYaml);
+            resources[0].Should().BeOfType<KubernetesNamespace>();
+            resources[1].Should().BeOfType<KubernetesService>();
+        }
+
+        [Fact]
+        public void KeyValueTypeDiscriminator_WithInterfaceBaseType_Single()
+        {
+            var bufferedDeserializer = new DeserializerBuilder()
+                .WithNamingConvention(CamelCaseNamingConvention.Instance)
+                .WithTypeDiscriminatingNodeDeserializer(options => {
+                    options.AddKeyValueTypeDiscriminator<IKubernetesResource>(
+                        "kind",
+                        new Dictionary<string, Type>()
+                        {
+                            { "Namespace", typeof(KubernetesNamespace) },
+                            { "Service", typeof(KubernetesService) }
+                        });
+                    },
+                    maxDepth: 3,
+                    maxLength: 40)
+                .Build();
+
+            var service = bufferedDeserializer.Deserialize<IKubernetesResource>(KubernetesServiceYaml);
+            service.Should().BeOfType<KubernetesService>();
+        }
+
+        [Fact]
+        public void KeyValueTypeDiscriminator_WithInterfaceBaseType_List()
+        {
+            var bufferedDeserializer = new DeserializerBuilder()
+                .WithNamingConvention(CamelCaseNamingConvention.Instance)
+                .WithTypeDiscriminatingNodeDeserializer(options => {
+                    options.AddKeyValueTypeDiscriminator<IKubernetesResource>(
+                        "kind",
+                        new Dictionary<string, Type>()
+                        {
+                            { "Namespace", typeof(KubernetesNamespace) },
+                            { "Service", typeof(KubernetesService) }
+                        });
+                    },
+                    maxDepth: 3,
+                    maxLength: 30)
+                .Build();
+
+            var resources = bufferedDeserializer.Deserialize<List<IKubernetesResource>>(ListOfKubernetesYaml);
+            resources[0].Should().BeOfType<KubernetesNamespace>();
+            resources[1].Should().BeOfType<KubernetesService>();
+        }
+
+        [Fact]
+        public void KeyValueTypeDiscriminator_MultipleWithSameKey()
+        {
+            var bufferedDeserializer = new DeserializerBuilder()
+                .WithNamingConvention(CamelCaseNamingConvention.Instance)
+                .WithTypeDiscriminatingNodeDeserializer(options => {
+                    options.AddKeyValueTypeDiscriminator<KubernetesResource>(
+                        "kind",
+                        new Dictionary<string, Type>()
+                        {
+                            { "Namespace", typeof(KubernetesNamespace) },
+                        });
+                    options.AddKeyValueTypeDiscriminator<KubernetesResource>(
+                        "kind",
+                        new Dictionary<string, Type>()
+                        {
+                            { "Service", typeof(KubernetesService) }
+                        });
+                    },
+                    maxDepth: 3,
+                    maxLength: 40)
+                .Build();
+            
+            var resources = bufferedDeserializer.Deserialize<List<KubernetesResource>>(ListOfKubernetesYaml);
+            resources[0].Should().BeOfType<KubernetesNamespace>();
+            resources[1].Should().BeOfType<KubernetesService>();
+        }
+
+        public const string ListOfKubernetesYaml = @"
+- apiVersion: v1
+  kind: Namespace
+  metadata:
+    name: test-namespace
+- apiVersion: v1
+  kind: Service
+  metadata:
+    name: my-service
+  spec:
+    selector:
+      app.kubernetes.io/name: MyApp
+    ports:
+      - protocol: TCP
+        port: 80
+        targetPort: 9376
+";
+
+        public const string KubernetesServiceYaml = @"
+apiVersion: v1
+kind: Service
+metadata:
+  name: my-service
+spec:
+  selector:
+    app.kubernetes.io/name: MyApp
+  ports:
+    - protocol: TCP
+      port: 80
+      targetPort: 9376
+";
+
+        public interface IKubernetesResource { }
+
+        public class KubernetesResource : IKubernetesResource
+        {
+            public string ApiVersion { get; set; }
+            public string Kind { get; set; }
+            public KubernetesMetadata Metadata { get; set; }
+
+            public class KubernetesMetadata
+            {
+                public string Name { get; set; }
+            }
+        }
+
+        public class KubernetesService : KubernetesResource
+        {
+            public KubernetesServiceSpec Spec { get; set; }
+            public class KubernetesServiceSpec
+            {
+                public Dictionary<string, string> Selector { get; set; }
+                public List<KubernetesServicePort> Ports { get; set; }
+                public class KubernetesServicePort
+                {
+                    public string Protocol { get; set; }
+                    public int Port { get; set; }
+                    public int TargetPort { get; set; }
+                }
+            }
+        }
+
+        public class KubernetesNamespace : KubernetesResource
+        {
+
+        }
+    }
+}
diff --git a/YamlDotNet.Test/Serialization/BufferedDeserialization/TypeDiscriminatingNodeDeserializerTests.cs b/YamlDotNet.Test/Serialization/BufferedDeserialization/TypeDiscriminatingNodeDeserializerTests.cs
new file mode 100644
index 00000000..34ec355f
--- /dev/null
+++ b/YamlDotNet.Test/Serialization/BufferedDeserialization/TypeDiscriminatingNodeDeserializerTests.cs
@@ -0,0 +1,89 @@
+// This file is part of YamlDotNet - A .NET library for YAML.
+// Copyright (c) Antoine Aubry and contributors
+//
+// 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.
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using FluentAssertions;
+using Xunit;
+using YamlDotNet.Core;
+using YamlDotNet.Serialization;
+using YamlDotNet.Serialization.NamingConventions;
+
+namespace YamlDotNet.Test.Serialization.BufferedDeserialization
+{
+    public class TypeDiscriminatingNodeDeserializerTests
+    {
+        [Fact]
+        public void TypeDiscriminatingNodeDeserializer_ThrowsWhen_MaxDepthExceeded()
+        {
+            var bufferedDeserializer = new DeserializerBuilder()
+                .WithNamingConvention(CamelCaseNamingConvention.Instance)
+                .WithTypeDiscriminatingNodeDeserializer(options => {
+                        options.AddKeyValueTypeDiscriminator<object>("kind", new Dictionary<string, Type>());
+                    },
+                    maxDepth: 2,
+                    maxLength: 40)
+                .Build();
+
+            Action act = () => bufferedDeserializer.Deserialize<object>(KubernetesServiceYaml);
+            act
+              .ShouldThrow<YamlException>()
+              .WithMessage("Failed to buffer yaml node")
+              .WithInnerException<ArgumentOutOfRangeException>()
+              .Where(e => e.InnerException.Message.Contains("Parser buffer exceeded max depth"));
+        }
+        
+        [Fact]
+        public void TypeDiscriminatingNodeDeserializer_ThrowsWhen_MaxLengthExceeded()
+        {
+            var bufferedDeserializer = new DeserializerBuilder()
+                .WithNamingConvention(CamelCaseNamingConvention.Instance)
+                .WithTypeDiscriminatingNodeDeserializer(options => {
+                        options.AddKeyValueTypeDiscriminator<object>("kind", new Dictionary<string, Type>());
+                    },
+                    maxDepth: 3,
+                    maxLength: 20)
+                .Build();
+
+            Action act = () => bufferedDeserializer.Deserialize<object>(KubernetesServiceYaml);
+            act
+              .ShouldThrow<YamlException>()
+              .WithMessage("Failed to buffer yaml node")
+              .WithInnerException<ArgumentOutOfRangeException>()
+              .Where(e => e.InnerException.Message.Contains("Parser buffer exceeded max length"));
+        }
+
+        public const string KubernetesServiceYaml = @"
+apiVersion: v1
+kind: Service
+metadata:
+  name: my-service
+spec:
+  selector:
+    app.kubernetes.io/name: MyApp
+  ports:
+    - protocol: TCP
+      port: 80
+      targetPort: 9376
+";
+    }
+}
diff --git a/YamlDotNet.Test/Serialization/BufferedDeserialization/UniqueKeyTypeDiscriminatorTests.cs b/YamlDotNet.Test/Serialization/BufferedDeserialization/UniqueKeyTypeDiscriminatorTests.cs
new file mode 100644
index 00000000..6d26e10c
--- /dev/null
+++ b/YamlDotNet.Test/Serialization/BufferedDeserialization/UniqueKeyTypeDiscriminatorTests.cs
@@ -0,0 +1,103 @@
+// This file is part of YamlDotNet - A .NET library for YAML.
+// Copyright (c) Antoine Aubry and contributors
+//
+// 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.
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using FluentAssertions;
+using Xunit;
+using YamlDotNet.Core;
+using YamlDotNet.Serialization;
+using YamlDotNet.Serialization.NamingConventions;
+
+namespace YamlDotNet.Test.Serialization.BufferedDeserialization
+{
+    public class UniqueKeyTypeDiscriminatorTests
+    {
+        [Fact]
+        public void UniqueKeyTypeDiscriminator_WithInterfaceBaseType()
+        {
+            var bufferedDeserializer = new DeserializerBuilder()
+                .WithNamingConvention(CamelCaseNamingConvention.Instance)
+                .WithTypeDiscriminatingNodeDeserializer(options => {
+                    options.AddUniqueKeyTypeDiscriminator<ICharacter>(
+                        new Dictionary<string, Type>()
+                        {
+                            { "cheeseSupply", typeof(Mouse) },
+                            { "avgDailyMeows", typeof(Cat) }
+                        }
+                    );
+                    },
+                    maxDepth: 3,
+                    maxLength: 10)
+                .Build();
+
+            var characters = bufferedDeserializer.Deserialize<List<ICharacter>>(TomAndJerryYaml);
+            characters[0].Should().BeOfType<Mouse>();
+            characters[1].Should().BeOfType<Cat>();
+        }
+
+        [Fact]
+        public void UniqueKeyTypeDiscriminator_WithObjectBaseType()
+        {
+            var bufferedDeserializer = new DeserializerBuilder()
+                .WithNamingConvention(CamelCaseNamingConvention.Instance)
+                .WithTypeDiscriminatingNodeDeserializer(options => {
+                    options.AddUniqueKeyTypeDiscriminator<object>(
+                        new Dictionary<string, Type>()
+                        {
+                            { "cheeseSupply", typeof(Mouse) },
+                            { "avgDailyMeows", typeof(Cat) }
+                        }
+                    );
+                    },
+                    maxDepth: 3,
+                    maxLength: 10)
+                .Build();
+
+            var charactersObj = bufferedDeserializer.Deserialize<object>(TomAndJerryYaml);
+            var characters = (List<object>)charactersObj;
+            characters[0].Should().BeOfType<Mouse>();
+            characters[1].Should().BeOfType<Cat>();
+        }
+
+        public const string TomAndJerryYaml = @"
+- name: Jerry
+  cheeseSupply: 5
+- name: Tom
+  avgDailyMeows: 20.0
+";
+
+        public interface ICharacter { }
+
+        public class Mouse : ICharacter
+        {
+            public string Name { get; set; }
+            public int CheeseSupply { get; set; }
+        }
+
+        public class Cat : ICharacter
+        {
+            public string Name { get; set; }
+            public float AvgDailyMeows { get; set; }
+        }
+    }
+}
diff --git a/YamlDotNet/Core/ParserExtensions.cs b/YamlDotNet/Core/ParserExtensions.cs
index 674de2bd..b94e875a 100644
--- a/YamlDotNet/Core/ParserExtensions.cs
+++ b/YamlDotNet/Core/ParserExtensions.cs
@@ -147,5 +147,71 @@ public static bool Accept<T>(this IParser parser) where T : ParsingEvent
         {
             return Accept<T>(parser, out var _);
         }
+
+        /// <summary>
+        /// Attempts to find a key on a YAML mapping that matches our predicate.
+        /// This is useful for scanning a mapping for type discriminator information.
+        /// For example: looking for a `kind` key on an object.
+        ///
+        /// This function only checks mappings, and only looks at the current depth.
+        ///
+        /// If the event is a mapping and has a key that satisfies the predicate the scan 
+        /// will stop, return true, and set <paramref name="key" /> and
+        /// <paramref name="value" />. All events up until the predicate is matched will
+        /// be consumed.
+        ///
+        /// If the event is not a mapping event or a matching key is not found, returns false.
+        /// </summary>
+        /// <param name="parser">The IParser which will have its current value checked for a matching mapping entry</param>
+        /// <param name="selector">The selector to filter the mapping by</param>
+        /// <param name="key">The matching key of the mapping as a Scalar, or null if no matching key found</param>
+        /// <param name="value">The matching value of the mapping as a ParsingEvent, or null if no matching key found</param>
+        /// <returns>Returns true if the current event is a mapping entry with a key that matches the selector;
+        /// otherwise returns false.</returns>
+        public static bool TryFindMappingEntry(this IParser parser, Func<Scalar, bool> selector, [MaybeNullWhen(false)] out Scalar? key, [MaybeNullWhen(false)] out ParsingEvent? value)
+        {
+            if (parser.TryConsume<MappingStart>(out var _start))
+            {
+                while (parser.Current != null)
+                {
+                    // so we only want to check keys in this mapping, don't descend
+                    switch (parser.Current)
+                    {
+                        case Scalar scalar:
+                            // we've found a scalar, check if it's value matches our predicate
+                            var keyMatched = selector(scalar);
+
+                            // move head so we can read or skip value
+                            parser.MoveNext();
+
+                            // read the value of the mapping key
+                            if (keyMatched)
+                            {
+                                // success
+                                value = parser.Current;
+                                key = scalar;
+                                return true;
+                            }
+
+                            // skip the value
+                            parser.SkipThisAndNestedEvents();
+
+                            break;
+                        case MappingStart _:
+                        case SequenceStart _:
+                            parser.SkipThisAndNestedEvents();
+                            break;
+                        default:
+                            // do nothing, skip to next node
+                            parser.MoveNext();
+                            break;
+                    }
+                }
+            }
+
+            key = null;
+            value = null;
+            return false;
+        }
     }
 }
diff --git a/YamlDotNet/Serialization/BufferedDeserialization/ITypeDiscriminatingNodeDeserializerOptions.cs b/YamlDotNet/Serialization/BufferedDeserialization/ITypeDiscriminatingNodeDeserializerOptions.cs
new file mode 100644
index 00000000..a8678dba
--- /dev/null
+++ b/YamlDotNet/Serialization/BufferedDeserialization/ITypeDiscriminatingNodeDeserializerOptions.cs
@@ -0,0 +1,47 @@
+// This file is part of YamlDotNet - A .NET library for YAML.
+// Copyright (c) Antoine Aubry and contributors
+//
+// 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.
+
+using System;
+using System.Linq;
+using System.Collections.Generic;
+using YamlDotNet.Serialization;
+using YamlDotNet.Serialization.NamingConventions;
+using YamlDotNet.Serialization.NodeDeserializers;
+using YamlDotNet.Serialization.BufferedDeserialization.TypeDiscriminators;
+
+namespace YamlDotNet.Serialization.BufferedDeserialization
+{
+    public interface ITypeDiscriminatingNodeDeserializerOptions
+    {
+        public void AddTypeDiscriminator(ITypeDiscriminator discriminator);
+        public void AddKeyValueTypeDiscriminator<T>(string discriminatorKey, IDictionary<string, Type> valueTypeMapping);
+
+#if NET7_0_OR_GREATER
+        public void AddKeyValueTypeDiscriminator<T>(string discriminatorKey, params (string, Type)[] valueTypeMapping) => AddKeyValueTypeDiscriminator<T>(discriminatorKey, valueTypeMapping.ToDictionary(kvp => kvp.Item1, kvp => kvp.Item2));
+#endif
+
+        public void AddUniqueKeyTypeDiscriminator<T>(IDictionary<string, Type> uniqueKeyTypeMapping);
+
+#if NET7_0_OR_GREATER
+        public void AddUniqueKeyTypeDiscriminator<T>(params (string, Type)[] uniqueKeyTypeMapping) => AddUniqueKeyTypeDiscriminator<T>(uniqueKeyTypeMapping.ToDictionary(kvp => kvp.Item1, kvp => kvp.Item2));
+#endif
+    }
+}
\ No newline at end of file
diff --git a/YamlDotNet/Serialization/BufferedDeserialization/ParserBuffer.cs b/YamlDotNet/Serialization/BufferedDeserialization/ParserBuffer.cs
new file mode 100644
index 00000000..2128f7f5
--- /dev/null
+++ b/YamlDotNet/Serialization/BufferedDeserialization/ParserBuffer.cs
@@ -0,0 +1,92 @@
+// This file is part of YamlDotNet - A .NET library for YAML.
+// Copyright (c) Antoine Aubry and contributors
+//
+// 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.
+
+using System;
+using System.Collections.Generic;
+using YamlDotNet.Core;
+using YamlDotNet.Core.Events;
+
+namespace YamlDotNet.Serialization.BufferedDeserialization
+{
+    /// <summary>
+    /// Wraps a <see cref="IParser"/> instance and allows it to be buffered as a LinkedList in memory and replayed.
+    /// </summary>
+    public class ParserBuffer : IParser
+    {
+        private readonly LinkedList<ParsingEvent> buffer;
+
+        private LinkedListNode<ParsingEvent>? current;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="ParserBuffer"/> class.
+        /// </summary>
+        /// <param name="parserToBuffer">The Parser to buffer.</param>
+        /// <param name="maxDepth">The maximum depth of the parser to buffer before raising an ArgumentOutOfRangeException.</param>
+        /// <param name="maxLength">The maximum length of the LinkedList can buffer before raising an ArgumentOutOfRangeException.</param>
+        /// <exception cref="ArgumentOutOfRangeException">If parser does not fit within the max depth and length specified.</exception>
+        public ParserBuffer(IParser parserToBuffer, int maxDepth, int maxLength)
+        {
+            buffer = new LinkedList<ParsingEvent>();
+            buffer.AddLast(parserToBuffer.Consume<MappingStart>());
+            var depth = 0;
+            do
+            {
+                var next = parserToBuffer.Consume<ParsingEvent>();
+                depth += next.NestingIncrease;
+                buffer.AddLast(next);
+
+                if (maxDepth > -1 && depth > maxDepth)
+                {
+                    throw new ArgumentOutOfRangeException(nameof(parserToBuffer), "Parser buffer exceeded max depth");
+                }
+                if (maxLength > -1 && buffer.Count > maxLength)
+                {
+                    throw new ArgumentOutOfRangeException(nameof(parserToBuffer), "Parser buffer exceeded max length");
+                }
+            } while (depth >= 0);
+
+            current = buffer.First;
+        }
+
+        /// <summary>
+        /// Gets the current event. Returns null after <see cref="MoveNext" /> returns false.
+        /// </summary>
+        public ParsingEvent? Current => current?.Value;
+
+        /// <summary>
+        /// Moves to the next event.
+        /// </summary>
+        /// <returns>Returns true if there are more events available, otherwise returns false.</returns>
+        public bool MoveNext()
+        {
+            current = current?.Next;
+            return current != null;
+        }
+
+        /// <summary>
+        /// Resets the buffer back to it's first event.
+        /// </summary>
+        public void Reset()
+        {
+            current = buffer.First;
+        }
+    }
+}
\ No newline at end of file
diff --git a/YamlDotNet/Serialization/BufferedDeserialization/TypeDiscriminatingNodeDeserializer.cs b/YamlDotNet/Serialization/BufferedDeserialization/TypeDiscriminatingNodeDeserializer.cs
new file mode 100644
index 00000000..5c0466ba
--- /dev/null
+++ b/YamlDotNet/Serialization/BufferedDeserialization/TypeDiscriminatingNodeDeserializer.cs
@@ -0,0 +1,120 @@
+// This file is part of YamlDotNet - A .NET library for YAML.
+// Copyright (c) Antoine Aubry and contributors
+//
+// 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.
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using YamlDotNet.Core;
+using YamlDotNet.Core.Events;
+using YamlDotNet.Serialization;
+using YamlDotNet.Serialization.NodeDeserializers;
+using YamlDotNet.Serialization.BufferedDeserialization.TypeDiscriminators;
+
+namespace YamlDotNet.Serialization.BufferedDeserialization
+{
+    /// <summary>
+    /// The TypeDiscriminatingNodeDeserializer acts as a psuedo <see cref="INodeDeserializer" />.
+    /// If any of it's <see cref="ITypeDiscriminator" /> has a matching BaseType, the TypeDiscriminatingNodeDeserializer will
+    /// begin buffering the yaml stream. It will then use the matching <see cref="ITypeDiscriminator" />s to determine
+    /// a dotnet output type for the yaml node. As the node is buffered, the <see cref="ITypeDiscriminator" />s are
+    /// able to examine the actual values within, and use these when discriminating a type.
+    /// Once a matching type is found, the TypeDiscriminatingNodeDeserializer uses it's inner deserializers to perform
+    /// the final deserialization for that type &amp; object.
+    /// Usually you will want all default <see cref="INodeDeserializer" />s that exist in the outer
+    /// <see cref="Deserializer" /> to also be used as inner deserializers.
+    /// </summary>
+    public class TypeDiscriminatingNodeDeserializer : INodeDeserializer
+    {
+        private readonly IList<INodeDeserializer> innerDeserializers;
+        private readonly IList<ITypeDiscriminator> typeDiscriminators;
+        private readonly int maxDepthToBuffer;
+        private readonly int maxLengthToBuffer;
+
+        public TypeDiscriminatingNodeDeserializer(IList<INodeDeserializer> innerDeserializers, IList<ITypeDiscriminator> typeDiscriminators, int maxDepthToBuffer, int maxLengthToBuffer)
+        {
+            this.innerDeserializers = innerDeserializers;
+            this.typeDiscriminators = typeDiscriminators;
+            this.maxDepthToBuffer = maxDepthToBuffer;
+            this.maxLengthToBuffer = maxLengthToBuffer;
+        }
+
+        public bool Deserialize(IParser reader, Type expectedType, Func<IParser, Type, object?> nestedObjectDeserializer, out object? value)
+        {
+            if (!reader.Accept<MappingStart>(out var mapping))
+            {
+                value = null;
+                return false;
+            }
+
+            // Can any of the registered discriminators deal with the expected type?
+            var possibleDiscriminators = typeDiscriminators.Where(t => t.BaseType.IsAssignableFrom(expectedType));
+            if (!possibleDiscriminators.Any())
+            {
+                value = null;
+                return false;
+            }
+
+            // Now buffer all the nodes in this mapping
+            var start = reader.Current!.Start;
+            Type actualType = expectedType;
+            ParserBuffer buffer;
+            try
+            {
+                buffer = new ParserBuffer(reader, maxDepth: maxDepthToBuffer, maxLength: maxLengthToBuffer);
+            }
+            catch (Exception exception)
+            {
+                throw new YamlException(start, reader.Current.End, "Failed to buffer yaml node", exception);
+            }
+
+            try
+            {
+                // use the discriminator to tell us what type it is really expecting by letting it inspect the parsing events
+                foreach (var discriminator in possibleDiscriminators)
+                {
+                    buffer.Reset();
+                    if (discriminator.TryDiscriminate(buffer, out var descriminatedType))
+                    {
+                        actualType = descriminatedType!;
+                        break;
+                    }
+                }
+            }
+            catch (Exception exception)
+            {
+                throw new YamlException(start, reader.Current.End, "Failed to discriminate type", exception);
+            }
+
+            // now continue by re-emitting parsing events and using the inner deserializers to handle
+            buffer.Reset();
+            foreach (var deserializer in innerDeserializers)
+            {
+                if (deserializer.Deserialize(buffer, actualType, nestedObjectDeserializer, out value))
+                {
+                    return true;
+                }
+            }
+
+            value = null;
+            return false;
+        }
+    }
+}
\ No newline at end of file
diff --git a/YamlDotNet/Serialization/BufferedDeserialization/TypeDiscriminatingNodeDeserializerOptions.cs b/YamlDotNet/Serialization/BufferedDeserialization/TypeDiscriminatingNodeDeserializerOptions.cs
new file mode 100644
index 00000000..7cec41d3
--- /dev/null
+++ b/YamlDotNet/Serialization/BufferedDeserialization/TypeDiscriminatingNodeDeserializerOptions.cs
@@ -0,0 +1,67 @@
+// This file is part of YamlDotNet - A .NET library for YAML.
+// Copyright (c) Antoine Aubry and contributors
+//
+// 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.
+
+using System;
+using System.Collections.Generic;
+using YamlDotNet.Serialization;
+using YamlDotNet.Serialization.NamingConventions;
+using YamlDotNet.Serialization.NodeDeserializers;
+using YamlDotNet.Serialization.BufferedDeserialization.TypeDiscriminators;
+
+namespace YamlDotNet.Serialization.BufferedDeserialization
+{
+    public class TypeDiscriminatingNodeDeserializerOptions : ITypeDiscriminatingNodeDeserializerOptions
+    {
+        internal readonly List<ITypeDiscriminator> discriminators = new List<ITypeDiscriminator>();
+
+        /// <summary>
+        /// Adds an <see cref="ITypeDiscriminator" /> to be checked by the TypeDiscriminatingNodeDeserializer.
+        /// </summary>
+        /// <param name="discriminator">The <see cref="ITypeDiscriminator" /> to add.</param>
+        public void AddTypeDiscriminator(ITypeDiscriminator discriminator)
+        {
+            this.discriminators.Add(discriminator);
+        }
+
+        /// <summary>
+        /// Adds a <see cref="KeyValueTypeDiscriminator" /> to be checked by the TypeDiscriminatingNodeDeserializer.
+        /// <see cref="KeyValueTypeDiscriminator" />s use the value of a specified key on the yaml object to map
+        /// to a target type.
+        /// </summary>
+        /// <param name="discriminatorKey">The yaml key to discriminate on.</param>
+        /// <param name="valueTypeMapping">A dictionary of values for the yaml key mapping to their respective types.</param>
+        public void AddKeyValueTypeDiscriminator<T>(string discriminatorKey, IDictionary<string, Type> valueTypeMapping)
+        {
+            this.discriminators.Add(new KeyValueTypeDiscriminator(typeof(T), discriminatorKey, valueTypeMapping));
+        }
+
+        /// <summary>
+        /// Adds a <see cref="UniqueKeyTypeDiscriminator" /> to be checked by the TypeDiscriminatingNodeDeserializer.
+        /// <see cref="UniqueKeyTypeDiscriminator" />s use the presence of unique keys on the yaml object to map
+        /// to different target types.
+        /// </summary>
+        /// <param name="uniqueKeyTypeMapping">A dictionary of unique yaml keys mapping to their respective types.</param>
+        public void AddUniqueKeyTypeDiscriminator<T>(IDictionary<string, Type> uniqueKeyTypeMapping)
+        {
+            this.discriminators.Add(new UniqueKeyTypeDiscriminator(typeof(T), uniqueKeyTypeMapping));
+        }
+    }
+}
\ No newline at end of file
diff --git a/YamlDotNet/Serialization/BufferedDeserialization/TypeDiscriminators/IValueTypeDiscriminator.cs b/YamlDotNet/Serialization/BufferedDeserialization/TypeDiscriminators/IValueTypeDiscriminator.cs
new file mode 100644
index 00000000..5f5e0598
--- /dev/null
+++ b/YamlDotNet/Serialization/BufferedDeserialization/TypeDiscriminators/IValueTypeDiscriminator.cs
@@ -0,0 +1,51 @@
+// This file is part of YamlDotNet - A .NET library for YAML.
+// Copyright (c) Antoine Aubry and contributors
+//
+// 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.
+
+using System;
+using YamlDotNet.Core;
+
+namespace YamlDotNet.Serialization.BufferedDeserialization.TypeDiscriminators
+{
+    /// <summary>
+    /// An ITypeDiscriminator provides an interface for discriminating which dotnet type to deserialize a yaml
+    /// stream into. They require the yaml stream to be buffered <see cref="TypeDiscriminatingNodeDeserializer" /> as they
+    /// can inspect the yaml value, determine the desired type, and reset the yaml stream to then deserialize into
+    /// that type.
+    /// </summary>
+    public interface ITypeDiscriminator
+    {
+        /// <summary>
+        /// Gets the BaseType of the discriminator. All types that an ITypeDiscriminator may discriminate into must
+        /// inherit from this type. This enables the deserializer to only buffer values of matching types.
+        /// If you would like an ITypeDiscriminator to discriminate all yaml values, the BaseType will be object.
+        /// </summary>
+        Type BaseType { get; }
+
+        /// <summary>
+        /// Trys to discriminate a type from the current IParser. As discriminating the type will consume the parser, the
+        /// parser will usually need to be a buffer so an instance of the discriminated type can be deserialized later.
+        /// </summary>
+        /// <param name="buffer">The IParser to consume and discriminate a type from.</param>
+        /// <param name="suggestedType">The output type discriminated. Null if no type matched the discriminator.</param>
+        /// <returns>Returns true if the discriminator matched the yaml stream.</returns>
+        bool TryDiscriminate(IParser buffer, out Type? suggestedType);
+    }
+}
\ No newline at end of file
diff --git a/YamlDotNet/Serialization/BufferedDeserialization/TypeDiscriminators/KeyValueTypeDiscriminator.cs b/YamlDotNet/Serialization/BufferedDeserialization/TypeDiscriminators/KeyValueTypeDiscriminator.cs
new file mode 100644
index 00000000..3006304a
--- /dev/null
+++ b/YamlDotNet/Serialization/BufferedDeserialization/TypeDiscriminators/KeyValueTypeDiscriminator.cs
@@ -0,0 +1,96 @@
+// This file is part of YamlDotNet - A .NET library for YAML.
+// Copyright (c) Antoine Aubry and contributors
+//
+// 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.
+
+using System;
+using System.Linq;
+using System.Collections.Generic;
+using YamlDotNet.Core;
+using YamlDotNet.Core.Events;
+using YamlDotNet.Serialization;
+
+namespace YamlDotNet.Serialization.BufferedDeserialization.TypeDiscriminators
+{
+    /// <summary>
+    /// A TypeDiscriminator that discriminates which type to deserialize a yaml stream into by checking the value
+    /// of a known key.
+    /// </summary>
+    public class KeyValueTypeDiscriminator : ITypeDiscriminator
+    {
+        public Type BaseType { get; private set; }
+        private readonly string targetKey;
+        private readonly IDictionary<string, Type> typeMapping;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="KeyValueTypeDiscriminator"/> class.
+        /// The KeyValueTypeDiscriminator will check the target key specified, and if it's value is contained within the
+        /// type mapping dictionary, the coresponding type will be discriminated.
+        /// </summary>
+        /// <param name="baseType">The base type which all discriminated types will implement. Use object if you're discriminating
+        /// unrelated types. Note the less specific you are with the base type the more yaml will need to be buffered.</param>
+        /// <param name="targetKey">The known key to check the value of when discriminating.</param>
+        /// <param name="typeMapping">A mapping dictionary of yaml values to types.</param>
+        /// <exception cref="ArgumentOutOfRangeException">If any of the target types do not implement the base type.</exception>
+        public KeyValueTypeDiscriminator(Type baseType, string targetKey, IDictionary<string, Type> typeMapping)
+        {
+            foreach (var keyValuePair in typeMapping)
+            {
+                if (!baseType.IsAssignableFrom(keyValuePair.Value))
+                {
+                    throw new ArgumentOutOfRangeException(nameof(typeMapping), $"{keyValuePair.Value} is not a assignable to {baseType}");
+                }
+            }
+            this.BaseType = baseType;
+            this.targetKey = targetKey;
+            this.typeMapping = typeMapping;
+        }
+
+        /// <summary>
+        /// Checks if the current parser contains the target key, and that it's value matches one of the type mappings.
+        /// If so, return true, and the matching type.
+        /// Otherwise, return false.
+        /// This will consume the parser, so you will usually need the parser to be a buffer so an instance 
+        /// of the discriminated type can be deserialized later.
+        /// </summary>
+        /// <param name="parser">The IParser to consume and discriminate a type from.</param>
+        /// <param name="suggestedType">The output type discriminated. Null if there target key was not present of if the value
+        /// of the target key was not within the type mapping.</param>
+        /// <returns>Returns true if the discriminator matched the yaml stream.</returns>
+        public bool TryDiscriminate(IParser parser, out Type? suggestedType)
+        {
+            if (parser.TryFindMappingEntry(
+                scalar => targetKey == scalar.Value,
+                out Scalar? key,
+                out ParsingEvent? value))
+            {
+                // read the value of the discriminator key
+                if (value is Scalar valueScalar && typeMapping.TryGetValue(valueScalar.Value, out var childType))
+                {
+                    suggestedType = childType;
+                    return true;
+                }
+            }
+
+            // we could not find our key, thus we could not determine correct child type
+            suggestedType = null;
+            return false;
+        }
+    }
+}
\ No newline at end of file
diff --git a/YamlDotNet/Serialization/BufferedDeserialization/TypeDiscriminators/UniqueKeyTypeDiscriminator.cs b/YamlDotNet/Serialization/BufferedDeserialization/TypeDiscriminators/UniqueKeyTypeDiscriminator.cs
new file mode 100644
index 00000000..cd96c3c1
--- /dev/null
+++ b/YamlDotNet/Serialization/BufferedDeserialization/TypeDiscriminators/UniqueKeyTypeDiscriminator.cs
@@ -0,0 +1,88 @@
+// This file is part of YamlDotNet - A .NET library for YAML.
+// Copyright (c) Antoine Aubry and contributors
+//
+// 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.
+
+using System;
+using System.Linq;
+using System.Collections.Generic;
+using YamlDotNet.Core;
+using YamlDotNet.Core.Events;
+using YamlDotNet.Serialization;
+
+namespace YamlDotNet.Serialization.BufferedDeserialization.TypeDiscriminators
+{
+    /// <summary>
+    /// A TypeDiscriminator that discriminates which type to deserialize a yaml stream into by checking the existence
+    /// of specific keys.
+    /// </summary>
+    public class UniqueKeyTypeDiscriminator : ITypeDiscriminator
+    {
+        public Type BaseType { get; private set; }
+
+        private readonly IDictionary<string, Type> typeMapping;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="UniqueKeyTypeDiscriminator"/> class.
+        /// The UniqueKeyTypeDiscriminator will check if any of the keys specified exist, and discriminate the coresponding type.
+        /// </summary>
+        /// <param name="baseType">The base type which all discriminated types will implement. Use object if you're discriminating
+        /// unrelated types. Note the less specific you are with the base type the more yaml will need to be buffered.</param>
+        /// <param name="typeMapping">A mapping dictionary of yaml keys to types.</param>
+        /// <exception cref="ArgumentOutOfRangeException">If any of the target types do not implement the base type.</exception>
+        public UniqueKeyTypeDiscriminator(Type baseType, IDictionary<string, Type> typeMapping)
+        {
+            foreach (var keyValuePair in typeMapping)
+            {
+                if (!baseType.IsAssignableFrom(keyValuePair.Value))
+                {
+                    throw new ArgumentOutOfRangeException(nameof(typeMapping), $"{keyValuePair.Value} is not a assignable to {baseType}");
+                }
+            }
+            this.BaseType = baseType;
+            this.typeMapping = typeMapping;
+        }
+
+        /// <summary>
+        /// Checks if the current parser contains of the unique keys this discriminator has in it's type mapping.
+        /// If so, return true, and the matching type.
+        /// Otherwise, return false.
+        /// This will consume the parser, so you will usually need the parser to be a buffer so an instance 
+        /// of the discriminated type can be deserialized later.
+        /// </summary>
+        /// <param name="parser">The IParser to consume and discriminate a type from.</param>
+        /// <param name="suggestedType">The output type discriminated. Null if there target key was not present of if the value
+        /// of the target key was not within the type mapping.</param>
+        /// <returns>Returns true if the discriminator matched the yaml stream.</returns>
+        public bool TryDiscriminate(IParser parser, out Type? suggestedType)
+        {
+            if (parser.TryFindMappingEntry(
+                scalar => this.typeMapping.ContainsKey(scalar.Value),
+                out Scalar key,
+                out ParsingEvent _))
+            {
+                suggestedType = this.typeMapping[key.Value];
+                return true;
+            }
+
+            suggestedType = null;
+            return false;
+        }
+    }
+}
\ No newline at end of file
diff --git a/YamlDotNet/Serialization/DeserializerBuilder.cs b/YamlDotNet/Serialization/DeserializerBuilder.cs
index 6cbc3efa..5fafb145 100755
--- a/YamlDotNet/Serialization/DeserializerBuilder.cs
+++ b/YamlDotNet/Serialization/DeserializerBuilder.cs
@@ -25,6 +25,7 @@
 using System.Diagnostics.CodeAnalysis;
 #endif
 using YamlDotNet.Core;
+using YamlDotNet.Serialization.BufferedDeserialization;
 using YamlDotNet.Serialization.NamingConventions;
 using YamlDotNet.Serialization.NodeDeserializers;
 using YamlDotNet.Serialization.NodeTypeResolvers;
@@ -246,6 +247,28 @@ public DeserializerBuilder WithoutNodeDeserializer(Type nodeDeserializerType)
             return this;
         }
 
+        /// <summary>
+        /// Registers a <see cref="TypeDiscriminatingNodeDeserializer" /> to be used by the deserializer. This internally registers
+        /// all existing <see cref="INodeDeserializer" /> as inner deserializers available to the <see cref="TypeDiscriminatingNodeDeserializer" />.
+        /// Usually you will want to call this after any other changes to the <see cref="INodeDeserializer" />s used by the deserializer.
+        /// </summary>
+        /// <param name="configureTypeDiscriminatingNodeDeserializerOptions">An action that can configure the <see cref="TypeDiscriminatingNodeDeserializer" />.</param>
+        /// <param name="maxDepth">Configures the max depth of yaml nodes that will be buffered. A value of -1 (the default) means yaml nodes of any depth will be buffered.</param>
+        /// <param name="maxLength">Configures the max number of yaml nodes that will be buffered. A value of -1 (the default) means there is no limit on the number of yaml nodes buffered.</param>
+        public DeserializerBuilder WithTypeDiscriminatingNodeDeserializer(
+            Action<ITypeDiscriminatingNodeDeserializerOptions> configureTypeDiscriminatingNodeDeserializerOptions, int maxDepth = -1, int maxLength = -1)
+        {
+            var options = new TypeDiscriminatingNodeDeserializerOptions();
+            configureTypeDiscriminatingNodeDeserializerOptions(options);
+            // We use all current NodeDeserializers as the inner deserializers for the TypeDiscriminatingNodeDeserializer,
+            // so that it can successfully deserialize anything our root deserializer can.
+            var typeDiscriminatingNodeDeserializer = new TypeDiscriminatingNodeDeserializer(nodeDeserializerFactories.BuildComponentList(), options.discriminators, maxDepth, maxLength);
+
+            // We register this before the DictionaryNodeDeserializer, as otherwise it will take precedence
+            // and cases where BaseType = object will not reach the TypeDiscriminatingNodeDeserializer
+            return WithNodeDeserializer(typeDiscriminatingNodeDeserializer, s => s.Before<DictionaryNodeDeserializer>());
+        }
+
         /// <summary>
         /// Registers an additional <see cref="INodeTypeResolver" /> to be used by the deserializer.
         /// </summary>
diff --git a/YamlDotNet/Serialization/StaticDeserializerBuilder.cs b/YamlDotNet/Serialization/StaticDeserializerBuilder.cs
index cbb51ff6..a763ff48 100644
--- a/YamlDotNet/Serialization/StaticDeserializerBuilder.cs
+++ b/YamlDotNet/Serialization/StaticDeserializerBuilder.cs
@@ -25,6 +25,7 @@
 using System.Diagnostics.CodeAnalysis;
 #endif
 using YamlDotNet.Core;
+using YamlDotNet.Serialization.BufferedDeserialization;
 using YamlDotNet.Serialization.NamingConventions;
 using YamlDotNet.Serialization.NodeDeserializers;
 using YamlDotNet.Serialization.NodeTypeResolvers;
@@ -205,6 +206,28 @@ public StaticDeserializerBuilder WithoutNodeDeserializer(Type nodeDeserializerTy
             return this;
         }
 
+        /// <summary>
+        /// Registers a <see cref="TypeDiscriminatingNodeDeserializer" /> to be used by the deserializer. This internally registers
+        /// all existing <see cref="INodeDeserializer" /> as inner deserializers available to the <see cref="TypeDiscriminatingNodeDeserializer" />.
+        /// Usually you will want to call this after any other changes to the <see cref="INodeDeserializer" />s used by the deserializer.
+        /// </summary>
+        /// <param name="configureTypeDiscriminatingNodeDeserializerOptions">An action that can configure the <see cref="TypeDiscriminatingNodeDeserializer" />.</param>
+        /// <param name="maxDepth">Configures the max depth of yaml nodes that will be buffered. A value of -1 (the default) means yaml nodes of any depth will be buffered.</param>
+        /// <param name="maxLength">Configures the max number of yaml nodes that will be buffered. A value of -1 (the default) means there is no limit on the number of yaml nodes buffered.</param>
+        public StaticDeserializerBuilder WithTypeDiscriminatingNodeDeserializer(
+            Action<ITypeDiscriminatingNodeDeserializerOptions> configureTypeDiscriminatingNodeDeserializerOptions, int maxDepth = -1, int maxLength = -1)
+        {
+            var options = new TypeDiscriminatingNodeDeserializerOptions();
+            configureTypeDiscriminatingNodeDeserializerOptions(options);
+            // We use all current NodeDeserializers as the inner deserializers for the TypeDiscriminatingNodeDeserializer,
+            // so that it can successfully deserialize anything our root deserializer can.
+            var typeDiscriminatingNodeDeserializer = new TypeDiscriminatingNodeDeserializer(nodeDeserializerFactories.BuildComponentList(), options.discriminators, maxDepth, maxLength);
+
+            // We register this before the DictionaryNodeDeserializer, as otherwise it will take precedence
+            // and cases where BaseType = object will not reach the TypeDiscriminatingNodeDeserializer
+            return WithNodeDeserializer(typeDiscriminatingNodeDeserializer, s => s.Before<DictionaryNodeDeserializer>());
+        }
+
         /// <summary>
         /// Registers an additional <see cref="INodeTypeResolver" /> to be used by the deserializer.
         /// </summary>