diff --git a/dotnet/src/webdriver/DriverOptions.cs b/dotnet/src/webdriver/DriverOptions.cs
index 483ceb03130a4..555a78d7a3a51 100644
--- a/dotnet/src/webdriver/DriverOptions.cs
+++ b/dotnet/src/webdriver/DriverOptions.cs
@@ -26,44 +26,6 @@
 
 namespace OpenQA.Selenium;
 
-/// <summary>
-/// Specifies the behavior of handling unexpected alerts in the IE driver.
-/// </summary>
-public enum UnhandledPromptBehavior
-{
-    /// <summary>
-    /// Indicates the behavior is not set.
-    /// </summary>
-    Default,
-
-    /// <summary>
-    /// Ignore unexpected alerts, such that the user must handle them.
-    /// </summary>
-    Ignore,
-
-    /// <summary>
-    /// Accept unexpected alerts.
-    /// </summary>
-    Accept,
-
-    /// <summary>
-    /// Dismiss unexpected alerts.
-    /// </summary>
-    Dismiss,
-
-    /// <summary>
-    /// Accepts unexpected alerts and notifies the user that the alert has
-    /// been accepted by throwing an <see cref="UnhandledAlertException"/>
-    /// </summary>
-    AcceptAndNotify,
-
-    /// <summary>
-    /// Dismisses unexpected alerts and notifies the user that the alert has
-    /// been dismissed by throwing an <see cref="UnhandledAlertException"/>
-    /// </summary>
-    DismissAndNotify
-}
-
 /// <summary>
 /// Specifies the behavior of waiting for page loads in the driver.
 /// </summary>
@@ -164,7 +126,7 @@ protected DriverOptions()
     /// Gets or sets the value for describing how unexpected alerts are to be handled in the browser.
     /// Defaults to <see cref="UnhandledPromptBehavior.Default"/>.
     /// </summary>
-    public UnhandledPromptBehavior UnhandledPromptBehavior { get; set; } = UnhandledPromptBehavior.Default;
+    public UnhandledPromptBehaviorOption? UnhandledPromptBehavior { get; set; }
 
     /// <summary>
     /// Gets or sets the value for describing how the browser is to wait for pages to load in the browser.
@@ -303,7 +265,7 @@ public virtual DriverOptionsMergeResult GetMergeResult(DriverOptions other)
             return result;
         }
 
-        if (this.UnhandledPromptBehavior != UnhandledPromptBehavior.Default && other.UnhandledPromptBehavior != UnhandledPromptBehavior.Default)
+        if (this.UnhandledPromptBehavior is not null && other.UnhandledPromptBehavior is not null)
         {
             result.IsMergeConflict = true;
             result.MergeConflictOptionName = "UnhandledPromptBehavior";
@@ -508,29 +470,55 @@ protected IWritableCapabilities GenerateDesiredCapabilities(bool isSpecification
             capabilities.SetCapability(CapabilityType.PageLoadStrategy, pageLoadStrategySetting);
         }
 
-        if (this.UnhandledPromptBehavior != UnhandledPromptBehavior.Default)
+        static string UnhandledPromptBehaviorToString(UnhandledPromptBehavior behavior) => behavior switch
+        {
+            Selenium.UnhandledPromptBehavior.Ignore => "ignore",
+            Selenium.UnhandledPromptBehavior.Accept => "accept",
+            Selenium.UnhandledPromptBehavior.Dismiss => "dismiss",
+            Selenium.UnhandledPromptBehavior.AcceptAndNotify => "accept and notify",
+            Selenium.UnhandledPromptBehavior.DismissAndNotify => "dismiss and notify",
+            _ => throw new ArgumentOutOfRangeException(nameof(behavior), $"UnhandledPromptBehavior value '{behavior}' is not recognized."),
+        };
+
+        if (this.UnhandledPromptBehavior is UnhandledPromptBehaviorSingleOption singleOption && singleOption.Value != Selenium.UnhandledPromptBehavior.Default)
+        {
+            var stringValue = UnhandledPromptBehaviorToString(singleOption.Value);
+
+            capabilities.SetCapability(CapabilityType.UnhandledPromptBehavior, stringValue);
+        }
+        else if (this.UnhandledPromptBehavior is UnhandledPromptBehaviorMultiOption multiOption)
         {
-            string unhandledPropmtBehaviorSetting = "ignore";
-            switch (this.UnhandledPromptBehavior)
+            Dictionary<string, string> multiOptionDictionary = [];
+
+            if (multiOption.Alert is not Selenium.UnhandledPromptBehavior.Default)
             {
-                case UnhandledPromptBehavior.Accept:
-                    unhandledPropmtBehaviorSetting = "accept";
-                    break;
+                multiOptionDictionary["alert"] = UnhandledPromptBehaviorToString(multiOption.Alert);
+            }
 
-                case UnhandledPromptBehavior.Dismiss:
-                    unhandledPropmtBehaviorSetting = "dismiss";
-                    break;
+            if (multiOption.Confirm is not Selenium.UnhandledPromptBehavior.Default)
+            {
+                multiOptionDictionary["confirm"] = UnhandledPromptBehaviorToString(multiOption.Confirm);
+            }
 
-                case UnhandledPromptBehavior.AcceptAndNotify:
-                    unhandledPropmtBehaviorSetting = "accept and notify";
-                    break;
+            if (multiOption.Prompt is not Selenium.UnhandledPromptBehavior.Default)
+            {
+                multiOptionDictionary["prompt"] = UnhandledPromptBehaviorToString(multiOption.Prompt);
+            }
 
-                case UnhandledPromptBehavior.DismissAndNotify:
-                    unhandledPropmtBehaviorSetting = "dismiss and notify";
-                    break;
+            if (multiOption.BeforeUnload is not Selenium.UnhandledPromptBehavior.Default)
+            {
+                multiOptionDictionary["beforeUnload"] = UnhandledPromptBehaviorToString(multiOption.BeforeUnload);
             }
 
-            capabilities.SetCapability(CapabilityType.UnhandledPromptBehavior, unhandledPropmtBehaviorSetting);
+            if (multiOption.Default is not Selenium.UnhandledPromptBehavior.Default)
+            {
+                multiOptionDictionary["default"] = UnhandledPromptBehaviorToString(multiOption.Default);
+            }
+
+            if (multiOptionDictionary.Count != 0)
+            {
+                capabilities.SetCapability(CapabilityType.UnhandledPromptBehavior, multiOptionDictionary);
+            }
         }
 
         if (this.Proxy != null)
diff --git a/dotnet/src/webdriver/UnhandledPromptBehaviorOption.cs b/dotnet/src/webdriver/UnhandledPromptBehaviorOption.cs
new file mode 100644
index 0000000000000..7e0dc35988243
--- /dev/null
+++ b/dotnet/src/webdriver/UnhandledPromptBehaviorOption.cs
@@ -0,0 +1,150 @@
+// <copyright file="UnhandledPromptBehaviorOption.cs" company="Selenium Committers">
+// Licensed to the Software Freedom Conservancy (SFC) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The SFC licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+// </copyright>
+
+namespace OpenQA.Selenium;
+
+/// <summary>
+/// Represents a configuration option that determines how unhandled prompts are managed during automated browser
+/// interactions.
+/// </summary>
+/// <remarks>
+/// Use this type to specify whether a single unhandled prompt behavior or multiple behaviors should be applied.
+/// The static methods provide convenient ways to create either a single-behavior or multi-behavior option.
+/// This abstraction is typically used in scenarios where browser automation frameworks need to control the handling of
+/// unexpected dialogs or prompts.
+/// <para>
+/// Available options:
+/// <list type="bullet">
+/// <item><description><see cref="UnhandledPromptBehaviorSingleOption"/> - Wraps a single <see cref="UnhandledPromptBehavior"/> value applied to all prompt types. Create via the implicit conversion from <see cref="UnhandledPromptBehavior"/> or by calling <see cref="Single(UnhandledPromptBehavior)"/>.</description></item>
+/// <item><description><see cref="UnhandledPromptBehaviorMultiOption"/> - Allows configuring per-prompt behaviors (Alert, Confirm, Prompt, BeforeUnload, Default). Create via <see cref="Multi()"/>.</description></item>
+/// </list>
+/// </para>
+/// </remarks>
+public abstract record UnhandledPromptBehaviorOption
+{
+    /// <summary>
+    /// Converts a value of type <see cref="UnhandledPromptBehavior"/> to an <see cref="UnhandledPromptBehaviorOption"/> instance.
+    /// </summary>
+    /// <param name="value">The <see cref="UnhandledPromptBehavior"/> value to convert.</param>
+    public static implicit operator UnhandledPromptBehaviorOption(UnhandledPromptBehavior value)
+        => Single(value);
+
+    /// <summary>
+    /// Creates an <see cref="UnhandledPromptBehaviorOption"/> representing a single <see cref="UnhandledPromptBehavior"/> value.
+    /// </summary>
+    /// <param name="value">The <see cref="UnhandledPromptBehavior"/> to apply for all prompt types.</param>
+    /// <returns>An <see cref="UnhandledPromptBehaviorOption"/> wrapping the provided behavior.</returns>
+    public static UnhandledPromptBehaviorOption Single(UnhandledPromptBehavior value)
+        => new UnhandledPromptBehaviorSingleOption(value);
+
+    /// <summary>
+    /// Creates an <see cref="UnhandledPromptBehaviorOption"/> allowing individual <see cref="UnhandledPromptBehavior"/> values per prompt type.
+    /// </summary>
+    /// <returns>An <see cref="UnhandledPromptBehaviorOption"/> with per-prompt configurable behaviors.</returns>
+    public static UnhandledPromptBehaviorOption Multi()
+        => new UnhandledPromptBehaviorMultiOption();
+}
+
+/// <summary>
+/// Represents an option that specifies a single unhandled prompt behavior to use when interacting with browser dialogs.
+/// </summary>
+/// <param name="Value">The unhandled prompt behavior to apply. Specifies how unexpected browser prompts are handled during automation.</param>
+public sealed record UnhandledPromptBehaviorSingleOption(UnhandledPromptBehavior Value) : UnhandledPromptBehaviorOption;
+
+/// <summary>
+/// Represents a set of options that specify how unhandled browser prompts are handled for different prompt types.
+/// </summary>
+/// <remarks>Use this class to configure distinct behaviors for alert, confirm, prompt, and beforeunload dialogs
+/// encountered during browser automation. Each property allows you to control the response to a specific type of
+/// unhandled prompt, enabling fine-grained handling beyond a single global setting.</remarks>
+public sealed record UnhandledPromptBehaviorMultiOption : UnhandledPromptBehaviorOption
+{
+    /// <summary>
+    /// Gets or sets the behavior to use when an unexpected alert is encountered during automation.
+    /// </summary>
+    public UnhandledPromptBehavior Alert { get; set; } = UnhandledPromptBehavior.Default;
+
+    /// <summary>
+    /// Gets or sets the behavior to use when a confirmation prompt is encountered.
+    /// </summary>
+    /// <remarks>Set this property to specify how the system should respond to confirmation dialogs, such as
+    /// JavaScript confirm boxes, during automated operations. The default value is <see
+    /// cref="UnhandledPromptBehavior.Default"/>, which applies the standard handling defined by the
+    /// environment.</remarks>
+    public UnhandledPromptBehavior Confirm { get; set; } = UnhandledPromptBehavior.Default;
+
+    /// <summary>
+    /// Gets or sets the behavior to use when an unexpected prompt is encountered during automation.
+    /// </summary>
+    /// <remarks>Set this property to control how the system responds to unhandled prompts, such as alerts or
+    /// confirmation dialogs, that appear unexpectedly. The default behavior is determined by the value of
+    /// <see cref="UnhandledPromptBehavior.Default"/>.</remarks>
+    public UnhandledPromptBehavior Prompt { get; set; } = UnhandledPromptBehavior.Default;
+
+    /// <summary>
+    /// Gets or sets the behavior to use when an unexpected beforeunload dialog is encountered.
+    /// </summary>
+    /// <remarks>Use this property to specify how the application should respond to beforeunload dialogs that
+    /// appear unexpectedly during automated browser interactions. This setting determines whether such dialogs are
+    /// automatically accepted, dismissed, or cause an error.</remarks>
+    public UnhandledPromptBehavior BeforeUnload { get; set; } = UnhandledPromptBehavior.Default;
+
+    /// <summary>
+    /// Gets or sets the default behavior to use when an unexpected browser prompt is encountered.
+    /// </summary>
+    public UnhandledPromptBehavior Default { get; set; } = UnhandledPromptBehavior.Default;
+}
+
+/// <summary>
+/// Specifies the behavior of handling unexpected alerts in the IE driver.
+/// </summary>
+public enum UnhandledPromptBehavior
+{
+    /// <summary>
+    /// Indicates the behavior is not set.
+    /// </summary>
+    Default,
+
+    /// <summary>
+    /// Ignore unexpected alerts, such that the user must handle them.
+    /// </summary>
+    Ignore,
+
+    /// <summary>
+    /// Accept unexpected alerts.
+    /// </summary>
+    Accept,
+
+    /// <summary>
+    /// Dismiss unexpected alerts.
+    /// </summary>
+    Dismiss,
+
+    /// <summary>
+    /// Accepts unexpected alerts and notifies the user that the alert has
+    /// been accepted by throwing an <see cref="UnhandledAlertException"/>
+    /// </summary>
+    AcceptAndNotify,
+
+    /// <summary>
+    /// Dismisses unexpected alerts and notifies the user that the alert has
+    /// been dismissed by throwing an <see cref="UnhandledAlertException"/>
+    /// </summary>
+    DismissAndNotify
+}