diff --git a/doc/dbus/bus/org.opensuse.Agama.Storage1.Proposal.bus.xml b/doc/dbus/bus/org.opensuse.Agama.Storage1.Proposal.bus.xml
index 3a5ee0600f..fc5aa6a047 100644
--- a/doc/dbus/bus/org.opensuse.Agama.Storage1.Proposal.bus.xml
+++ b/doc/dbus/bus/org.opensuse.Agama.Storage1.Proposal.bus.xml
@@ -27,14 +27,7 @@
     </signal>
   </interface>
   <interface name="org.opensuse.Agama.Storage1.Proposal">
-    <property type="s" name="BootDevice" access="read"/>
-    <property type="b" name="LVM" access="read"/>
-    <property type="as" name="SystemVGDevices" access="read"/>
-    <property type="s" name="EncryptionPassword" access="read"/>
-    <property type="s" name="EncryptionMethod" access="read"/>
-    <property type="s" name="EncryptionPBKDFunction" access="read"/>
-    <property type="s" name="SpacePolicy" access="read"/>
-    <property type="aa{sv}" name="Volumes" access="read"/>
+    <property type="a{sv}" name="Settings" access="read"/>
     <property type="aa{sv}" name="Actions" access="read"/>
   </interface>
 </node>
diff --git a/doc/dbus/org.opensuse.Agama.Storage1.Proposal.Calculator.doc.xml b/doc/dbus/org.opensuse.Agama.Storage1.Proposal.Calculator.doc.xml
index 254aa14124..ec60f49dcd 100644
--- a/doc/dbus/org.opensuse.Agama.Storage1.Proposal.Calculator.doc.xml
+++ b/doc/dbus/org.opensuse.Agama.Storage1.Proposal.Calculator.doc.xml
@@ -18,13 +18,14 @@
       <!--
         MountPath               s
         MountOptions            as
-        Target                  s
-        TargetDevice            s (only makes sense if Target is not default)
+        Target                  s (options: "default", "new_partition", "new_vg", "device", "filesystem")
+        TargetDevice            s (only makes sense if Target is not "default")
         FsType                  s
         MinSize                 t (bytes)
         MaxSize                 t (bytes. Optional, max size is considered as unlimited if omitted)
         AutoSize                b
-        Snapshots               b
+        Snapshots               b (makes sense only for btrfs)
+        Transactional           b (makes sense only for btrfs)
         Outline                 a{sv}
           Required              b
           FsTypes               as
@@ -39,20 +40,41 @@
       Calculates a new proposal.
     -->
     <method name="Calculate">
-    <!--
-      BootDevice              s
-      LVM                     b
-      SystemVGDevices         as
-      EncryptionPassword      s
-      EncryptionMethod        s
-      EncryptionPBKDFunction  s
-      SpacePolicy             s
-      SpaceActions            a{ss}
-      Volumes                 aa{sv}
-        List of volumes to create. The values for each volume are the same as the values returned
-        by DefaultVolume method. The Outline (if given) would be ignored.
-    -->
+      <!--
+        Target                 s (options: "disk", "newLvmVg", "reusedLvmVg")
+        TargeDevice            s (optional: does not make sense if Target is "newLvmVg")
+        TargetPVDevices        as (optional: only makes sense if Target is "newLvmVg")
+        ConfigureBoot          b
+        BootDevice             s
+        EncryptionPassword     s
+        EncryptionMethod       s
+        EncryptionPBKDFunction s
+        SpacePolicy            s
+        SpaceActions           aa{sv}
+        Volumes                aa{sv}
+
+        Each space action has the following properties:
+          Device                 s
+          Action                 s (options: "force_delete", "resize")
+
+        Each volume has the following properties:
+          MountPath               s
+          MountOptions            as
+          Target                  s (options: "default", "new_partition", "new_vg", "device", "filesystem")
+          TargetDevice            s (only makes sense if Target is not "default")
+          FsType                  s
+          MinSize                 t (bytes)
+          MaxSize                 t (bytes. Optional, max size is considered as unlimited if omitted)
+          AutoSize                b
+          Snapshots               b (makes sense only for btrfs)
+          Transactional           b (makes sense only for btrfs)
+      -->
       <arg name="settings" direction="in" type="a{sv}"/>
+      <!--
+        Whether the proposal was correctly calculated:
+          0: success
+          1: failure
+      -->
       <arg name="result" direction="out" type="u"/>
     </method>
     <property type="ao" name="AvailableDevices" access="read"/>
diff --git a/doc/dbus/org.opensuse.Agama.Storage1.Proposal.doc.xml b/doc/dbus/org.opensuse.Agama.Storage1.Proposal.doc.xml
index cf473ac671..9b7bea10ab 100644
--- a/doc/dbus/org.opensuse.Agama.Storage1.Proposal.doc.xml
+++ b/doc/dbus/org.opensuse.Agama.Storage1.Proposal.doc.xml
@@ -4,26 +4,36 @@
     Interfaces with the properties of the calculated proposal.
   -->
   <interface name="org.opensuse.Agama.Storage1.Proposal">
-    <property type="s" name="BootDevice" access="read"/>
-    <property type="b" name="LVM" access="read"/>
-    <property type="as" name="SystemVGDevices" access="read"/>
-    <property type="s" name="EncryptionPassword" access="read"/>
-    <property type="s" name="EncryptionMethod" access="read"/>
-    <property type="s" name="EncryptionPBKDFunction" access="read"/>
-    <property type="s" name="SpacePolicy" access="read"/>
     <!--
-      List of volumes used for calculating the proposal.
+      Proposal settings:
+        Target                 s (options: "disk", "newLvmVg", "reusedLvmVg")
+        TargeDevice            s (optional: does not make sense if Target is "newLvmVg")
+        TargetPVDevices        as (optional: only makes sense if Target is "newLvmVg")
+        ConfigureBoot          b
+        BootDevice             s
+        DefaultBootDevice      s
+        EncryptionPassword     s
+        EncryptionMethod       s
+        EncryptionPBKDFunction s
+        SpacePolicy            s
+        SpaceActions           aa{sv}
+        Volumes                aa{sv}
+
+      Each space action has the following properties:
+        Device                 s
+        Action                 s (options: "force_delete", "resize")
+
       Each volume has the following properties:
         MountPath               s
         MountOptions            as
-        Target                  s
-        TargetDevice            s (only makes sense if Target is not default)
+        Target                  s (options: "default", "new_partition", "new_vg", "device", "filesystem")
+        TargetDevice            s (only makes sense if Target is not "default")
         FsType                  s
         MinSize                 t (bytes)
         MaxSize                 t (bytes. Optional, max size is considered as unlimited if omitted)
         AutoSize                b
-        Snapshots               b ( makes sense only for btrfs )
-        Transactional           b ( makes sense only for btrfs )
+        Snapshots               b (makes sense only for btrfs)
+        Transactional           b (makes sense only for btrfs)
         Outline                 a{sv}
           Required              b
           FsTypes               as
@@ -32,10 +42,11 @@
           SnapshotsAffectSizes  b
           SizeRelevantVolumes   as
     -->
-    <property type="aa{sv}" name="Volumes" access="read"/>
+    <property type="a{sv}" name="Settings" access="read"/>
     <!--
       Actions to perform in the system in order to create the volumes.
       Each action has the following properties:
+        Device  s
         Text    s
         Subvol  b
         Delete  b
diff --git a/service/Gemfile.lock b/service/Gemfile.lock
index a70c881f97..9f8554476d 100755
--- a/service/Gemfile.lock
+++ b/service/Gemfile.lock
@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    agama (7)
+    agama-yast (7.devel737)
       cfa (~> 1.0.2)
       cfa_grub2 (~> 2.0.0)
       cheetah (~> 1.0.0)
@@ -26,7 +26,9 @@ GEM
     docile (1.4.0)
     eventmachine (1.2.7)
     fast_gettext (2.3.0)
-    nokogiri (1.15.5-x86_64-linux)
+    mini_portile2 (2.8.5)
+    nokogiri (1.15.5)
+      mini_portile2 (~> 2.8.2)
       racc (~> 1.4)
     packaging_rake_tasks (1.5.4)
       rake
@@ -63,7 +65,7 @@ PLATFORMS
   x86_64-linux-gnu
 
 DEPENDENCIES
-  agama!
+  agama-yast!
   byebug
   packaging_rake_tasks (~> 1.5.1)
   rake (~> 13.0.6)
diff --git a/service/lib/agama/dbus/hash_validator.rb b/service/lib/agama/dbus/hash_validator.rb
new file mode 100644
index 0000000000..a7c7a4c3e9
--- /dev/null
+++ b/service/lib/agama/dbus/hash_validator.rb
@@ -0,0 +1,154 @@
+# frozen_string_literal: true
+
+# Copyright (c) [2024] SUSE LLC
+#
+# All Rights Reserved.
+#
+# This program is free software; you can redistribute it and/or modify it
+# under the terms of version 2 of the GNU General Public License as published
+# by the Free Software Foundation.
+#
+# This program is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+# FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+# more details.
+#
+# You should have received a copy of the GNU General Public License along
+# with this program; if not, contact SUSE LLC.
+#
+# To contact SUSE LLC about this file by physical or electronic mail, you may
+# find current contact information at www.suse.com.
+
+require "agama/dbus/types"
+
+module Agama
+  module DBus
+    # Validates a Hash (dictionary) from D-Bus according to an scheme.
+    #
+    # This validation is useful to check the expected types of a D-Bus call when some parameter is
+    # a dictionary with variant types.
+    #
+    # @example
+    #   # Let's say there is a D-Bus method with the following signature:
+    #
+    #   dbus_method :Calculate, "in settings:a{sv}"
+    #
+    #   # The settings parameter will be transformed to a ruby Hash and this class allows to
+    #   # validate the types of the hash values.
+    #
+    #   scheme = {
+    #     "ID"       => Integer,
+    #     "Name"     => String,
+    #     "Children" => Agama::DBus::Types.Array.new(Integer)
+    #   }
+    #
+    #   value1 = { "ID" => 10, "Name" => "Foo", "Color" => "red" }
+    #   validator = HashValidator.new(value1, scheme: scheme)
+    #   validator.valid?          #=> true
+    #   validator.missing_keys    #=> ["Children"]
+    #   validator.extra_keys      #=> ["Color"]
+    #   validator.issues          #=> ["Unknown D-Bus property Color"]
+    #
+    #   value2 = { "ID" => 10, "Name" => 33 }
+    #   validator = HashValidator.new(value2, scheme: scheme)
+    #   validator.valid?          #=> false
+    #   validator.missing_keys    #=> ["Children"]
+    #   validator.wrong_type_keys #=> ["Name"]
+    #   validator.issues.size     #=> 1
+    class HashValidator
+      # @param value [Hash{String => Object}] Hash to validate.
+      # @param scheme [Hash{String => Class, Types::BOOL, Types::Array, Types::Hash}] Scheme
+      #   for validating the hash.
+      def initialize(value, scheme:)
+        @value = value
+        @scheme = scheme
+      end
+
+      # Whether the hash is valid.
+      #
+      # The hash is consider as valid if there is no key with wrong type. Missing and extra keys are
+      # not validated.
+      #
+      # @return [Boolean]
+      def valid?
+        wrong_type_keys.none?
+      end
+
+      # Keys with correct type.
+      #
+      # Missing and extra keys are ignored.
+      #
+      # @return [Array<String>]
+      def valid_keys
+        value.keys.select { |k| valid_key?(k) }
+      end
+
+      # Keys with incorrect type.
+      #
+      # Missing and extra keys are ignored.
+      #
+      # @return [Array<String>]
+      def wrong_type_keys
+        value.keys.select { |k| !extra_key?(k) && wrong_type_key?(k) }
+      end
+
+      # Keys not included in the scheme.
+      #
+      # @return [Array<String>]
+      def extra_keys
+        value.keys.select { |k| extra_key?(k) }
+      end
+
+      # Keys included in the scheme but missing in the hash value.
+      #
+      # @return [Array<String>]
+      def missing_keys
+        scheme.keys - value.keys
+      end
+
+      # List of issues.
+      #
+      # There is an issue for each extra key and for each key with wrong type.
+      #
+      # @return [Array<String>]
+      def issues
+        issues = []
+
+        extra_keys.map do |key|
+          issues << "Unknown D-Bus property #{key}"
+        end
+
+        wrong_type_keys.map do |key|
+          type = scheme[key]
+          value = self.value[key]
+
+          issues << "D-Bus property #{key} must be #{type}: #{value} (#{value.class})"
+        end
+
+        issues
+      end
+
+    private
+
+      # @return [Hash{String => Object}]
+      attr_reader :value
+
+      # @return [Hash{String => Class, Types::BOOL, Types::Array, Types::Hash}]
+      attr_reader :scheme
+
+      def valid_key?(key)
+        !(extra_key?(key) || wrong_type_key?(key))
+      end
+
+      def extra_key?(key)
+        !scheme.keys.include?(key)
+      end
+
+      def wrong_type_key?(key)
+        type = scheme[key]
+        checker = Types::Checker.new(type)
+        !checker.match?(value[key])
+      end
+    end
+  end
+end
diff --git a/service/lib/agama/dbus/storage/interfaces/device/drive.rb b/service/lib/agama/dbus/storage/interfaces/device/drive.rb
index 0466ad7984..51c2f0d7c0 100644
--- a/service/lib/agama/dbus/storage/interfaces/device/drive.rb
+++ b/service/lib/agama/dbus/storage/interfaces/device/drive.rb
@@ -85,7 +85,10 @@ def drive_model
             #
             # @return [String]
             def drive_bus
-              storage_device.bus || ""
+              # FIXME: not sure whether checking for "none" is robust enough
+              return "" if storage_device.bus.nil? || storage_device.bus.casecmp?("none")
+
+              storage_device.bus
             end
 
             # Bus Id for DASD
@@ -110,7 +113,15 @@ def drive_driver
             def drive_transport
               return "" unless storage_device.respond_to?(:transport)
 
-              storage_device.transport.to_s
+              transport = storage_device.transport
+              return "" if transport.nil? || transport.is?(:unknown)
+
+              # FIXME: transport does not have proper i18n support at yast2-storage-ng, so we are
+              # just duplicating some logic from yast2-storage-ng here
+              return "USB" if transport.is?(:usb)
+              return "IEEE 1394" if transport.is?(:sbp)
+
+              transport.to_s
             end
 
             # More info about the device
diff --git a/service/lib/agama/dbus/storage/manager.rb b/service/lib/agama/dbus/storage/manager.rb
index 3d9380569d..9686733630 100644
--- a/service/lib/agama/dbus/storage/manager.rb
+++ b/service/lib/agama/dbus/storage/manager.rb
@@ -152,7 +152,9 @@ def default_volume(mount_path)
         # @param dbus_settings [Hash]
         # @return [Integer] 0 success; 1 error
         def calculate_proposal(dbus_settings)
-          settings = ProposalSettingsConversion.from_dbus(dbus_settings, config: config)
+          settings = ProposalSettingsConversion.from_dbus(dbus_settings,
+            config: config, logger: logger)
+
           logger.info(
             "Calculating storage proposal from D-Bus.\n " \
             "D-Bus settings: #{dbus_settings}\n" \
diff --git a/service/lib/agama/dbus/storage/proposal.rb b/service/lib/agama/dbus/storage/proposal.rb
index 591d142451..f33e2e61ad 100644
--- a/service/lib/agama/dbus/storage/proposal.rb
+++ b/service/lib/agama/dbus/storage/proposal.rb
@@ -19,20 +19,18 @@
 # To contact SUSE LLC about this file by physical or electronic mail, you may
 # find current contact information at www.suse.com.
 
-require "dbus"
 require "agama/dbus/base_object"
 require "agama/dbus/storage/proposal_settings_conversion"
+require "dbus"
 
 module Agama
   module DBus
     module Storage
-      # D-Bus object to manage the storage proposal
+      # D-Bus object to manage the storage proposal.
       class Proposal < BaseObject
         PATH = "/org/opensuse/Agama/Storage1/Proposal"
         private_constant :PATH
 
-        # Constructor
-        #
         # @param backend [Agama::Storage::Proposal]
         # @param logger [Logger]
         def initialize(backend, logger)
@@ -44,88 +42,22 @@ def initialize(backend, logger)
         private_constant :STORAGE_PROPOSAL_INTERFACE
 
         dbus_interface STORAGE_PROPOSAL_INTERFACE do
-          dbus_reader :boot_device, "s"
-
-          dbus_reader :lvm, "b", dbus_name: "LVM"
-
-          dbus_reader :system_vg_devices, "as", dbus_name: "SystemVGDevices"
-
-          dbus_reader :encryption_password, "s"
-
-          dbus_reader :encryption_method, "s"
-
-          dbus_reader :encryption_pbkd_function, "s", dbus_name: "EncryptionPBKDFunction"
-
-          dbus_reader :space_policy, "s"
-
-          dbus_reader :space_actions, "aa{sv}"
-
-          dbus_reader :volumes, "aa{sv}"
-
+          dbus_reader :settings, "a{sv}"
           dbus_reader :actions, "aa{sv}"
         end
 
-        # Device used as boot device by the storage proposal
-        #
-        # @return [String] Empty string if no device has been selected yet.
-        def boot_device
-          dbus_settings.fetch("BootDevice", "")
-        end
-
-        # Whether the proposal creates logical volumes
+        # Proposal settings.
         #
-        # @return [Boolean]
-        def lvm
-          dbus_settings.fetch("LVM", false)
-        end
-
-        def system_vg_devices
-          dbus_settings.fetch("SystemVGDevices", [])
-        end
-
-        # Password for encrypting devices
-        #
-        # @return [String]
-        def encryption_password
-          dbus_settings.fetch("EncryptionPassword", "")
-        end
-
-        # Encryption method
+        # @see ProposalSettingsConversion::ToDBus
         #
-        # @return [String] For the possible values, check Y2Storage::EncryptionMethod.all
-        def encryption_method
-          dbus_settings.fetch("EncryptionMethod", "")
-        end
-
-        # PBKD function
-        #
-        # @return [String] For the possible values, check Y2Storage::PbkdFunction.all
-        def encryption_pbkd_function
-          dbus_settings.fetch("EncryptionPBKDFunction", "")
-        end
-
-        # Space policy strategy
-        #
-        # @return [String] For the possible values, check Agama::Storage::SpaceSettings
-        def space_policy
-          dbus_settings.fetch("SpacePolicy", "")
-        end
-
-        # Space actions
-        #
-        # @return [Array<Hash>]
-        def space_actions
-          dbus_settings.fetch("SpaceActions", [])
-        end
+        # @return [Hash]
+        def settings
+          return {} unless backend.settings
 
-        # Volumes used to calculate the storage proposal
-        #
-        # @return [Array<Hash>]
-        def volumes
-          dbus_settings.fetch("Volumes", [])
+          ProposalSettingsConversion.to_dbus(backend.settings)
         end
 
-        # List of sorted actions in D-Bus format
+        # List of sorted actions in D-Bus format.
         #
         # @see #to_dbus_action
         #
@@ -142,17 +74,14 @@ def actions
         # @return [Logger]
         attr_reader :logger
 
-        # @return [Hash]
-        def dbus_settings
-          return {} unless backend.settings
-
-          @dbus_settings ||= ProposalSettingsConversion.to_dbus(backend.settings)
-        end
-
-        # Converts an action to D-Bus format
+        # Converts an action to D-Bus format.
         #
         # @param action [Y2Storage::CompoundAction]
-        # @return [Hash]
+        # @return [Hash<String, Object>]
+        #   * "Device" [String]
+        #   * "Text" [String]
+        #   * "Subvol" [Boolean]
+        #   * "Delete" [Boolean]
         def to_dbus_action(action)
           {
             "Device" => action.target_device.sid,
diff --git a/service/lib/agama/dbus/storage/proposal_settings_conversion.rb b/service/lib/agama/dbus/storage/proposal_settings_conversion.rb
index 47ac4f9536..dc8e94ffc7 100644
--- a/service/lib/agama/dbus/storage/proposal_settings_conversion.rb
+++ b/service/lib/agama/dbus/storage/proposal_settings_conversion.rb
@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-# Copyright (c) [2023] SUSE LLC
+# Copyright (c) [2023-2024] SUSE LLC
 #
 # All Rights Reserved.
 #
@@ -31,10 +31,11 @@ module ProposalSettingsConversion
         #
         # @param dbus_settings [Hash]
         # @param config [Agama::Config]
+        # @param logger [Logger, nil]
         #
         # @return [Agama::Storage::ProposalSettings]
-        def self.from_dbus(dbus_settings, config:)
-          FromDBus.new(dbus_settings, config: config).convert
+        def self.from_dbus(dbus_settings, config:, logger: nil)
+          FromDBus.new(dbus_settings, config: config, logger: logger).convert
         end
 
         # Performs conversion to D-Bus format.
diff --git a/service/lib/agama/dbus/storage/proposal_settings_conversion/from_dbus.rb b/service/lib/agama/dbus/storage/proposal_settings_conversion/from_dbus.rb
index 412607d72c..c817076e53 100644
--- a/service/lib/agama/dbus/storage/proposal_settings_conversion/from_dbus.rb
+++ b/service/lib/agama/dbus/storage/proposal_settings_conversion/from_dbus.rb
@@ -19,12 +19,15 @@
 # To contact SUSE LLC about this file by physical or electronic mail, you may
 # find current contact information at www.suse.com.
 
-require "y2storage/encryption_method"
-require "y2storage/pbkd_function"
+require "agama/dbus/hash_validator"
+require "agama/dbus/storage/volume_conversion"
+require "agama/dbus/types"
+require "agama/storage/device_settings"
 require "agama/storage/proposal_settings"
 require "agama/storage/proposal_settings_reader"
 require "agama/storage/space_settings"
-require "agama/dbus/storage/volume_conversion"
+require "y2storage/encryption_method"
+require "y2storage/pbkd_function"
 
 module Agama
   module DBus
@@ -34,25 +37,23 @@ module ProposalSettingsConversion
         class FromDBus
           # @param dbus_settings [Hash]
           # @param config [Agama::Config]
-          def initialize(dbus_settings, config:)
+          # @param logger [Logger, nil]
+          def initialize(dbus_settings, config:, logger: nil)
             @dbus_settings = dbus_settings
             @config = config
+            @logger = logger || Logger.new($stdout)
           end
 
           # Performs the conversion from D-Bus format.
           #
           # @return [Agama::Storage::ProposalSettings]
           def convert
-            settings = Agama::Storage::ProposalSettingsReader.new(config).read
+            logger.info("D-Bus settings: #{dbus_settings}")
 
-            settings.tap do |target|
-              dbus_settings.each do |dbus_property, dbus_value|
-                converter = CONVERSIONS[dbus_property]
-                # FIXME: likely ignoring the wrong attribute is not the best
-                next unless converter
+            dbus_settings_issues.each { |i| logger.warn(i) }
 
-                send(converter, target, dbus_value)
-              end
+            Agama::Storage::ProposalSettingsReader.new(config).read.tap do |target|
+              valid_dbus_properties.each { |p| conversion(target, p) }
             end
           end
 
@@ -64,36 +65,145 @@ def convert
           # @return [Agama::Config]
           attr_reader :config
 
-          # D-Bus attributes and their converters.
-          CONVERSIONS = {
-            "BootDevice"             => :boot_device_conversion,
-            "LVM"                    => :lvm_conversion,
-            "SystemVGDevices"        => :system_vg_devices_conversion,
-            "EncryptionPassword"     => :encryption_password_conversion,
-            "EncryptionMethod"       => :encryption_method_conversion,
-            "EncryptionPBKDFunction" => :encryption_pbkd_function_conversion,
-            "SpacePolicy"            => :space_policy_conversion,
-            "SpaceActions"           => :space_actions_conversion,
-            "Volumes"                => :volumes_conversion
-          }.freeze
-          private_constant :CONVERSIONS
+          # @return [Logger]
+          attr_reader :logger
+
+          DBUS_PROPERTIES = [
+            {
+              name:       "Target",
+              type:       String,
+              conversion: :device_conversion
+            },
+            {
+              name: "TargetDevice",
+              type: String
+            },
+            {
+              name: "TargetPVDevices",
+              type: Types::Array.new(String)
+            },
+            {
+              name:       "ConfigureBoot",
+              type:       Types::BOOL,
+              conversion: :configure_boot_conversion
+            },
+            {
+              name:       "BootDevice",
+              type:       String,
+              conversion: :boot_device_conversion
+            },
+            {
+              name:       "EncryptionPassword",
+              type:       String,
+              conversion: :encryption_password_conversion
+            },
+            {
+              name:       "EncryptionMethod",
+              type:       String,
+              conversion: :encryption_method_conversion
+            },
+            {
+              name:       "EncryptionPBKDFunction",
+              type:       String,
+              conversion: :encryption_pbkd_function_conversion
+            },
+            {
+              name:       "SpacePolicy",
+              type:       String,
+              conversion: :space_policy_conversion
+            },
+            {
+              name:       "SpaceActions",
+              type:       Types::Array.new(Types::Hash.new(key: String, value: String)),
+              conversion: :space_actions_conversion
+            },
+            {
+              name:       "Volumes",
+              type:       Types::Array.new(Types::Hash.new(key: String)),
+              conversion: :volumes_conversion
+            }
+          ].freeze
+
+          private_constant :DBUS_PROPERTIES
+
+          # Issues detected in the D-Bus settings, see {HashValidator#issues}.
+          #
+          # @return [Array<String>]
+          def dbus_settings_issues
+            validator.issues
+          end
+
+          # D-Bus properties with valid type, see {HashValidator#valid_keys}.
+          #
+          # @return [Array<String>]
+          def valid_dbus_properties
+            validator.valid_keys
+          end
+
+          # Validator for D-Bus settings.
+          #
+          # @return [HashValidator]
+          def validator
+            return @validator if @validator
+
+            scheme = DBUS_PROPERTIES.map { |p| [p[:name], p[:type]] }.to_h
+            @validator = HashValidator.new(dbus_settings, scheme: scheme)
+          end
+
+          # @param target [Agama::Storage::ProposalSettings]
+          # @param dbus_property_name [String]
+          def conversion(target, dbus_property_name)
+            dbus_property = DBUS_PROPERTIES.find { |d| d[:name] == dbus_property_name }
+            conversion_method = dbus_property[:conversion]
+
+            return unless conversion_method
+
+            send(conversion_method, target, dbus_settings[dbus_property_name])
+          end
 
           # @param target [Agama::Storage::ProposalSettings]
           # @param value [String]
-          def boot_device_conversion(target, value)
-            target.boot_device = value.empty? ? nil : value
+          def device_conversion(target, value)
+            device_settings = case value
+            when "disk"
+              disk_device_conversion
+            when "newLvmVg"
+              new_lvm_vg_device_conversion
+            when "reusedLvmVg"
+              reused_lvm_vg_device_conversion
+            end
+
+            target.device = device_settings
+          end
+
+          # @return [Agama::Storage::DeviceSettings::Disk]
+          def disk_device_conversion
+            device = dbus_settings["TargetDevice"]
+            Agama::Storage::DeviceSettings::Disk.new(device)
+          end
+
+          # @return [Agama::Storage::DeviceSettings::NewLvmVg]
+          def new_lvm_vg_device_conversion
+            candidates = dbus_settings["TargetPVDevices"] || []
+            Agama::Storage::DeviceSettings::NewLvmVg.new(candidates)
+          end
+
+          # @return [Agama::Storage::DeviceSettings::ReusedLvmVg]
+          def reused_lvm_vg_device_conversion
+            device = dbus_settings["TargetDevice"]
+            Agama::Storage::DeviceSettings::ReusedLvmVg.new(device)
           end
 
           # @param target [Agama::Storage::ProposalSettings]
           # @param value [Boolean]
-          def lvm_conversion(target, value)
-            target.lvm.enabled = value
+          def configure_boot_conversion(target, value)
+            target.boot.configure = value
           end
 
           # @param target [Agama::Storage::ProposalSettings]
-          # @param value [Array<String>]
-          def system_vg_devices_conversion(target, value)
-            target.lvm.system_vg_devices = value
+          # @param value [String]
+          def boot_device_conversion(target, value)
+            target.boot.device = value.empty? ? nil : value
           end
 
           # @param target [Agama::Storage::ProposalSettings]
@@ -144,7 +254,9 @@ def volumes_conversion(target, value)
             return if value.empty?
 
             required_volumes = target.volumes.select { |v| v.outline.required? }
-            volumes = value.map { |v| VolumeConversion.from_dbus(v, config: config) }
+            volumes = value.map do |dbus_volume|
+              VolumeConversion.from_dbus(dbus_volume, config: config, logger: logger)
+            end
 
             target.volumes = volumes + missing_volumes(required_volumes, volumes)
           end
diff --git a/service/lib/agama/dbus/storage/proposal_settings_conversion/to_dbus.rb b/service/lib/agama/dbus/storage/proposal_settings_conversion/to_dbus.rb
index d4820e847f..b1d725e69b 100644
--- a/service/lib/agama/dbus/storage/proposal_settings_conversion/to_dbus.rb
+++ b/service/lib/agama/dbus/storage/proposal_settings_conversion/to_dbus.rb
@@ -20,6 +20,7 @@
 # find current contact information at www.suse.com.
 
 require "agama/dbus/storage/volume_conversion"
+require "agama/storage/device_settings"
 
 module Agama
   module DBus
@@ -34,19 +35,27 @@ def initialize(settings)
 
           # Performs the conversion to D-Bus format.
           #
-          # @return [Hash]
+          # @return [Hash<String, Object>]
+          #   * "Target" [String]
+          #   * "Device" [String] Optional
+          #   * "CandidatePVDevices" [Array<String>] Optional
+          #   * "ConfigureBoot" [Boolean]
+          #   * "BootDevice" [String]
+          #   * "DefaultBootDevice" [String]
+          #   * "EncryptionPassword" [String]
+          #   * "EncryptionMethod" [String]
+          #   * "EncryptionPBKDFunction" [String]
+          #   * "SpacePolicy" [String]
+          #   * "SpaceActions" [Array<Hash>] see {#space_actions_conversion}
+          #   * "Volumes" [Array<Hash>] see {#volumes_conversion}
           def convert
-            {
-              "BootDevice"             => settings.boot_device.to_s,
-              "LVM"                    => settings.lvm.enabled?,
-              "SystemVGDevices"        => settings.lvm.system_vg_devices,
-              "EncryptionPassword"     => settings.encryption.password.to_s,
-              "EncryptionMethod"       => settings.encryption.method.id.to_s,
-              "EncryptionPBKDFunction" => settings.encryption.pbkd_function&.value || "",
-              "SpacePolicy"            => settings.space.policy.to_s,
-              "SpaceActions"           => space_actions_conversion,
-              "Volumes"                => settings.volumes.map { |v| VolumeConversion.to_dbus(v) }
-            }
+            target = device_conversion
+
+            DBUS_PROPERTIES.each do |dbus_property, conversion|
+              target[dbus_property] = send(conversion)
+            end
+
+            target
           end
 
         private
@@ -54,12 +63,110 @@ def convert
           # @return [Agama::Storage::ProposalSettings]
           attr_reader :settings
 
-          # @return [Array<Hash>]
+          DBUS_PROPERTIES = {
+            "ConfigureBoot"          => :configure_boot_conversion,
+            "BootDevice"             => :boot_device_conversion,
+            "DefaultBootDevice"      => :default_boot_device_conversion,
+            "EncryptionPassword"     => :encryption_password_conversion,
+            "EncryptionMethod"       => :encryption_method_conversion,
+            "EncryptionPBKDFunction" => :encryption_pbkd_function_conversion,
+            "SpacePolicy"            => :space_policy_conversion,
+            "SpaceActions"           => :space_actions_conversion,
+            "Volumes"                => :volumes_conversion
+          }.freeze
+
+          private_constant :DBUS_PROPERTIES
+
+          # @return [Hash]
+          def device_conversion
+            device_settings = settings.device
+
+            case device_settings
+            when Agama::Storage::DeviceSettings::Disk
+              disk_device_conversion(device_settings)
+            when Agama::Storage::DeviceSettings::NewLvmVg
+              new_lvm_vg_device_conversion(device_settings)
+            when Agama::Storage::DeviceSettings::ReusedLvmVg
+              reused_lvm_vg_device_conversion(device_settings)
+            end
+          end
+
+          # @param device_settings [Agama::Storage::DeviceSettings::Disk]
+          # @return [Hash]
+          def disk_device_conversion(device_settings)
+            {
+              "Target"       => "disk",
+              "TargetDevice" => device_settings.name || ""
+            }
+          end
+
+          # @param device_settings [Agama::Storage::DeviceSettings::NewLvmVg]
+          # @return [Hash]
+          def new_lvm_vg_device_conversion(device_settings)
+            {
+              "Target"          => "newLvmVg",
+              "TargetPVDevices" => device_settings.candidate_pv_devices
+            }
+          end
+
+          # @param device_settings [Agama::Storage::DeviceSettings::Disk]
+          # @return [Hash]
+          def reused_lvm_vg_device_conversion(device_settings)
+            {
+              "Target"       => "reusedLvmVg",
+              "TargetDevice" => device_settings.name || ""
+            }
+          end
+
+          # @return [Boolean]
+          def configure_boot_conversion
+            settings.boot.configure?
+          end
+
+          # @return [String]
+          def boot_device_conversion
+            settings.boot.device || ""
+          end
+
+          # @return [String]
+          def default_boot_device_conversion
+            settings.default_boot_device || ""
+          end
+
+          # @return [String]
+          def encryption_password_conversion
+            settings.encryption.password.to_s
+          end
+
+          # @return [String]
+          def encryption_method_conversion
+            settings.encryption.method.id.to_s
+          end
+
+          # @return [String]
+          def encryption_pbkd_function_conversion
+            settings.encryption.pbkd_function&.value || ""
+          end
+
+          # @return [String]
+          def space_policy_conversion
+            settings.space.policy.to_s
+          end
+
+          # @return [Array<Hash<String, Object>>]
+          #   For each action:
+          #   * "Device" [String]
+          #   * "Action" [String]
           def space_actions_conversion
             settings.space.actions.each_with_object([]) do |(device, action), actions|
               actions << { "Device" => device, "Action" => action.to_s }
             end
           end
+
+          # @return [Array<Hash>] see {VolumeConversion::ToDBus}.
+          def volumes_conversion
+            settings.volumes.map { |v| VolumeConversion.to_dbus(v) }
+          end
         end
       end
     end
diff --git a/service/lib/agama/dbus/storage/volume_conversion.rb b/service/lib/agama/dbus/storage/volume_conversion.rb
index 75481e1a02..4c62d6b86f 100644
--- a/service/lib/agama/dbus/storage/volume_conversion.rb
+++ b/service/lib/agama/dbus/storage/volume_conversion.rb
@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-# Copyright (c) [2023] SUSE LLC
+# Copyright (c) [2023-2024] SUSE LLC
 #
 # All Rights Reserved.
 #
@@ -31,10 +31,11 @@ module VolumeConversion
         #
         # @param dbus_volume [Hash]
         # @param config [Agama::Config]
+        # @param logger [Logger, nil]
         #
         # @return [Agama::Storage::Volume]
-        def self.from_dbus(dbus_volume, config:)
-          FromDBus.new(dbus_volume, config: config).convert
+        def self.from_dbus(dbus_volume, config:, logger: nil)
+          FromDBus.new(dbus_volume, config: config, logger: logger).convert
         end
 
         # Performs conversion to D-Bus format.
diff --git a/service/lib/agama/dbus/storage/volume_conversion/from_dbus.rb b/service/lib/agama/dbus/storage/volume_conversion/from_dbus.rb
index e66f361a3a..b2440dab4f 100644
--- a/service/lib/agama/dbus/storage/volume_conversion/from_dbus.rb
+++ b/service/lib/agama/dbus/storage/volume_conversion/from_dbus.rb
@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-# Copyright (c) [2023] SUSE LLC
+# Copyright (c) [2023-2024] SUSE LLC
 #
 # All Rights Reserved.
 #
@@ -19,6 +19,8 @@
 # To contact SUSE LLC about this file by physical or electronic mail, you may
 # find current contact information at www.suse.com.
 
+require "agama/dbus/hash_validator"
+require "agama/dbus/types"
 require "agama/storage/volume"
 require "agama/storage/volume_location"
 require "agama/storage/volume_templates_builder"
@@ -33,26 +35,24 @@ module VolumeConversion
         class FromDBus
           # @param dbus_volume [Hash]
           # @param config [Agama::Config]
-          def initialize(dbus_volume, config:)
+          # @param logger [Logger, nil]
+          def initialize(dbus_volume, config:, logger: nil)
             @dbus_volume = dbus_volume
             @config = config
+            @logger = logger || Logger.new($stdout)
           end
 
           # Performs the conversion from D-Bus format.
           #
           # @return [Agama::Storage::Volume]
           def convert
-            builder = Agama::Storage::VolumeTemplatesBuilder.new_from_config(config)
-            volume = builder.for(dbus_volume["MountPath"] || "")
+            logger.info("D-Bus volume: #{dbus_volume}")
 
-            volume.tap do |target|
-              dbus_volume.each do |dbus_property, dbus_value|
-                converter = CONVERSIONS[dbus_property]
-                # FIXME: likely ignoring the wrong attribute is not the best
-                next unless converter
+            dbus_volume_issues.each { |i| logger.warn(i) }
 
-                send(converter, target, dbus_value)
-              end
+            builder = Agama::Storage::VolumeTemplatesBuilder.new_from_config(config)
+            builder.for(dbus_volume["MountPath"] || "").tap do |target|
+              valid_dbus_properties.each { |p| conversion(target, p) }
             end
           end
 
@@ -64,19 +64,89 @@ def convert
           # @return [Agama::Config]
           attr_reader :config
 
-          # D-Bus attributes and their converters.
-          CONVERSIONS = {
-            "MountPath"    => :mount_path_conversion,
-            "MountOptions" => :mount_options_conversion,
-            "Target"       => :target_conversion,
-            "TargetDevice" => :target_device_conversion,
-            "FsType"       => :fs_type_conversion,
-            "MinSize"      => :min_size_conversion,
-            "MaxSize"      => :max_size_conversion,
-            "AutoSize"     => :auto_size_conversion,
-            "Snapshots"    => :snapshots_conversion
-          }.freeze
-          private_constant :CONVERSIONS
+          # @return [Logger]
+          attr_reader :logger
+
+          DBUS_PROPERTIES = [
+            {
+              name:       "MountPath",
+              type:       String,
+              conversion: :mount_path_conversion
+            },
+            {
+              name:       "MountOptions",
+              type:       Types::Array.new(String),
+              conversion: :mount_options_conversion
+            },
+            {
+              name:       "Target",
+              type:       String,
+              conversion: :target_conversion
+            },
+            {
+              name:       "TargetDevice",
+              type:       String,
+              conversion: :target_device_conversion
+            },
+            {
+              name:       "FsType",
+              type:       String,
+              conversion: :fs_type_conversion
+            },
+            {
+              name:       "MinSize",
+              type:       Integer,
+              conversion: :min_size_conversion
+            },
+            {
+              name:       "MaxSize",
+              type:       Integer,
+              conversion: :max_size_conversion
+            },
+            {
+              name:       "AutoSize",
+              type:       Types::BOOL,
+              conversion: :auto_size_conversion
+            },
+            {
+              name:       "Snapshots",
+              type:       Types::BOOL,
+              conversion: :snapshots_conversion
+            }
+          ].freeze
+
+          private_constant :DBUS_PROPERTIES
+
+          # Issues detected in the D-Bus volume, see {HashValidator#issues}.
+          #
+          # @return [Array<String>]
+          def dbus_volume_issues
+            validator.issues
+          end
+
+          # D-Bus properties with valid type, see {HashValidator#valid_keys}.
+          #
+          # @return [Array<String>]
+          def valid_dbus_properties
+            validator.valid_keys
+          end
+
+          # Validator for D-Bus volume.
+          #
+          # @return [HashValidator]
+          def validator
+            return @validator if @validator
+
+            scheme = DBUS_PROPERTIES.map { |p| [p[:name], p[:type]] }.to_h
+            @validator = HashValidator.new(dbus_volume, scheme: scheme)
+          end
+
+          # @param target [Agama::Storage::Volume]
+          # @param dbus_property_name [String]
+          def conversion(target, dbus_property_name)
+            dbus_property = DBUS_PROPERTIES.find { |d| d[:name] == dbus_property_name }
+            send(dbus_property[:conversion], target, dbus_volume[dbus_property_name])
+          end
 
           # @param target [Agama::Storage::Volume]
           # @param value [String]
diff --git a/service/lib/agama/dbus/storage/volume_conversion/to_dbus.rb b/service/lib/agama/dbus/storage/volume_conversion/to_dbus.rb
index 9c4c51533b..5a79699000 100644
--- a/service/lib/agama/dbus/storage/volume_conversion/to_dbus.rb
+++ b/service/lib/agama/dbus/storage/volume_conversion/to_dbus.rb
@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-# Copyright (c) [2023] SUSE LLC
+# Copyright (c) [2023-2024] SUSE LLC
 #
 # All Rights Reserved.
 #
@@ -32,7 +32,18 @@ def initialize(volume)
 
           # Performs the conversion to D-Bus format.
           #
-          # @return [Hash]
+          # @return [Hash<String, Object>]
+          #   * "MountPath" [String]
+          #   * "MountOptions" [Array<String>]
+          #   * "TargetDevice" [String]
+          #   * "TargetVG" [String]
+          #   * "FsType" [String]
+          #   * "MinSize" [Integer]
+          #   * "MaxSize" [Integer] Optional
+          #   * "AutoSize" [Boolean]
+          #   * "Snapshots" [Booelan]
+          #   * "Transactional" [Boolean]
+          #   * "Outline" [Hash] see {#outline_conversion}
           def convert
             {
               "MountPath"     => volume.mount_path.to_s,
@@ -43,10 +54,11 @@ def convert
               "MinSize"       => volume.min_size&.to_i,
               "AutoSize"      => volume.auto_size?,
               "Snapshots"     => volume.btrfs.snapshots?,
-              "Transactional" => volume.btrfs.read_only?
+              "Transactional" => volume.btrfs.read_only?,
+              "Outline"       => outline_conversion
             }.tap do |target|
+              # Some volumes could not have "MaxSize".
               max_size_conversion(target)
-              outline_conversion(target)
             end
           end
 
@@ -62,11 +74,20 @@ def max_size_conversion(target)
             target["MaxSize"] = volume.max_size.to_i
           end
 
-          # @param target [Hash]
-          def outline_conversion(target)
+          # Converts volume outline to D-Bus.
+          #
+          # @return [Hash<String, Object>]
+          #   * "Required" [Boolean]
+          #   * "FsTypes" [Array<String>]
+          #   * "SupportAutoSize" [Boolean]
+          #   * "AdjustByRam" [Boolean]
+          #   * "SnapshotsConfigurable" [Boolean]
+          #   * "SnapshotsAffectSizes" [Boolean]
+          #   * "SizeRelevantVolumes" [Array<String>]
+          def outline_conversion
             outline = volume.outline
 
-            target["Outline"] = {
+            {
               "Required"              => outline.required?,
               "FsTypes"               => outline.filesystems.map(&:to_human_string),
               "SupportAutoSize"       => outline.adaptive_sizes?,
diff --git a/service/lib/agama/dbus/types.rb b/service/lib/agama/dbus/types.rb
new file mode 100644
index 0000000000..0109dd5e40
--- /dev/null
+++ b/service/lib/agama/dbus/types.rb
@@ -0,0 +1,159 @@
+# frozen_string_literal: true
+
+# Copyright (c) [2024] SUSE LLC
+#
+# All Rights Reserved.
+#
+# This program is free software; you can redistribute it and/or modify it
+# under the terms of version 2 of the GNU General Public License as published
+# by the Free Software Foundation.
+#
+# This program is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+# FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+# more details.
+#
+# You should have received a copy of the GNU General Public License along
+# with this program; if not, contact SUSE LLC.
+#
+# To contact SUSE LLC about this file by physical or electronic mail, you may
+# find current contact information at www.suse.com.
+
+module Agama
+  module DBus
+    # This module offers classes to help to validate the expected types from a D-Bus call when
+    # variant types are involved, typically using dictionaries.
+    #
+    # @example
+    #   # Let's say there is a D-Bus method with the following signature:
+    #
+    #   dbus_method :Calculate, "in settings:a{sv}"
+    #
+    #   # The settings parameter will be transformed to a ruby Hash. This module provides a
+    #   # {Checker} class that helps to validate the expected types.
+    #
+    #   # Checks whether the value is a String
+    #   checker = Types::Checker.new(String)
+    #   checker.match?(settings["Foo"])
+    #
+    #   # Checks whether the value is bool
+    #   checker = Types::Checker.new(Types::BOOL)
+    #   checker.match?(settings["Foo"])
+    #
+    #   # Checks whether the value is an Array of String
+    #   checker = Types::Checker.new(Types::Array.new(String))
+    #   checker.match?(settings["Foo"])
+    #
+    #   # Checks whether the value is a Hash of String keys and Integer values
+    #   checker = Types::Checker.new(Types::Hash.new(k: String, v: Integer))
+    #   checker.match?(settings["Foo"])
+    #
+    # See {HashValidator} for validating hashes coming from D-Bus according to a scheme.
+    module Types
+      # Type representing a boolean (true or false).
+      BOOL = :bool
+
+      # Type representing an array of values.
+      class Array
+        # @return [Class, BOOL, Array, Hash, nil]
+        attr_reader :elements_type
+
+        # @param elements_type [Class, BOOL, Array, Hash, nil] The type of the elements in the
+        #   array. If nil, the type of the elements is not checked.
+        def initialize(elements_type = nil)
+          @elements_type = elements_type
+        end
+      end
+
+      # Type representing a hash.
+      class Hash
+        # @return [Class, BOOL, Array, Hash, nil]
+        attr_reader :keys_type
+
+        # @return [Class, BOOL, Array, Hash, nil]
+        attr_reader :values_type
+
+        # @param key [Class, BOOL, Array, Hash, nil] The type of keys. If nil, the type of the keys
+        #   is not checked.
+        # @param value [Class, BOOL, Array, Hash, nil] The type of values. If nil, the type of the
+        #   values is not checked.
+        def initialize(key: nil, value: nil)
+          @keys_type = key
+          @values_type = value
+        end
+      end
+
+      # Checks whether a value matches a type.
+      class Checker
+        # @param type [Class, BOOL, Array, Hash] The type to check.
+        def initialize(type)
+          @type = type
+        end
+
+        # Whether the given value matches the type.
+        #
+        # @param value [Object]
+        # @return [Boolean]
+        def match?(value)
+          case type
+          when BOOL
+            match_bool?(value)
+          when Agama::DBus::Types::Array
+            match_array?(value)
+          when Agama::DBus::Types::Hash
+            match_hash?(value)
+          when Class, Module
+            value.is_a?(type)
+          else
+            false
+          end
+        end
+
+      private
+
+        # @return [Class, BOOL, Array, Hash]
+        attr_reader :type
+
+        # Whether the value matches with {BOOL} type.
+        #
+        # @return [Boolean]
+        def match_bool?(value)
+          value.is_a?(TrueClass) || value.is_a?(FalseClass)
+        end
+
+        # Whether the value matches with {Array} type.
+        #
+        # @return [Boolean]
+        def match_array?(value)
+          return false unless value.is_a?(::Array)
+
+          if type.elements_type
+            checker = Checker.new(type.elements_type)
+            return value.all? { |v| checker.match?(v) }
+          end
+
+          true
+        end
+
+        # Whether the value matches with {Hash} type.
+        #
+        # @return [Boolean]
+        def match_hash?(value)
+          return false unless value.is_a?(::Hash)
+
+          if type.keys_type
+            checker = Checker.new(Types::Array.new(type.keys_type))
+            return false unless checker.match?(value.keys)
+          end
+
+          if type.values_type
+            checker = Checker.new(Types::Array.new(type.values_type))
+            return false unless checker.match?(value.values)
+          end
+
+          true
+        end
+      end
+    end
+  end
+end
diff --git a/service/lib/agama/storage/lvm_settings.rb b/service/lib/agama/storage/boot_settings.rb
similarity index 68%
rename from service/lib/agama/storage/lvm_settings.rb
rename to service/lib/agama/storage/boot_settings.rb
index 245ad27b45..4ef2e4dca8 100644
--- a/service/lib/agama/storage/lvm_settings.rb
+++ b/service/lib/agama/storage/boot_settings.rb
@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-# Copyright (c) [2023] SUSE LLC
+# Copyright (c) [2024] SUSE LLC
 #
 # All Rights Reserved.
 #
@@ -21,22 +21,21 @@
 
 module Agama
   module Storage
-    # Settings regarding LVM for the Agama storage proposal
-    class LvmSettings
-      # Whether to use LVM
+    # Class for configuring the boot settings of the Agama storage proposal.
+    class BootSettings
+      # Whether to configure partitions for booting.
       #
       # @return [Boolean]
-      attr_accessor :enabled
-      alias_method :enabled?, :enabled
+      attr_accessor :configure
+      alias_method :configure?, :configure
 
-      # Devices to use for the system LVM volume group
+      # Device to use for booting.
       #
-      # @return [Array<String>]
-      attr_accessor :system_vg_devices
+      # @return [String, nil]
+      attr_accessor :device
 
       def initialize
-        @enabled = false
-        @system_vg_devices = []
+        @configure = true
       end
     end
   end
diff --git a/service/lib/agama/storage/device_settings.rb b/service/lib/agama/storage/device_settings.rb
new file mode 100644
index 0000000000..ec44343cdc
--- /dev/null
+++ b/service/lib/agama/storage/device_settings.rb
@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+# Copyright (c) [2024] SUSE LLC
+#
+# All Rights Reserved.
+#
+# This program is free software; you can redistribute it and/or modify it
+# under the terms of version 2 of the GNU General Public License as published
+# by the Free Software Foundation.
+#
+# This program is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+# FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+# more details.
+#
+# You should have received a copy of the GNU General Public License along
+# with this program; if not, contact SUSE LLC.
+#
+# To contact SUSE LLC about this file by physical or electronic mail, you may
+# find current contact information at www.suse.com.
+
+module Agama
+  module Storage
+    # Module for the settings to configure the device of the Agama storage proposal.
+    module DeviceSettings
+      # Class to be used when the target device is a disk.
+      class Disk
+        # Name of the device to use.
+        #
+        # @return [String, nil]
+        attr_accessor :name
+
+        # @param name [String, nil]
+        def initialize(name = nil)
+          @name = name
+        end
+      end
+
+      # Class to be used when the target device is a reused LVM volume group.
+      class ReusedLvmVg
+        # Name of the LVM volume group to reuse.
+        #
+        # @return [String, nil]
+        attr_accessor :name
+
+        # @param name [String, nil]
+        def initialize(name = nil)
+          @name = name
+        end
+      end
+
+      # Class to be used when the target device is a new LVM volume group.
+      class NewLvmVg
+        # List of candidate devices to create physical volumes.
+        #
+        # @return [Array<String>]
+        attr_accessor :candidate_pv_devices
+
+        # @param candidates [Array<String>]
+        def initialize(candidates = [])
+          @candidate_pv_devices = candidates
+        end
+      end
+    end
+  end
+end
diff --git a/service/lib/agama/storage/proposal.rb b/service/lib/agama/storage/proposal.rb
index 0b3d546dc3..ec6c63b1f5 100644
--- a/service/lib/agama/storage/proposal.rb
+++ b/service/lib/agama/storage/proposal.rb
@@ -19,18 +19,32 @@
 # To contact SUSE LLC about this file by physical or electronic mail, you may
 # find current contact information at www.suse.com.
 
-require "y2storage"
 require "agama/issue"
 require "agama/storage/actions"
+require "agama/storage/device_settings"
 require "agama/storage/proposal_settings_conversion"
+require "yast"
+require "y2storage"
 
 module Agama
   module Storage
     # Backend class to calculate a storage proposal.
     class Proposal
+      include Yast::I18n
+
+      # Settings used for calculating the proposal.
+      #
+      # @note Some values are recoverd from Y2Storage, see
+      #   {ProposalSettingsConversion::FromY2Storage}
+      #
+      # @return [ProposalSettings, nil] nil if no proposal has been calculated yet.
+      attr_reader :settings
+
       # @param config [Config] Agama config
       # @param logger [Logger]
       def initialize(config, logger: nil)
+        textdomain "agama"
+
         @config = config
         @logger = logger || Logger.new($stdout)
         @on_calculate_callbacks = []
@@ -60,40 +74,16 @@ def available_devices
       # @param settings [Agamal::Storage::ProposalSettings] settings to calculate the proposal.
       # @return [Boolean] whether the proposal was correctly calculated.
       def calculate(settings)
-        # Use the first available device if no boot device is indicated.
-        settings.boot_device ||= available_devices.first&.name
-
-        @original_settings = settings
+        select_target_device(settings) if missing_target_device?(settings)
 
         calculate_proposal(settings)
 
+        @settings = ProposalSettingsConversion.from_y2storage(proposal.settings, settings)
         @on_calculate_callbacks.each(&:call)
 
         success?
       end
 
-      # Settings used for calculating the proposal.
-      #
-      # Note that this settings might differ from the {#original_settings}. For example, the sizes
-      # of some volumes could be adjusted if auto size is set.
-      #
-      # @return [ProposalSettings, nil] nil if no proposal has been calculated yet.
-      def settings
-        return nil unless calculated?
-
-        ProposalSettingsConversion.from_y2storage(
-          proposal.settings,
-          config: config
-        ).tap do |settings|
-          # The conversion from Y2Storage cannot infer the space policy. Copying space policy from
-          # the original settings.
-          settings.space.policy = original_settings.space.policy
-          # FIXME: The conversion from Y2Storage cannot reliably infer the system VG devices in all
-          #   cases. Copying system VG devices from the original settings.
-          settings.lvm.system_vg_devices = original_settings.lvm.system_vg_devices
-        end
-      end
-
       # Storage actions.
       #
       # @return [Array<Y2Storage::CompoundAction>]
@@ -110,7 +100,7 @@ def issues
         return [] if !calculated? || success?
 
         [
-          boot_device_issue,
+          target_device_issue,
           missing_devices_issue,
           proposal_issue
         ].compact
@@ -124,11 +114,6 @@ def issues
       # @return [Logger]
       attr_reader :logger
 
-      # Settings originally used for calculating the proposal (without conversion from Y2Storage).
-      #
-      # @return [Agama::Storage::ProposalSettings]
-      attr_reader :original_settings
-
       # @return [Y2Storage::MinGuidedProposal, nil]
       def proposal
         storage_manager.proposal
@@ -141,6 +126,36 @@ def calculated?
         !proposal.nil?
       end
 
+      # Selects the first available device as target device for installation.
+      #
+      # @param settings [ProposalSettings]
+      def select_target_device(settings)
+        device = available_devices.first&.name
+        return unless device
+
+        case settings.device
+        when DeviceSettings::Disk
+          settings.device.name = device
+        when DeviceSettings::NewLvmVg
+          settings.device.candidate_pv_devices = [device]
+        when DeviceSettings::ReusedLvmVg
+          # TODO: select an existing VG?
+        end
+      end
+
+      # Whether the given settings has no target device for the installation.
+      #
+      # @param settings [ProposalSettings]
+      # @return [Boolean]
+      def missing_target_device?(settings)
+        case settings.device
+        when DeviceSettings::Disk, DeviceSettings::ReusedLvmVg
+          settings.device.name.nil?
+        when DeviceSettings::NewLvmVg
+          settings.device.candidate_pv_devices.empty?
+        end
+      end
+
       # Instantiates and executes a Y2Storage proposal with the given settings
       #
       # @param settings [Y2Storage::ProposalSettings]
@@ -171,13 +186,13 @@ def storage_manager
         Y2Storage::StorageManager.instance
       end
 
-      # Returns an issue if there is no boot device.
+      # Returns an issue if there is no target device.
       #
       # @return [Issue, nil]
-      def boot_device_issue
-        return if settings.boot_device
+      def target_device_issue
+        return unless missing_target_device?(settings)
 
-        Issue.new("No device selected for installation",
+        Issue.new(_("No device selected for installation"),
           source:   Issue::Source::CONFIG,
           severity: Issue::Severity::ERROR)
       end
@@ -186,13 +201,23 @@ def boot_device_issue
       #
       # @return [Issue, nil]
       def missing_devices_issue
-        # At this moment, only the boot device is checked.
-        return unless settings.boot_device
-        return if available_devices.map(&:name).include?(settings.boot_device)
-
-        Issue.new("Selected device is not found in the system",
+        available = available_devices.map(&:name)
+        missing = settings.installation_devices.reject { |d| available.include?(d) }
+
+        return if missing.none?
+
+        Issue.new(
+          format(
+            n_(
+              "The following selected device is not found in the system: %{devices}",
+              "The following selected devices are not found in the system: %{devices}",
+              missing.size
+            ),
+            devices: missing.join(", ")
+          ),
           source:   Issue::Source::CONFIG,
-          severity: Issue::Severity::ERROR)
+          severity: Issue::Severity::ERROR
+        )
       end
 
       # Returns an issue if the proposal is not valid.
@@ -201,7 +226,7 @@ def missing_devices_issue
       def proposal_issue
         return if success?
 
-        Issue.new("Cannot accommodate the required file systems for installation",
+        Issue.new(_("Cannot accommodate the required file systems for installation"),
           source:   Issue::Source::CONFIG,
           severity: Issue::Severity::ERROR)
       end
diff --git a/service/lib/agama/storage/proposal_settings.rb b/service/lib/agama/storage/proposal_settings.rb
index c0e237de50..77e142dda7 100644
--- a/service/lib/agama/storage/proposal_settings.rb
+++ b/service/lib/agama/storage/proposal_settings.rb
@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-# Copyright (c) [2022-2023] SUSE LLC
+# Copyright (c) [2022-2024] SUSE LLC
 #
 # All Rights Reserved.
 #
@@ -19,7 +19,8 @@
 # To contact SUSE LLC about this file by physical or electronic mail, you may
 # find current contact information at www.suse.com.
 
-require "agama/storage/lvm_settings"
+require "agama/storage/boot_settings"
+require "agama/storage/device_settings"
 require "agama/storage/encryption_settings"
 require "agama/storage/space_settings"
 
@@ -27,38 +28,94 @@ module Agama
   module Storage
     # Settings used to calculate an storage proposal.
     class ProposalSettings
-      # Configuration of LVM
+      # Target device settings.
       #
-      # @return [LvmSettings]
-      attr_reader :lvm
+      # @return [DeviceSettings::Disk, DeviceSettings::NewLvmVg, DeviceSettings::ReusedLvmVg]
+      attr_accessor :device
 
-      # Encryption settings
+      # Boot settings.
       #
-      # @return [EncryptionSettings]
-      attr_reader :encryption
+      # @return [BootSettings]
+      attr_accessor :boot
 
-      # Settings to configure the behavior when making space to allocate the new partitions
+      # Encryption settings.
       #
-      # @return [SpaceSettings]
-      attr_reader :space
+      # @return [EncryptionSettings]
+      attr_accessor :encryption
 
-      # Device name of the disk that will be used for booting the system and also to allocate all
-      # the partitions, except those that have been explicitly assigned to other disk(s).
+      # Settings to configure the behavior when making space to allocate the new partitions.
       #
-      # @return [String, nil] nil if no device has been selected yet.
-      attr_accessor :boot_device
+      # @return [SpaceSettings]
+      attr_accessor :space
 
-      # Set of volumes to create
+      # Set of volumes to create.
       #
       # @return [Array<Volume>]
       attr_accessor :volumes
 
       def initialize
-        @lvm = LvmSettings.new
+        @device = DeviceSettings::Disk.new
+        @boot = BootSettings.new
         @encryption = EncryptionSettings.new
         @space = SpaceSettings.new
         @volumes = []
       end
+
+      # All devices involved in the installation.
+      #
+      # @return [Array<String>]
+      def installation_devices
+        [boot_device, target_devices, volume_devices]
+          .flatten
+          .compact
+          .uniq
+      end
+
+      # Default device to use for configuring boot.
+      #
+      # @return [String, nil]
+      def default_boot_device
+        case device
+        when DeviceSettings::Disk
+          device.name
+        when DeviceSettings::NewLvmVg
+          device.candidate_pv_devices.min
+        when DeviceSettings::ReusedLvmVg
+          # TODO: Decide what device to use.
+        end
+      end
+
+    private
+
+      # Device used for booting.
+      #
+      # @return [String, nil]
+      def boot_device
+        return nil unless boot.configure?
+
+        boot.device
+      end
+
+      # Target devices for the installation depending on the device settings.
+      #
+      # @return [Array<String>]
+      def target_devices
+        case device
+        when DeviceSettings::Disk, DeviceSettings::ReusedLvmVg
+          [device.name].compact
+        when DeviceSettings::NewLvmVg
+          device.candidate_pv_devices
+        else
+          []
+        end
+      end
+
+      # Devices directly assigned to the volumes.
+      #
+      # @return [Array<String>]
+      def volume_devices
+        volumes.map(&:location).reject(&:reuse_device?).map(&:device)
+      end
     end
   end
 end
diff --git a/service/lib/agama/storage/proposal_settings_conversion.rb b/service/lib/agama/storage/proposal_settings_conversion.rb
index 56e860a396..f8439c7531 100644
--- a/service/lib/agama/storage/proposal_settings_conversion.rb
+++ b/service/lib/agama/storage/proposal_settings_conversion.rb
@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-# Copyright (c) [2023] SUSE LLC
+# Copyright (c) [2023-2024] SUSE LLC
 #
 # All Rights Reserved.
 #
@@ -26,17 +26,17 @@ module Agama
   module Storage
     # Conversions for the proposal settings.
     module ProposalSettingsConversion
-      # Performs conversion from Y2Storage format.
+      # Performs conversion from Y2Storage.
       #
-      # @param settings [Y2Storage::ProposalSettings]
-      # @param config [Agama::Config]
+      # @param y2storage_settings [Y2Storage::ProposalSettings]
+      # @param settings [Agama::Storage::ProposalSettings]
       #
       # @return [Agama::Storage::ProposalSettings]
-      def self.from_y2storage(settings, config:)
-        FromY2Storage.new(settings, config: config).convert
+      def self.from_y2storage(y2storage_settings, settings)
+        FromY2Storage.new(y2storage_settings, settings).convert
       end
 
-      # Performs conversion to Y2Storage format.
+      # Performs conversion to Y2Storage.
       #
       # @param settings [Agama::Storage::ProposalSettings]
       # @param config [Agama::Config]
diff --git a/service/lib/agama/storage/proposal_settings_conversion/from_y2storage.rb b/service/lib/agama/storage/proposal_settings_conversion/from_y2storage.rb
index a60a0c59a3..475e53e25c 100644
--- a/service/lib/agama/storage/proposal_settings_conversion/from_y2storage.rb
+++ b/service/lib/agama/storage/proposal_settings_conversion/from_y2storage.rb
@@ -19,30 +19,32 @@
 # To contact SUSE LLC about this file by physical or electronic mail, you may
 # find current contact information at www.suse.com.
 
-require "agama/storage/proposal_settings"
 require "agama/storage/volume_conversion"
 
 module Agama
   module Storage
     module ProposalSettingsConversion
-      # Proposal settings conversion from Y2Storage format.
+      # Proposal settings conversion from Y2Storage.
+      #
+      # @note This class does not perform a real conversion from Y2Storage settings. Instead of
+      #   that, it copies the given settings and recovers some values from Y2Storage.
+      #   A real conversion is not needed because the original settings are always available.
+      #   Moreover, Agama introduces some concepts that do not exist in the Y2Storage settings
+      #   (e.g., target, boot device or space policy), which could be impossible to infer.
       class FromY2Storage
-        # @param settings [Y2Storage::ProposalSettings]
-        # @param config [Agama::Config]
-        def initialize(settings, config:)
+        # @param y2storage_settings [Y2Storage::ProposalSettings]
+        # @param settings [Agama::Storage::ProposalSettings] Settings to be copied and modified.
+        def initialize(y2storage_settings, settings)
+          @y2storage_settings = y2storage_settings
           @settings = settings
-          @config = config
         end
 
-        # Performs the conversion from Y2Storage format.
+        # Performs the conversion from Y2Storage.
         #
         # @return [Agama::Storage::ProposalSettings]
         def convert
-          ProposalSettings.new.tap do |target|
-            boot_device_conversion(target)
-            lvm_conversion(target)
-            encryption_conversion(target)
-            space_settings_conversion(target)
+          settings.dup.tap do |target|
+            space_actions_conversion(target)
             volumes_conversion(target)
           end
         end
@@ -50,82 +52,32 @@ def convert
       private
 
         # @return [Y2Storage::ProposalSettings]
-        attr_reader :settings
-
-        # @return [Agama::Config]
-        attr_reader :config
-
-        # @param target [Agama::Storage::ProposalSettings]
-        def boot_device_conversion(target)
-          target.boot_device = settings.root_device
-        end
-
-        # @param target [Agama::Storage::ProposalSettings]
-        def lvm_conversion(target)
-          target.lvm.enabled = settings.lvm
-
-          # FIXME: The candidate devices list represents the system VG devices if it contains any
-          #   device different to the root device. If the candidate devices only contains the root
-          #   device, then there is no way to know whether the root device was explicitly assigned
-          #   as system VG device. Note that candidate devices will also contain the root device
-          #   when the system VG devices list was empty.
-          candidate_devices = settings.candidate_devices || []
-          return unless candidate_devices.reject { |d| d == settings.root_device }.any?
+        attr_reader :y2storage_settings
 
-          target.lvm.system_vg_devices = settings.candidate_devices
-        end
-
-        # @param target [Agama::Storage::ProposalSettings]
-        def encryption_conversion(target)
-          target.encryption.password = settings.encryption_password
-          target.encryption.method = settings.encryption_method
-          target.encryption.pbkd_function = settings.encryption_pbkdf
-        end
+        # @return [Agama::Storage::ProposalSettings]
+        attr_reader :settings
 
-        # @note The space policy cannot be inferred from Y2Storage settings.
+        # Recovers space actions.
+        #
+        # @note Space actions are generated in the conversion of the settings to Y2Storage format,
+        #   see {ProposalSettingsConversion::ToY2Storage}.
+        #
         # @param target [Agama::Storage::ProposalSettings]
-        def space_settings_conversion(target)
-          target.space.actions = settings.space_settings.actions
+        def space_actions_conversion(target)
+          target.space.actions = y2storage_settings.space_settings.actions
         end
 
+        # Some values of the volumes have to be recovered from Y2Storage proposal.
+        #
         # @param target [Agama::Storage::ProposalSettings]
         def volumes_conversion(target)
-          target.volumes = volumes.select(&:proposed?).map do |spec|
-            VolumeConversion.from_y2storage(spec, config: config)
-          end
-
-          fallbacks_conversion(target)
-        end
-
-        # @param target [Agama::Storage::ProposalSettings]
-        def fallbacks_conversion(target)
-          target.volumes.each do |volume|
-            volume.min_size_fallback_for = volumes_with_min_size_fallback(volume.mount_path)
-            volume.max_size_fallback_for = volumes_with_max_size_fallback(volume.mount_path)
-          end
-        end
-
-        # @param mount_path [String]
-        # @return [Array<String>]
-        def volumes_with_min_size_fallback(mount_path)
-          specs = volumes.select { |s| s.fallback_for_min_size == mount_path }
-          specs.map(&:mount_point)
+          target.volumes = target.volumes.map { |v| volume_conversion(v) }
         end
 
-        # @param mount_path [String]
-        # @return [Array<String>]
-        def volumes_with_max_size_fallback(mount_path)
-          specs = volumes.select { |s| s.fallback_for_max_size == mount_path }
-          specs.map(&:mount_point)
-        end
-
-        # Volumes from settings.
-        #
-        # Note that volumes might be nil in Y2Storage settings.
-        #
-        # @return [Array<Y2Storage::VolumeSpecification>]
-        def volumes
-          settings.volumes || []
+        # @param volume [Agama::Storage::Volume]
+        # @return [Agama::Storage::Volume]
+        def volume_conversion(volume)
+          VolumeConversion.from_y2storage(volume)
         end
       end
     end
diff --git a/service/lib/agama/storage/proposal_settings_conversion/to_y2storage.rb b/service/lib/agama/storage/proposal_settings_conversion/to_y2storage.rb
index 0f695d0774..c38add3cf5 100644
--- a/service/lib/agama/storage/proposal_settings_conversion/to_y2storage.rb
+++ b/service/lib/agama/storage/proposal_settings_conversion/to_y2storage.rb
@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-# Copyright (c) [2023] SUSE LLC
+# Copyright (c) [2023-2024] SUSE LLC
 #
 # All Rights Reserved.
 #
@@ -20,13 +20,14 @@
 # find current contact information at www.suse.com.
 
 require "y2storage"
+require "agama/storage/device_settings"
 require "agama/storage/volume_conversion"
 require "agama/storage/volume_templates_builder"
 
 module Agama
   module Storage
     module ProposalSettingsConversion
-      # Proposal settings conversion to Y2Storage format.
+      # Proposal settings conversion to Y2Storage.
       class ToY2Storage
         # @param settings [Agama::Storage::ProposalSettings]
         # @param config [Agama::Config]
@@ -35,7 +36,7 @@ def initialize(settings, config:)
           @config = config
         end
 
-        # Performs the conversion to Y2Storage format.
+        # Performs the conversion to Y2Storage.
         #
         # @return [Y2Storage::ProposalSettings]
         def convert
@@ -43,9 +44,8 @@ def convert
           # generic default values that are independent of the product (there is no YaST
           # ProductFeatures mechanism in place).
           Y2Storage::ProposalSettings.new_for_current_product.tap do |target|
-            boot_device_conversion(target)
-            candidate_devices_conversion(target)
-            lvm_conversion(target)
+            device_conversion(target)
+            boot_conversion(target)
             encryption_conversion(target)
             space_policy_conversion(target)
             volumes_conversion(target)
@@ -61,32 +61,56 @@ def convert
         attr_reader :config
 
         # @param target [Y2Storage::ProposalSettings]
-        def boot_device_conversion(target)
-          target.root_device = settings.boot_device
+        def device_conversion(target)
+          device_settings = settings.device
+
+          case device_settings
+          when DeviceSettings::Disk
+            disk_device_conversion(target)
+          when DeviceSettings::NewLvmVg
+            new_lvm_vg_device_conversion(target, device_settings)
+          when DeviceSettings::ReusedLvmVg
+            reused_lvm_vg_device_conversion(target, device_settings)
+          end
         end
 
         # @param target [Y2Storage::ProposalSettings]
-        def candidate_devices_conversion(target)
-          candidate_devices = []
-
-          if settings.lvm.enabled? && settings.lvm.system_vg_devices.any?
-            candidate_devices = settings.lvm.system_vg_devices
-          elsif settings.boot_device
-            candidate_devices = [settings.boot_device]
-          end
+        def disk_device_conversion(target)
+          target.lvm = false
+          target.candidate_devices = [boot_device].compact
+        end
 
-          target.candidate_devices = candidate_devices
+        # @param target [Y2Storage::ProposalSettings]
+        # @param device_settings [DeviceSettings::NewLvmVg]
+        def new_lvm_vg_device_conversion(target, device_settings)
+          enable_lvm(target)
+          target.candidate_devices = device_settings.candidate_pv_devices
         end
 
         # @param target [Y2Storage::ProposalSettings]
-        def lvm_conversion(target)
-          lvm = settings.lvm.enabled?
+        # @param _device_settings [DeviceSettings::ReusedLvmVg]
+        def reused_lvm_vg_device_conversion(target, _device_settings)
+          enable_lvm(target)
+          # TODO: Sets the reused VG (not supported by yast2-storage-ng yet).
+          # TODO: Decide what to consider as candidate devices.
+          target.candidate_devices = []
+        end
 
-          target.lvm = lvm
-          # Activate support for dedicated volume groups
+        # @param target [Y2Storage::ProposalSettings]
+        def enable_lvm(target)
+          target.lvm = true
+          # Activate support for dedicated volume groups.
           target.separate_vgs = true
           # Prevent VG reuse
           target.lvm_vg_reuse = false
+          # Create VG as big as needed to allocate the LVs.
+          target.lvm_vg_strategy = :use_needed
+        end
+
+        # @param target [Y2Storage::ProposalSettings]
+        def boot_conversion(target)
+          target.boot = settings.boot.configure?
+          target.root_device = boot_device
         end
 
         # @param target [Y2Storage::ProposalSettings]
@@ -119,12 +143,14 @@ def volumes_conversion(target)
           target.swap_reuse = :none
 
           volumes = settings.volumes.map { |v| VolumeConversion.to_y2storage(v) }
+
           disabled_volumes = missing_volumes.map do |volume|
             VolumeConversion.to_y2storage(volume).tap { |v| v.proposed = false }
           end
 
           target.volumes = volumes + disabled_volumes
 
+          volume_device_conversion(target)
           fallbacks_conversion(target)
         end
 
@@ -137,6 +163,15 @@ def missing_volumes
             .reject { |t| t.mount_path.empty? }
         end
 
+        # Assigns the target device if needed.
+        #
+        # @param target [Y2Storage::ProposalSettings]
+        def volume_device_conversion(target)
+          return unless settings.device.is_a?(DeviceSettings::Disk)
+
+          target.volumes.select(&:proposed?).each { |v| v.device ||= settings.device.name }
+        end
+
         # @param target [Y2Storage::ProposalSettings]
         def fallbacks_conversion(target)
           target.volumes.each do |spec|
@@ -161,19 +196,24 @@ def find_max_size_fallback(mount_path)
           volume&.mount_path
         end
 
+        # Device used for booting.
+        #
+        # @return [String, nil]
+        def boot_device
+          settings.boot.device || settings.default_boot_device
+        end
+
         # All block devices affected by the space policy.
         #
-        # This includes the partitions from the boot device, the candidate devices and from the
-        # devices directly assigned to a volume as target device. If a device is not partitioned,
-        # then the device itself is included.
+        # @see ProposalSettings#installation_devices
+        #
+        # If a device is partitioned, then its partitions are included instead of the device.
         #
         # @return [Array<String>]
         def all_devices
-          devices = [settings.boot_device] +
-            settings.lvm.system_vg_devices +
-            settings.volumes.map(&:location).reject(&:reuse_device?).map(&:device)
-
-          devices.compact.uniq.map { |d| device_or_partitions(d) }.flatten
+          settings.installation_devices
+            .map { |d| device_or_partitions(d) }
+            .flatten
         end
 
         # @param device [String]
diff --git a/service/lib/agama/storage/proposal_settings_reader.rb b/service/lib/agama/storage/proposal_settings_reader.rb
index fff9245e9e..e0c038fd6f 100644
--- a/service/lib/agama/storage/proposal_settings_reader.rb
+++ b/service/lib/agama/storage/proposal_settings_reader.rb
@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-# Copyright (c) [2023] SUSE LLC
+# Copyright (c) [2023-2024] SUSE LLC
 #
 # All Rights Reserved.
 #
@@ -19,10 +19,11 @@
 # To contact SUSE LLC about this file by physical or electronic mail, you may
 # find current contact information at www.suse.com.
 
+require "agama/storage/device_settings"
+require "agama/storage/space_settings"
+require "agama/storage/volume_templates_builder"
 require "y2storage/encryption_method"
 require "y2storage/pbkd_function"
-require "agama/storage/volume_templates_builder"
-require "agama/storage/space_settings"
 
 module Agama
   module Storage
@@ -63,7 +64,9 @@ def read
       # @param settings [Agama::Storage::ProposalSettings]
       # @param value [Boolean]
       def lvm_reader(settings, value)
-        settings.lvm.enabled = value
+        return unless value
+
+        settings.device = DeviceSettings::NewLvmVg.new
       end
 
       # @param settings [Agama::Storage::ProposalSettings]
diff --git a/service/lib/agama/storage/volume_conversion.rb b/service/lib/agama/storage/volume_conversion.rb
index 73ca398f91..432f39034f 100644
--- a/service/lib/agama/storage/volume_conversion.rb
+++ b/service/lib/agama/storage/volume_conversion.rb
@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-# Copyright (c) [2023] SUSE LLC
+# Copyright (c) [2023-2024] SUSE LLC
 #
 # All Rights Reserved.
 #
@@ -26,17 +26,15 @@ module Agama
   module Storage
     # Conversions for a volume
     module VolumeConversion
-      # Performs conversion from Y2Storage format.
-      #
-      # @param spec [Y2Storage::VolumeSpecification]
-      # @param config [Agama::Config]
+      # Performs conversion from Y2Storage.
       #
+      # @param volume [Agama::Storage::Volume]
       # @return [Agama::Storage::Volume]
-      def self.from_y2storage(spec, config:)
-        FromY2Storage.new(spec, config: config).convert
+      def self.from_y2storage(volume)
+        FromY2Storage.new(volume).convert
       end
 
-      # Performs conversion to Y2Storage format.
+      # Performs conversion to Y2Storage.
       #
       # @param volume [Agama::Storage::Volume]
       # @return [Y2Storage::VolumeSpecification]
diff --git a/service/lib/agama/storage/volume_conversion/from_y2storage.rb b/service/lib/agama/storage/volume_conversion/from_y2storage.rb
index e881a0f26a..d7f1b93226 100644
--- a/service/lib/agama/storage/volume_conversion/from_y2storage.rb
+++ b/service/lib/agama/storage/volume_conversion/from_y2storage.rb
@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-# Copyright (c) [2023] SUSE LLC
+# Copyright (c) [2023-2024] SUSE LLC
 #
 # All Rights Reserved.
 #
@@ -20,91 +20,51 @@
 # find current contact information at www.suse.com.
 
 require "y2storage/storage_manager"
-require "agama/storage/volume_templates_builder"
 
 module Agama
   module Storage
     module VolumeConversion
-      # Volume conversion from Y2Storage format.
+      # Volume conversion from Y2Storage.
+      #
+      # @note This class does not perform a real conversion from Y2Storage. Instead of that, it
+      #   copies the given volume and recovers some values from Y2Storage.
       class FromY2Storage
-        # @param spec [Y2Storage::VolumeSpecification]
-        # @param config [Agama::Config]
-        def initialize(spec, config:)
-          @spec = spec
-          @config = config
+        # @param volume [Agama::Storage::ProposalSettings]
+        def initialize(volume)
+          @volume = volume
         end
 
-        # Performs the conversion from Y2Storage format.
+        # Performs the conversion from Y2Storage.
         #
         # @return [Agama::Storage::Volume]
         def convert
-          volume = VolumeTemplatesBuilder.new_from_config(config).for(spec.mount_point || "")
-
-          volume.tap do |target|
-            target.mount_options = spec.mount_options
-            target.fs_type = spec.fs_type
-
+          volume.dup.tap do |target|
             sizes_conversion(target)
-            btrfs_conversion(target)
-            location_conversion(target)
           end
         end
 
       private
 
-        # @return [Y2Storage::VolumeSpecification]
-        attr_reader :spec
-
-        # @return [Agama::Config]
-        attr_reader :config
+        # @return [Agama::Storage::ProposalSettings]
+        attr_reader :volume
 
         # @param target [Agama::Storage::Volume]
         def sizes_conversion(target)
-          target.auto_size = auto_size?
-
-          # The volume specification contains the min and max sizes for the volume. But the final
-          # range of sizes used by the Y2Storage proposal depends on the fallback sizes (if this
-          # volume is fallback for other volume) and the size for snapshots (if snapshots is
-          # active). The planned device contains the real range of sizes used by the proposal.
+          # The final range of sizes used by the Y2Storage proposal depends on the fallback sizes
+          # (if this volume is fallback for other volume) and the size for snapshots (if snapshots
+          # is active). The planned device contains the real range of sizes used by the proposal.
           #
           # From Agama point of view, this is the way of recovering the range of sizes used by
           # Y2Storage when a volume is set to have auto size.
-          planned = planned_device_for(spec.mount_point)
-          target.min_size = planned&.min || spec.min_size
-          target.max_size = planned&.max || spec.max_size
-        end
+          planned = planned_device_for(target.mount_path)
+          return unless planned
 
-        # @see #sizes_conversion
-        #
-        # @return [Boolean]
-        def auto_size?
-          # The three ignore_xxx attributes (ignore_snapshots_sizes, ignore_fallback_sizes and
-          # ignore_adjust_by_ram) are always in sync and always initialized to the inverse of
-          # #auto_size
-          !spec.ignore_fallback_sizes?
-        end
-
-        # @param target [Agama::Storage::Volume]
-        def btrfs_conversion(target)
-          target.btrfs.snapshots = spec.snapshots?
-          target.btrfs.subvolumes = spec.subvolumes
-          target.btrfs.default_subvolume = spec.btrfs_default_subvolume
-          target.btrfs.read_only = spec.btrfs_read_only
-        end
-
-        # @param target [Agama::Storage::Volume]
-        def location_conversion(target)
-          if spec.reuse?
-            target.location.target = spec.reformat? ? :device : :filesystem
-            target.location.device = spec.reuse_name
-          elsif !!spec.device
-            target.location.target = spec.separate_vg? ? :new_vg : :new_partition
-            target.location.device = spec.device
-          end
+          target.min_size = planned.min
+          target.max_size = planned.max
         end
 
         # Planned device for the given mount path.
-
+        #
         # @param mount_path [String]
         # @return [Y2Storage::Planned::Device, nil]
         def planned_device_for(mount_path)
diff --git a/service/lib/agama/storage/volume_conversion/to_y2storage.rb b/service/lib/agama/storage/volume_conversion/to_y2storage.rb
index 9c00bcd1e0..dd258c3bce 100644
--- a/service/lib/agama/storage/volume_conversion/to_y2storage.rb
+++ b/service/lib/agama/storage/volume_conversion/to_y2storage.rb
@@ -25,14 +25,14 @@
 module Agama
   module Storage
     module VolumeConversion
-      # Volume conversion to Y2Storage format.
+      # Volume conversion to Y2Storage.
       class ToY2Storage
         # @param volume [Agama::Storage::Volume]
         def initialize(volume)
           @volume = volume
         end
 
-        # Performs the conversion to Y2Storage format.
+        # Performs the conversion to Y2Storage.
         #
         # @return [Y2Storage::VolumeSpecification]
         def convert # rubocop:disable Metrics/AbcSize
diff --git a/service/package/rubygem-agama-yast.changes b/service/package/rubygem-agama-yast.changes
index 2168eafe66..1e8f813afa 100644
--- a/service/package/rubygem-agama-yast.changes
+++ b/service/package/rubygem-agama-yast.changes
@@ -1,3 +1,11 @@
+-------------------------------------------------------------------
+Wed Apr  3 15:12:05 UTC 2024 - José Iván López González <jlopez@suse.com>
+
+- Add new proposal settings to allow configuring the boot device
+  and to select different scenarios for the installation device:
+  a disk, a new LVM volume group or reuse an LVM volume group
+  (gh#openSUSE/agama#1068).
+
 -------------------------------------------------------------------
 Fri Mar 22 09:18:20 UTC 2024 - Ancor Gonzalez Sosa <ancor@suse.com>
 
diff --git a/service/test/agama/dbus/hash_validator_test.rb b/service/test/agama/dbus/hash_validator_test.rb
new file mode 100644
index 0000000000..69b995af31
--- /dev/null
+++ b/service/test/agama/dbus/hash_validator_test.rb
@@ -0,0 +1,197 @@
+# frozen_string_literal: true
+
+# Copyright (c) [2024] SUSE LLC
+#
+# All Rights Reserved.
+#
+# This program is free software; you can redistribute it and/or modify it
+# under the terms of version 2 of the GNU General Public License as published
+# by the Free Software Foundation.
+#
+# This program is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+# FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+# more details.
+#
+# You should have received a copy of the GNU General Public License along
+# with this program; if not, contact SUSE LLC.
+#
+# To contact SUSE LLC about this file by physical or electronic mail, you may
+# find current contact information at www.suse.com.
+
+require_relative "../../test_helper"
+require "agama/dbus/hash_validator"
+require "agama/dbus/types"
+
+describe Agama::DBus::HashValidator do
+  subject { described_class.new(value, scheme: scheme) }
+
+  let(:scheme) do
+    {
+      "Name"     => String,
+      "Surname"  => Agama::DBus::Types::Array.new(String),
+      "Age"      => Integer,
+      "Height"   => Integer,
+      "Children" => Array
+    }
+  end
+
+  describe "#valid?" do
+    context "if there is any key with unexpected type" do
+      let(:value) do
+        {
+          "Gender" => "Male",
+          "Height" => true
+        }
+      end
+
+      it "returns false" do
+        expect(subject.valid?).to eq(false)
+      end
+    end
+
+    context "if there is no key with unexpected type" do
+      let(:value) do
+        {
+          "Name"   => "John",
+          "Gender" => "Male",
+          "Height" => 175
+        }
+      end
+
+      it "returns true" do
+        expect(subject.valid?).to eq(true)
+      end
+    end
+  end
+
+  describe "#valid_keys" do
+    let(:value) do
+      {
+        "Name"     => "John",
+        "Gender"   => "Male",
+        "Age"      => 45,
+        "Height"   => true,
+        "Children" => ["Mark", "Zara"]
+      }
+    end
+
+    it "returns the hash keys defined in the scheme and with the type indicated in the scheme" do
+      expect(subject.valid_keys).to eq(["Name", "Age", "Children"])
+    end
+  end
+
+  describe "#wrong_type_keys" do
+    context "if the hash contains the same types as the scheme" do
+      let(:value) do
+        {
+          "Name"     => "John",
+          "Age"      => 45,
+          "Children" => ["Mark", "Zara"]
+        }
+      end
+
+      it "returns an empty list" do
+        expect(subject.wrong_type_keys).to eq([])
+      end
+    end
+
+    context "if the hash contains types different to the scheme" do
+      let(:value) do
+        {
+          "Name"     => true,
+          "Age"      => 45,
+          "Children" => "none"
+        }
+      end
+
+      it "returns the keys with wrong type" do
+        expect(subject.wrong_type_keys).to eq(["Name", "Children"])
+      end
+    end
+  end
+
+  describe "#extra_keys" do
+    context "if the hash does not contain keys that are not included in the scheme" do
+      let(:value) do
+        {
+          "Name"     => "Jhon",
+          "Children" => []
+        }
+      end
+
+      it "returns an empty list" do
+        expect(subject.extra_keys).to eq([])
+      end
+    end
+
+    context "if the hash contains some keys that are not included in the scheme" do
+      let(:value) do
+        {
+          "Name"     => "Jhon",
+          "Gender"   => "Male",
+          "Birthday" => nil,
+          "Children" => []
+        }
+      end
+
+      it "returns a list with the extra keys" do
+        expect(subject.extra_keys).to eq(["Gender", "Birthday"])
+      end
+    end
+  end
+
+  describe "#missing_keys" do
+    context "if the hash contains all the keys defined in the scheme" do
+      let(:value) do
+        {
+          "Name"     => "Jhon",
+          "Surname"  => [],
+          "Age"      => 45,
+          "Height"   => 176,
+          "Children" => []
+        }
+      end
+
+      it "returns an empty list" do
+        expect(subject.missing_keys).to eq([])
+      end
+    end
+
+    context "if the hash does not contain any of the keys defined in the scheme" do
+      let(:value) do
+        {
+          "Surname" => [],
+          "Age"     => 45,
+          "Height"  => 176
+        }
+      end
+
+      it "returns a list with the missing keys" do
+        expect(subject.missing_keys).to eq(["Name", "Children"])
+      end
+    end
+  end
+
+  describe "#issues" do
+    let(:value) do
+      {
+        "Name"     => "John",
+        "Age"      => 45,
+        "Gender"   => "Male",
+        "Birthday" => nil,
+        "Height"   => "175",
+        "Children" => {}
+      }
+    end
+
+    it "generates an issue for each extra key and for each wrong type" do
+      expect(subject.issues).to contain_exactly(
+        /Unknown .* Gender/,
+        /Unknown .* Birthday/,
+        /Height must be/,
+        /Children must be/
+      )
+    end
+  end
+end
diff --git a/service/test/agama/dbus/storage/interfaces/device/drive_examples.rb b/service/test/agama/dbus/storage/interfaces/device/drive_examples.rb
index 62595298c4..42d9c082e3 100644
--- a/service/test/agama/dbus/storage/interfaces/device/drive_examples.rb
+++ b/service/test/agama/dbus/storage/interfaces/device/drive_examples.rb
@@ -192,13 +192,29 @@
         allow(device).to receive(:transport).and_return(transport)
       end
 
-      let(:transport) { instance_double(Y2Storage::DataTransport, to_s: "usb") }
+      let(:transport) { Y2Storage::DataTransport::FCOE }
 
       it "returns the transport" do
-        expect(subject.drive_transport).to eq("usb")
+        expect(subject.drive_transport).to eq("fcoe")
       end
 
-      context "if transport is unknown" do
+      context "if transport is Unknown" do
+        let(:transport) { Y2Storage::DataTransport::UNKNOWN }
+
+        it "returns an empty string" do
+          expect(subject.drive_transport).to eq("")
+        end
+      end
+
+      context "if transport is USB" do
+        let(:transport) { Y2Storage::DataTransport::USB }
+
+        it "returns the corresponding string" do
+          expect(subject.drive_transport).to eq("USB")
+        end
+      end
+
+      context "if transport is missing" do
         let(:transport) { nil }
 
         it "returns an empty string" do
diff --git a/service/test/agama/dbus/storage/manager_test.rb b/service/test/agama/dbus/storage/manager_test.rb
index 958725b215..7e85660587 100644
--- a/service/test/agama/dbus/storage/manager_test.rb
+++ b/service/test/agama/dbus/storage/manager_test.rb
@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-# Copyright (c) [2023] SUSE LLC
+# Copyright (c) [2023-2024] SUSE LLC
 #
 # All Rights Reserved.
 #
@@ -22,6 +22,7 @@
 require_relative "../../../test_helper"
 require "agama/dbus/storage/manager"
 require "agama/dbus/storage/proposal"
+require "agama/storage/device_settings"
 require "agama/storage/manager"
 require "agama/storage/proposal"
 require "agama/storage/proposal_settings"
@@ -262,8 +263,9 @@
   describe "#calculate_proposal" do
     let(:dbus_settings) do
       {
-        "BootDevice"         => "/dev/vda",
-        "LVM"                => true,
+        "Target"             => "disk",
+        "TargetDevice"       => "/dev/vda",
+        "BootDevice"         => "/dev/vdb",
         "EncryptionPassword" => "n0ts3cr3t",
         "Volumes"            => dbus_volumes
       }
@@ -279,9 +281,9 @@
     it "calculates a proposal with settings having values from D-Bus" do
       expect(proposal).to receive(:calculate) do |settings|
         expect(settings).to be_a(Agama::Storage::ProposalSettings)
-        expect(settings.boot_device).to eq "/dev/vda"
-        expect(settings.lvm).to be_a(Agama::Storage::LvmSettings)
-        expect(settings.lvm.enabled).to eq true
+        expect(settings.device).to be_a(Agama::Storage::DeviceSettings::Disk)
+        expect(settings.device.name).to eq "/dev/vda"
+        expect(settings.boot.device).to eq "/dev/vdb"
         expect(settings.encryption).to be_a(Agama::Storage::EncryptionSettings)
         expect(settings.encryption.password).to eq("n0ts3cr3t")
         expect(settings.volumes).to contain_exactly(
@@ -296,12 +298,12 @@
     context "when the D-Bus settings does not include some values" do
       let(:dbus_settings) { {} }
 
-      it "calculates a proposal with default/empty values for the missing settings" do
+      it "calculates a proposal with default values for the missing settings" do
         expect(proposal).to receive(:calculate) do |settings|
           expect(settings).to be_a(Agama::Storage::ProposalSettings)
-          expect(settings.boot_device).to eq nil
-          expect(settings.lvm).to be_a(Agama::Storage::LvmSettings)
-          expect(settings.lvm.enabled).to eq false
+          expect(settings.device).to be_a(Agama::Storage::DeviceSettings::Disk)
+          expect(settings.device.name).to be_nil
+          expect(settings.boot.device).to be_nil
           expect(settings.encryption).to be_a(Agama::Storage::EncryptionSettings)
           expect(settings.encryption.password).to be_nil
           expect(settings.volumes).to eq([])
diff --git a/service/test/agama/dbus/storage/proposal_settings_conversion/from_dbus_test.rb b/service/test/agama/dbus/storage/proposal_settings_conversion/from_dbus_test.rb
index 3114f1a9e6..b65221e7c7 100644
--- a/service/test/agama/dbus/storage/proposal_settings_conversion/from_dbus_test.rb
+++ b/service/test/agama/dbus/storage/proposal_settings_conversion/from_dbus_test.rb
@@ -20,14 +20,15 @@
 # find current contact information at www.suse.com.
 
 require_relative "../../../../test_helper"
-require "y2storage/encryption_method"
-require "y2storage/pbkd_function"
+require "agama/dbus/storage/proposal_settings_conversion/from_dbus"
 require "agama/config"
+require "agama/storage/device_settings"
 require "agama/storage/proposal_settings"
-require "agama/dbus/storage/proposal_settings_conversion/from_dbus"
+require "y2storage/encryption_method"
+require "y2storage/pbkd_function"
 
 describe Agama::DBus::Storage::ProposalSettingsConversion::FromDBus do
-  subject { described_class.new(dbus_settings, config: config) }
+  subject { described_class.new(dbus_settings, config: config, logger: logger) }
 
   let(:config) { Agama::Config.new(config_data) }
 
@@ -59,12 +60,25 @@
     }
   end
 
+  let(:logger) { Logger.new($stdout, level: :warn) }
+
+  before do
+    allow(Agama::Storage::EncryptionSettings)
+      .to receive(:available_methods).and_return(
+        [
+          Y2Storage::EncryptionMethod::LUKS1,
+          Y2Storage::EncryptionMethod::LUKS2
+        ]
+      )
+  end
+
   describe "#convert" do
     let(:dbus_settings) do
       {
-        "BootDevice"             => "/dev/sda",
-        "LVM"                    => true,
-        "SystemVGDevices"        => ["/dev/sda", "/dev/sdb"],
+        "Target"                 => "disk",
+        "TargetDevice"           => "/dev/sda",
+        "ConfigureBoot"          => true,
+        "BootDevice"             => "/dev/sdb",
         "EncryptionPassword"     => "notsecret",
         "EncryptionMethod"       => "luks1",
         "EncryptionPBKDFunction" => "pbkdf2",
@@ -90,16 +104,20 @@
       settings = subject.convert
 
       expect(settings).to be_a(Agama::Storage::ProposalSettings)
-      expect(settings.boot_device).to eq("/dev/sda")
-      expect(settings.lvm.enabled?).to eq(true)
-      expect(settings.lvm.system_vg_devices).to contain_exactly("/dev/sda", "/dev/sdb")
+      expect(settings.device).to be_a(Agama::Storage::DeviceSettings::Disk)
+      expect(settings.device.name).to eq("/dev/sda")
+      expect(settings.boot.configure?).to eq(true)
+      expect(settings.boot.device).to eq("/dev/sdb")
       expect(settings.encryption.method).to eq(Y2Storage::EncryptionMethod::LUKS1)
       expect(settings.encryption.pbkd_function).to eq(Y2Storage::PbkdFunction::PBKDF2)
       expect(settings.space.policy).to eq(:custom)
       expect(settings.space.actions).to eq({
         "/dev/sda" => :force_delete, "/dev/sdb1" => :resize
       })
-      expect(settings.volumes.map(&:mount_path)).to contain_exactly("/", "/test")
+      expect(settings.volumes).to contain_exactly(
+        an_object_having_attributes(mount_path: "/"),
+        an_object_having_attributes(mount_path: "/test")
+      )
     end
 
     context "when some values are not provided from D-Bus" do
@@ -109,22 +127,96 @@
         settings = subject.convert
 
         expect(settings).to be_a(Agama::Storage::ProposalSettings)
-        expect(settings.boot_device).to be_nil
-        expect(settings.lvm.enabled?).to eq(false)
+        expect(settings.device).to be_a(Agama::Storage::DeviceSettings::Disk)
+        expect(settings.device.name).to be_nil
+        expect(settings.boot.configure?).to eq(true)
+        expect(settings.boot.device).to be_nil
         expect(settings.encryption.method).to eq(Y2Storage::EncryptionMethod::LUKS2)
         expect(settings.encryption.pbkd_function).to eq(Y2Storage::PbkdFunction::ARGON2ID)
         expect(settings.space.policy).to eq(:delete)
-        expect(settings.volumes.map(&:mount_path)).to contain_exactly("/", "swap")
+        expect(settings.volumes).to contain_exactly(
+          an_object_having_attributes(mount_path: "/"),
+          an_object_having_attributes(mount_path: "swap")
+        )
+      end
+    end
+
+    context "when 'Target' is not provided from D-Bus" do
+      let(:dbus_settings) { {} }
+
+      it "sets device settings to create partitions" do
+        settings = subject.convert
+
+        expect(settings.device).to be_a(Agama::Storage::DeviceSettings::Disk)
+        expect(settings.device.name).to be_nil
+      end
+    end
+
+    context "when 'Target' has 'disk' value" do
+      let(:dbus_settings) do
+        {
+          "Target"       => "disk",
+          "TargetDevice" => "/dev/vda"
+        }
+      end
+
+      it "sets device settings to create partitions in the indicated device" do
+        settings = subject.convert
+
+        expect(settings.device).to be_a(Agama::Storage::DeviceSettings::Disk)
+        expect(settings.device.name).to eq("/dev/vda")
       end
     end
 
-    context "when an empty boot device is provided from D-Bus" do
-      let(:dbus_settings) { { "BootDevice" => "" } }
+    context "when 'Target' has 'newLvmVg' value" do
+      let(:dbus_settings) do
+        {
+          "Target"          => "newLvmVg",
+          "TargetPVDevices" => ["/dev/vda", "/dev/vdb"]
+        }
+      end
+
+      it "sets device settings to create a new LVM volume group in the indicated devices" do
+        settings = subject.convert
+
+        expect(settings.device).to be_a(Agama::Storage::DeviceSettings::NewLvmVg)
+        expect(settings.device.candidate_pv_devices).to contain_exactly("/dev/vda", "/dev/vdb")
+      end
+    end
+
+    context "when 'Target' has 'reusedLvmVg' value" do
+      let(:dbus_settings) do
+        {
+          "Target"       => "reusedLvmVg",
+          "TargetDevice" => "/dev/vg0"
+        }
+      end
 
-      it "sets the boot device to nil" do
+      it "sets device settings to reuse the indicated LVM volume group" do
         settings = subject.convert
 
-        expect(settings.boot_device).to be_nil
+        expect(settings.device).to be_a(Agama::Storage::DeviceSettings::ReusedLvmVg)
+        expect(settings.device.name).to eq("/dev/vg0")
+      end
+    end
+
+    context "when some value provided from D-Bus has unexpected type" do
+      let(:dbus_settings) { { "BootDevice" => 1 } }
+
+      it "ignores the value" do
+        settings = subject.convert
+
+        expect(settings.boot.device).to be_nil
+      end
+    end
+
+    context "when some unexpected setting is provided from D-Bus" do
+      let(:dbus_settings) { { "Foo" => 1 } }
+
+      it "does not fail" do
+        settings = subject.convert
+
+        expect(settings).to be_a(Agama::Storage::ProposalSettings)
       end
     end
 
@@ -133,12 +225,17 @@
 
       it "completes the volumes with the default volumes from config" do
         settings = subject.convert
-        expect(settings.volumes.map(&:mount_path)).to contain_exactly("/", "swap")
+        expect(settings.volumes).to contain_exactly(
+          an_object_having_attributes(mount_path: "/"),
+          an_object_having_attributes(mount_path: "swap")
+        )
       end
 
       it "ignores templates of non-default volumes" do
         settings = subject.convert
-        expect(settings.volumes.map(&:mount_path)).to_not include("/home")
+        expect(settings.volumes).to_not include(
+          an_object_having_attributes(mount_path: "/home")
+        )
       end
     end
 
@@ -153,22 +250,30 @@
 
       it "completes the volumes with the mandatory volumes" do
         settings = subject.convert
-        expect(settings.volumes.map(&:mount_path)).to include("/")
+        expect(settings.volumes).to include(
+          an_object_having_attributes(mount_path: "/")
+        )
       end
 
       it "includes the volumes provided from D-Bus" do
         settings = subject.convert
-        expect(settings.volumes.map(&:mount_path)).to include("/test")
+        expect(settings.volumes).to include(
+          an_object_having_attributes(mount_path: "/test")
+        )
       end
 
       it "ignores default volumes that are not mandatory" do
         settings = subject.convert
-        expect(settings.volumes.map(&:mount_path)).to_not include("swap")
+        expect(settings.volumes).to_not include(
+          an_object_having_attributes(mount_path: "swap")
+        )
       end
 
       it "ignores templates for excluded volumes" do
         settings = subject.convert
-        expect(settings.volumes.map(&:mount_path)).to_not include("/home")
+        expect(settings.volumes).to_not include(
+          an_object_having_attributes(mount_path: "/home")
+        )
       end
     end
   end
diff --git a/service/test/agama/dbus/storage/proposal_settings_conversion/to_dbus_test.rb b/service/test/agama/dbus/storage/proposal_settings_conversion/to_dbus_test.rb
index c5961e1585..76700c39c5 100644
--- a/service/test/agama/dbus/storage/proposal_settings_conversion/to_dbus_test.rb
+++ b/service/test/agama/dbus/storage/proposal_settings_conversion/to_dbus_test.rb
@@ -20,20 +20,20 @@
 # find current contact information at www.suse.com.
 
 require_relative "../../../../test_helper"
-require "y2storage/encryption_method"
-require "y2storage/pbkd_function"
 require "agama/dbus/storage/proposal_settings_conversion/to_dbus"
+require "agama/storage/device_settings"
 require "agama/storage/proposal_settings"
 require "agama/storage/volume"
+require "y2storage/encryption_method"
+require "y2storage/pbkd_function"
 
 describe Agama::DBus::Storage::ProposalSettingsConversion::ToDBus do
   let(:default_settings) { Agama::Storage::ProposalSettings.new }
 
   let(:custom_settings) do
     Agama::Storage::ProposalSettings.new.tap do |settings|
-      settings.boot_device = "/dev/sda"
-      settings.lvm.enabled = true
-      settings.lvm.system_vg_devices = ["/dev/sda", "/dev/sdb"]
+      settings.device.name = "/dev/sda"
+      settings.boot.device = "/dev/sdb"
       settings.encryption.password = "notsecret"
       settings.encryption.method = Y2Storage::EncryptionMethod::LUKS2
       settings.encryption.pbkd_function = Y2Storage::PbkdFunction::ARGON2ID
@@ -46,9 +46,11 @@
   describe "#convert" do
     it "converts the settings to a D-Bus hash" do
       expect(described_class.new(default_settings).convert).to eq(
+        "Target"                 => "disk",
+        "TargetDevice"           => "",
+        "ConfigureBoot"          => true,
         "BootDevice"             => "",
-        "LVM"                    => false,
-        "SystemVGDevices"        => [],
+        "DefaultBootDevice"      => "",
         "EncryptionPassword"     => "",
         "EncryptionMethod"       => "luks2",
         "EncryptionPBKDFunction" => "pbkdf2",
@@ -58,9 +60,11 @@
       )
 
       expect(described_class.new(custom_settings).convert).to eq(
-        "BootDevice"             => "/dev/sda",
-        "LVM"                    => true,
-        "SystemVGDevices"        => ["/dev/sda", "/dev/sdb"],
+        "Target"                 => "disk",
+        "TargetDevice"           => "/dev/sda",
+        "ConfigureBoot"          => true,
+        "BootDevice"             => "/dev/sdb",
+        "DefaultBootDevice"      => "/dev/sda",
         "EncryptionPassword"     => "notsecret",
         "EncryptionMethod"       => "luks2",
         "EncryptionPBKDFunction" => "argon2id",
@@ -99,5 +103,62 @@
         ]
       )
     end
+
+    context "when the device is set to create partitions" do
+      let(:settings) do
+        Agama::Storage::ProposalSettings.new.tap do |settings|
+          settings.device = Agama::Storage::DeviceSettings::Disk.new("/dev/vda")
+        end
+      end
+
+      it "generates settings to use a disk as target device" do
+        dbus_settings = described_class.new(settings).convert
+
+        expect(dbus_settings).to include(
+          "Target"       => "disk",
+          "TargetDevice" => "/dev/vda"
+        )
+
+        expect(dbus_settings).to_not include("TargetPVDevices")
+      end
+    end
+
+    context "when the device is set to create a new LVM volume group" do
+      let(:settings) do
+        Agama::Storage::ProposalSettings.new.tap do |settings|
+          settings.device = Agama::Storage::DeviceSettings::NewLvmVg.new(["/dev/vda"])
+        end
+      end
+
+      it "generates settings to create a LVM volume group as target device" do
+        dbus_settings = described_class.new(settings).convert
+
+        expect(dbus_settings).to include(
+          "Target"          => "newLvmVg",
+          "TargetPVDevices" => ["/dev/vda"]
+        )
+
+        expect(dbus_settings).to_not include("TargetDevice")
+      end
+    end
+
+    context "when the device is set to reuse a LVM volume group" do
+      let(:settings) do
+        Agama::Storage::ProposalSettings.new.tap do |settings|
+          settings.device = Agama::Storage::DeviceSettings::ReusedLvmVg.new("/dev/vg0")
+        end
+      end
+
+      it "generates settings to reuse a LVM volume group as target device" do
+        dbus_settings = described_class.new(settings).convert
+
+        expect(dbus_settings).to include(
+          "Target"       => "reusedLvmVg",
+          "TargetDevice" => "/dev/vg0"
+        )
+
+        expect(dbus_settings).to_not include("TargetPVDevices")
+      end
+    end
   end
 end
diff --git a/service/test/agama/dbus/storage/proposal_settings_conversion_test.rb b/service/test/agama/dbus/storage/proposal_settings_conversion_test.rb
index f4a0c1502a..236e98db35 100644
--- a/service/test/agama/dbus/storage/proposal_settings_conversion_test.rb
+++ b/service/test/agama/dbus/storage/proposal_settings_conversion_test.rb
@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-# Copyright (c) [2023] SUSE LLC
+# Copyright (c) [2023-2024] SUSE LLC
 #
 # All Rights Reserved.
 #
@@ -30,8 +30,10 @@
 
     let(:dbus_settings) { {} }
 
+    let(:logger) { Logger.new($stdout, level: :warn) }
+
     it "generates proposal settings from D-Bus settings" do
-      result = described_class.from_dbus(dbus_settings, config: config)
+      result = described_class.from_dbus(dbus_settings, config: config, logger: logger)
       expect(result).to be_a(Agama::Storage::ProposalSettings)
     end
   end
diff --git a/service/test/agama/dbus/storage/proposal_test.rb b/service/test/agama/dbus/storage/proposal_test.rb
index fc61302129..cfc18c7be4 100644
--- a/service/test/agama/dbus/storage/proposal_test.rb
+++ b/service/test/agama/dbus/storage/proposal_test.rb
@@ -21,6 +21,7 @@
 
 require_relative "../../../test_helper"
 require "agama/dbus/storage/proposal"
+require "agama/storage/device_settings"
 require "agama/storage/proposal"
 require "agama/storage/proposal_settings"
 require "agama/storage/volume"
@@ -29,212 +30,66 @@
 describe Agama::DBus::Storage::Proposal do
   subject { described_class.new(backend, logger) }
 
-  let(:logger) { Logger.new($stdout, level: :warn) }
-
   let(:backend) do
     instance_double(Agama::Storage::Proposal, settings: settings)
   end
 
-  let(:settings) { nil }
-
-  describe "#boot_device" do
-    context "if a proposal has not been calculated yet" do
-      let(:settings) { nil }
-
-      it "returns an empty string" do
-        expect(subject.boot_device).to eq ""
-      end
-    end
-
-    context "if a proposal has been calculated" do
-      let(:settings) do
-        Agama::Storage::ProposalSettings.new.tap { |s| s.boot_device = "/dev/vda" }
-      end
-
-      it "returns the candidate devices used by the proposal" do
-        expect(subject.boot_device).to eq "/dev/vda"
-      end
-    end
-  end
-
-  describe "#lvm" do
-    context "if a proposal has not been calculated yet" do
-      let(:settings) { nil }
-
-      it "returns false" do
-        expect(subject.lvm).to eq(false)
-      end
-    end
-
-    context "if a proposal has been calculated" do
-      let(:settings) do
-        Agama::Storage::ProposalSettings.new.tap { |s| s.lvm.enabled = true }
-      end
-
-      it "return whether LVM was used" do
-        expect(subject.lvm).to eq(true)
-      end
-    end
-  end
-
-  describe "#system_vg_devices" do
-    context "if a proposal has not been calculated yet" do
-      let(:settings) { nil }
-
-      it "returns an empty list" do
-        expect(subject.system_vg_devices).to eq([])
-      end
-    end
-
-    context "if a proposal has been calculated" do
-      let(:settings) do
-        Agama::Storage::ProposalSettings.new.tap { |s| s.lvm.system_vg_devices = ["/dev/vda"] }
-      end
-
-      it "returns the devices used for the system VG" do
-        expect(subject.system_vg_devices).to contain_exactly("/dev/vda")
-      end
-    end
-  end
-
-  describe "#encryption_password" do
-    context "if a proposal has not been calculated yet" do
-      let(:settings) { nil }
-
-      it "returns an empty string" do
-        expect(subject.encryption_password).to eq("")
-      end
-    end
-
-    context "if a proposal has been calculated" do
-      let(:settings) do
-        Agama::Storage::ProposalSettings.new.tap { |s| s.encryption.password = "n0ts3cr3t" }
-      end
-
-      it "return the encryption password used by the proposal" do
-        expect(subject.encryption_password).to eq("n0ts3cr3t")
-      end
-    end
-  end
-
-  describe "#encryption_method" do
-    context "if a proposal has not been calculated yet" do
-      let(:settings) { nil }
-
-      it "returns an empty string" do
-        expect(subject.encryption_method).to eq("")
-      end
-    end
-
-    context "if a proposal has been calculated" do
-      let(:settings) do
-        Agama::Storage::ProposalSettings.new.tap { |s| s.encryption.method = luks2 }
-      end
-
-      let(:luks2) { Y2Storage::EncryptionMethod::LUKS2 }
-
-      it "return the encryption method used by the proposal" do
-        expect(subject.encryption_method).to eq(luks2.id.to_s)
-      end
-    end
-  end
-
-  describe "#encryption_pbkd_function" do
-    context "if a proposal has not been calculated yet" do
-      let(:settings) { nil }
-
-      it "returns an empty string" do
-        expect(subject.encryption_pbkd_function).to eq("")
-      end
-    end
-
-    context "if a proposal has been calculated" do
-      let(:settings) do
-        Agama::Storage::ProposalSettings.new.tap { |s| s.encryption.pbkd_function = argon2id }
-      end
-
-      let(:argon2id) { Y2Storage::PbkdFunction::ARGON2ID }
-
-      it "return the encryption method used by the proposal" do
-        expect(subject.encryption_pbkd_function).to eq(argon2id.value)
-      end
-    end
-  end
-
-  describe "#space_policy" do
-    context "if a proposal has not been calculated yet" do
-      let(:settings) { nil }
-
-      it "returns an empty string" do
-        expect(subject.space_policy).to eq("")
-      end
-    end
-
-    context "if a proposal has been calculated" do
-      let(:settings) do
-        Agama::Storage::ProposalSettings.new.tap { |s| s.space.policy = :delete }
-      end
+  let(:logger) { Logger.new($stdout, level: :warn) }
 
-      it "return the space policy used by the proposal" do
-        expect(subject.space_policy).to eq("delete")
-      end
-    end
-  end
+  let(:settings) { nil }
 
-  describe "#space_actions" do
+  describe "#settings" do
     context "if a proposal has not been calculated yet" do
       let(:settings) { nil }
 
-      it "returns an empty list" do
-        expect(subject.space_actions).to eq([])
+      it "returns an empty hash" do
+        expect(subject.settings).to eq({})
       end
     end
 
     context "if a proposal has been calculated" do
       let(:settings) do
         Agama::Storage::ProposalSettings.new.tap do |settings|
+          settings.device = Agama::Storage::DeviceSettings::Disk.new("/dev/vda")
+          settings.boot.device = "/dev/vdb"
+          settings.encryption.password = "n0ts3cr3t"
+          settings.encryption.method = luks2
+          settings.encryption.pbkd_function = argon2id
+          settings.space.policy = :custom
           settings.space.actions = {
             "/dev/vda1" => :force_delete,
             "/dev/vda2" => :resize
           }
+          settings.volumes = [
+            Agama::Storage::Volume.new("/test1"),
+            Agama::Storage::Volume.new("/test2")
+          ]
         end
       end
 
-      it "return a list with a hash for each action" do
-        expect(subject.space_actions).to contain_exactly(
-          { "Device" => "/dev/vda1", "Action" => "force_delete" },
-          { "Device" => "/dev/vda2", "Action" => "resize" }
-        )
-      end
-    end
-  end
-
-  describe "#volumes" do
-    let(:settings) do
-      Agama::Storage::ProposalSettings.new.tap { |s| s.volumes = calculated_volumes }
-    end
-
-    context "if the calculated settings has no volumes" do
-      let(:calculated_volumes) { [] }
-
-      it "returns an empty list" do
-        expect(subject.volumes).to eq([])
-      end
-    end
-
-    context "if the calculated settings has volumes" do
-      let(:calculated_volumes) { [calculated_volume1, calculated_volume2] }
-      let(:calculated_volume1) { Agama::Storage::Volume.new("/test1") }
-      let(:calculated_volume2) { Agama::Storage::Volume.new("/test2") }
-
-      it "returns a list with a hash for each volume" do
-        expect(subject.volumes.size).to eq(2)
-        expect(subject.volumes).to all(be_a(Hash))
+      let(:luks2) { Y2Storage::EncryptionMethod::LUKS2 }
 
-        volume1, volume2 = subject.volumes
+      let(:argon2id) { Y2Storage::PbkdFunction::ARGON2ID }
 
-        expect(volume1).to include("MountPath" => "/test1")
-        expect(volume2).to include("MountPath" => "/test2")
+      it "returns the proposal settings in D-Bus format" do
+        expect(subject.settings).to include(
+          "Target"                 => "disk",
+          "TargetDevice"           => "/dev/vda",
+          "ConfigureBoot"          => true,
+          "BootDevice"             => "/dev/vdb",
+          "EncryptionPassword"     => "n0ts3cr3t",
+          "EncryptionMethod"       => luks2.id.to_s,
+          "EncryptionPBKDFunction" => argon2id.value,
+          "SpacePolicy"            => "custom",
+          "SpaceActions"           => [
+            { "Device" => "/dev/vda1", "Action" => "force_delete" },
+            { "Device" => "/dev/vda2", "Action" => "resize" }
+          ],
+          "Volumes"                => [
+            include("MountPath" => "/test1"),
+            include("MountPath" => "/test2")
+          ]
+        )
       end
     end
   end
diff --git a/service/test/agama/dbus/storage/volume_conversion/from_dbus_test.rb b/service/test/agama/dbus/storage/volume_conversion/from_dbus_test.rb
index 5512783c33..e3d3e2bfa9 100644
--- a/service/test/agama/dbus/storage/volume_conversion/from_dbus_test.rb
+++ b/service/test/agama/dbus/storage/volume_conversion/from_dbus_test.rb
@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-# Copyright (c) [2023] SUSE LLC
+# Copyright (c) [2023-2024] SUSE LLC
 #
 # All Rights Reserved.
 #
@@ -61,6 +61,8 @@
     }
   end
 
+  let(:logger) { Logger.new($stdout, level: :warn) }
+
   describe "#convert" do
     let(:dbus_volume) do
       {
diff --git a/service/test/agama/dbus/storage/volume_conversion/to_dbus_test.rb b/service/test/agama/dbus/storage/volume_conversion/to_dbus_test.rb
index 2356c0c94e..9fc2db2749 100644
--- a/service/test/agama/dbus/storage/volume_conversion/to_dbus_test.rb
+++ b/service/test/agama/dbus/storage/volume_conversion/to_dbus_test.rb
@@ -20,10 +20,10 @@
 # find current contact information at www.suse.com.
 
 require_relative "../../../../test_helper"
-require "y2storage/filesystems/type"
-require "y2storage/disk_size"
 require "agama/dbus/storage/volume_conversion/to_dbus"
 require "agama/storage/volume"
+require "y2storage/filesystems/type"
+require "y2storage/disk_size"
 
 describe Agama::DBus::Storage::VolumeConversion::ToDBus do
   let(:default_volume) { Agama::Storage::Volume.new("/test") }
diff --git a/service/test/agama/dbus/storage/volume_conversion_test.rb b/service/test/agama/dbus/storage/volume_conversion_test.rb
index 5f158a1855..5dd15d7a98 100644
--- a/service/test/agama/dbus/storage/volume_conversion_test.rb
+++ b/service/test/agama/dbus/storage/volume_conversion_test.rb
@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-# Copyright (c) [2023] SUSE LLC
+# Copyright (c) [2023-2024] SUSE LLC
 #
 # All Rights Reserved.
 #
@@ -30,8 +30,10 @@
 
     let(:dbus_volume) { {} }
 
+    let(:logger) { Logger.new($stdout, level: :warn) }
+
     it "generates a volume from D-Bus settings" do
-      result = described_class.from_dbus(dbus_volume, config: config)
+      result = described_class.from_dbus(dbus_volume, config: config, logger: logger)
       expect(result).to be_a(Agama::Storage::Volume)
     end
   end
diff --git a/service/test/agama/dbus/types_test.rb b/service/test/agama/dbus/types_test.rb
new file mode 100644
index 0000000000..6661508be7
--- /dev/null
+++ b/service/test/agama/dbus/types_test.rb
@@ -0,0 +1,167 @@
+# frozen_string_literal: true
+
+# Copyright (c) [2024] SUSE LLC
+#
+# All Rights Reserved.
+#
+# This program is free software; you can redistribute it and/or modify it
+# under the terms of version 2 of the GNU General Public License as published
+# by the Free Software Foundation.
+#
+# This program is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+# FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+# more details.
+#
+# You should have received a copy of the GNU General Public License along
+# with this program; if not, contact SUSE LLC.
+#
+# To contact SUSE LLC about this file by physical or electronic mail, you may
+# find current contact information at www.suse.com.
+
+require_relative "../../test_helper"
+require "agama/dbus/types"
+
+describe Agama::DBus::Types::Checker do
+  describe "#match?" do
+    describe "for Bool type" do
+      subject { described_class.new(Agama::DBus::Types::BOOL) }
+
+      it "returns true if the given value is true or false" do
+        expect(subject.match?(true)).to eq(true)
+        expect(subject.match?(false)).to eq(true)
+      end
+
+      it "returns false otherwise" do
+        expect(subject.match?(nil)).to eq(false)
+        expect(subject.match?("foo")).to eq(false)
+        expect(subject.match?(10)).to eq(false)
+        expect(subject.match?([])).to eq(false)
+        expect(subject.match?({})).to eq(false)
+      end
+    end
+
+    describe "for Array type" do
+      subject { described_class.new(array_type) }
+
+      let(:array_type) { Agama::DBus::Types::Array.new }
+
+      it "returns true if the given value is an array" do
+        expect(subject.match?([])).to eq(true)
+        expect(subject.match?([1, 2])).to eq(true)
+      end
+
+      it "returns false otherwise" do
+        expect(subject.match?(nil)).to eq(false)
+        expect(subject.match?("foo")).to eq(false)
+        expect(subject.match?(10)).to eq(false)
+        expect(subject.match?(true)).to eq(false)
+        expect(subject.match?({})).to eq(false)
+      end
+
+      context "if the elements of the array have to be of a specific type" do
+        let(:array_type) { Agama::DBus::Types::Array.new(String) }
+
+        it "returns true if all the elements match the given type" do
+          expect(subject.match?([])).to eq(true)
+          expect(subject.match?(["foo", "bar"])).to eq(true)
+        end
+
+        it "returns false otherwise" do
+          expect(subject.match?([nil])).to eq(false)
+          expect(subject.match?([10])).to eq(false)
+          expect(subject.match?([true])).to eq(false)
+          expect(subject.match?([[]])).to eq(false)
+          expect(subject.match?([{}])).to eq(false)
+        end
+      end
+    end
+
+    describe "for Hash type" do
+      subject { described_class.new(hash_type) }
+
+      let(:hash_type) { Agama::DBus::Types::Hash.new }
+
+      it "returns true if the given value is an hash" do
+        expect(subject.match?({})).to eq(true)
+        expect(subject.match?({ foo: "", bar: 1 })).to eq(true)
+      end
+
+      it "returns false otherwise" do
+        expect(subject.match?(nil)).to eq(false)
+        expect(subject.match?("foo")).to eq(false)
+        expect(subject.match?(10)).to eq(false)
+        expect(subject.match?(true)).to eq(false)
+        expect(subject.match?([])).to eq(false)
+      end
+
+      context "if the keys of the hash have to be of a specific type" do
+        let(:hash_type) { Agama::DBus::Types::Hash.new(key: String) }
+
+        it "returns true if all the keys match the given type" do
+          expect(subject.match?({})).to eq(true)
+          expect(subject.match?({ "foo" => "", "bar" => 1 })).to eq(true)
+        end
+
+        it "returns false otherwise" do
+          expect(subject.match?({ nil: 1 })).to eq(false)
+          expect(subject.match?({ a: 1 })).to eq(false)
+          expect(subject.match?({ 10 => 1 })).to eq(false)
+          expect(subject.match?({ true => 1 })).to eq(false)
+          expect(subject.match?({ [] => 1 })).to eq(false)
+          expect(subject.match?({ {} => 1 })).to eq(false)
+        end
+      end
+
+      context "if the values of the hash have to be of a specific type" do
+        let(:hash_type) { Agama::DBus::Types::Hash.new(value: Integer) }
+
+        it "returns true if all the values match the given type" do
+          expect(subject.match?({})).to eq(true)
+          expect(subject.match?({ "foo" => 1, bar: 2 })).to eq(true)
+        end
+
+        it "returns false otherwise" do
+          expect(subject.match?({ foo: nil })).to eq(false)
+          expect(subject.match?({ foo: 1.0 })).to eq(false)
+          expect(subject.match?({ foo: "" })).to eq(false)
+          expect(subject.match?({ foo: [] })).to eq(false)
+          expect(subject.match?({ foo: {} })).to eq(false)
+        end
+      end
+
+      context "if the keys and the values of the hash have to be of a specific type" do
+        let(:hash_type) do
+          Agama::DBus::Types::Hash.new(key: String, value: Agama::DBus::Types::BOOL)
+        end
+
+        it "returns true if all the keys and values match the given types" do
+          expect(subject.match?({})).to eq(true)
+          expect(subject.match?({ "foo" => true, "bar" => false })).to eq(true)
+        end
+
+        it "returns false otherwise" do
+          expect(subject.match?({ "foo" => nil })).to eq(false)
+          expect(subject.match?({ foo: true })).to eq(false)
+        end
+      end
+    end
+
+    describe "for other types" do
+      subject { described_class.new(Array) }
+
+      it "returns true if the given value is an instance of the given type" do
+        expect(subject.match?([])).to eq(true)
+        expect(subject.match?([1, 2])).to eq(true)
+      end
+
+      it "returns false otherwise" do
+        expect(subject.match?(nil)).to eq(false)
+        expect(subject.match?("foo")).to eq(false)
+        expect(subject.match?(10)).to eq(false)
+        expect(subject.match?(true)).to eq(false)
+        expect(subject.match?({})).to eq(false)
+      end
+    end
+  end
+end
diff --git a/service/test/agama/storage/proposal_settings_conversion/from_y2storage_test.rb b/service/test/agama/storage/proposal_settings_conversion/from_y2storage_test.rb
index c01e40a4e9..93f0f9e519 100644
--- a/service/test/agama/storage/proposal_settings_conversion/from_y2storage_test.rb
+++ b/service/test/agama/storage/proposal_settings_conversion/from_y2storage_test.rb
@@ -20,168 +20,60 @@
 # find current contact information at www.suse.com.
 
 require_relative "../../../test_helper"
-require "agama/storage/proposal_settings_conversion/from_y2storage"
 require "agama/config"
+require "agama/storage/proposal_settings"
+require "agama/storage/proposal_settings_conversion/from_y2storage"
 require "y2storage"
 
 describe Agama::Storage::ProposalSettingsConversion::FromY2Storage do
-  subject { described_class.new(y2storage_settings, config: config) }
-
-  let(:config) { Agama::Config.new }
+  subject { described_class.new(y2storage_settings, original_settings) }
+
+  let(:y2storage_settings) do
+    Y2Storage::ProposalSettings.new.tap do |settings|
+      settings.space_settings.actions = {
+        "/dev/sda"  => :force_delete,
+        "/dev/sdb1" => :resize
+      }
+    end
+  end
 
-  describe "#convert" do
-    let(:y2storage_settings) do
-      Y2Storage::ProposalSettings.new.tap do |settings|
-        settings.root_device = "/dev/sda"
-        settings.lvm = false
-        settings.candidate_devices = ["/dev/sda"]
-        settings.encryption_password = "notsecret"
-        settings.encryption_method = Y2Storage::EncryptionMethod::LUKS2
-        settings.encryption_pbkdf = Y2Storage::PbkdFunction::ARGON2ID
-        settings.space_settings.actions = {
-          "/dev/sda"  => :force_delete,
-          "/dev/sdb1" => :resize
-        }
-        settings.volumes = []
-      end
+  let(:original_settings) do
+    Agama::Storage::ProposalSettings.new.tap do |settings|
+      settings.device.name = "/dev/sda"
+      settings.boot.device = "/dev/sdb"
+      settings.encryption.password = "notsecret"
+      settings.encryption.method = Y2Storage::EncryptionMethod::LUKS2
+      settings.encryption.pbkd_function = Y2Storage::PbkdFunction::ARGON2ID
+      settings.space.policy = :delete
+      settings.space.actions = []
+      settings.volumes = [Agama::Storage::Volume.new("/test")]
     end
+  end
 
-    it "converts the Y2Storage settings to Agama settings" do
+  describe "#convert" do
+    it "generates settings with the same values as the given settings" do
       settings = subject.convert
 
       expect(settings).to be_a(Agama::Storage::ProposalSettings)
-      expect(settings).to have_attributes(
-        boot_device: "/dev/sda",
-        lvm:         an_object_having_attributes(
-          enabled:           false,
-          system_vg_devices: []
-        ),
-        encryption:  an_object_having_attributes(
-          password:      "notsecret",
-          method:        Y2Storage::EncryptionMethod::LUKS2,
-          pbkd_function: Y2Storage::PbkdFunction::ARGON2ID
-        ),
-        space:       an_object_having_attributes(
-          actions: { "/dev/sda" => :force_delete, "/dev/sdb1" => :resize }
-        ),
-        volumes:     []
+      expect(settings.device).to be_a(Agama::Storage::DeviceSettings::Disk)
+      expect(settings.device.name).to eq("/dev/sda")
+      expect(settings.boot.device).to eq("/dev/sdb")
+      expect(settings.encryption.password).to eq("notsecret")
+      expect(settings.encryption.method).to eq(Y2Storage::EncryptionMethod::LUKS2)
+      expect(settings.encryption.pbkd_function).to eq(Y2Storage::PbkdFunction::ARGON2ID)
+      expect(settings.space.policy).to eq(:delete)
+      expect(settings.volumes).to contain_exactly(
+        an_object_having_attributes(mount_path: "/test")
       )
     end
 
-    context "LVM settings conversion" do
-      before do
-        y2storage_settings.root_device = "/dev/sda"
-        y2storage_settings.candidate_devices = candidate_devices
-      end
-
-      context "when the candidate devices only includes the root device" do
-        let(:candidate_devices) { ["/dev/sda"] }
-
-        it "does not set system VG devices" do
-          settings = subject.convert
-
-          expect(settings).to have_attributes(
-            lvm: an_object_having_attributes(
-              system_vg_devices: []
-            )
-          )
-        end
-      end
-
-      context "when the candidate devices includes the root device and other devices" do
-        let(:candidate_devices) { ["/dev/sda", "/dev/sdb"] }
-
-        it "sets the candidate devices as system VG devices" do
-          settings = subject.convert
-
-          expect(settings).to have_attributes(
-            lvm: an_object_having_attributes(
-              system_vg_devices: contain_exactly("/dev/sda", "/dev/sdb")
-            )
-          )
-        end
-      end
-
-      context "when the candidate devices only includes other devices" do
-        let(:candidate_devices) { ["/dev/sdb", "/dev/sdc"] }
-
-        it "sets the candidate devices as system VG devices" do
-          settings = subject.convert
-
-          expect(settings).to have_attributes(
-            lvm: an_object_having_attributes(
-              system_vg_devices: contain_exactly("/dev/sdb", "/dev/sdc")
-            )
-          )
-        end
-
-        it "does not set the root device as system VG device" do
-          settings = subject.convert
-
-          expect(settings.lvm.system_vg_devices).to_not include("/dev/sda")
-        end
-      end
-    end
-
-    context "volumes conversion" do
-      before do
-        y2storage_settings.volumes = [spec1, spec2, spec3]
-      end
-
-      let(:spec1) do
-        Y2Storage::VolumeSpecification.new({}).tap do |spec|
-          spec.mount_point = "/"
-          spec.proposed = true
-        end
-      end
-
-      let(:spec2) do
-        Y2Storage::VolumeSpecification.new({}).tap do |spec|
-          spec.mount_point = "/home"
-          spec.proposed = true
-          spec.fallback_for_min_size = "/"
-          spec.fallback_for_max_size = "/"
-        end
-      end
-
-      let(:spec3) do
-        Y2Storage::VolumeSpecification.new({}).tap do |spec|
-          spec.mount_point = "swap"
-          spec.proposed = false
-          spec.fallback_for_min_size = "/"
-          spec.fallback_for_max_size = "/home"
-        end
-      end
-
-      it "only includes volumes for the proposed specs" do
-        settings = subject.convert
-
-        expect(settings).to have_attributes(
-          volumes: contain_exactly(
-            an_object_having_attributes(mount_path: "/"),
-            an_object_having_attributes(mount_path: "/home")
-          )
-        )
-      end
-
-      it "sets the fallbacks for min and max sizes" do
-        settings = subject.convert
+    it "restores the space actions from Y2Storage" do
+      settings = subject.convert
 
-        expect(settings).to have_attributes(
-          volumes: contain_exactly(
-            an_object_having_attributes(
-              mount_path:            "/",
-              min_size_fallback_for: contain_exactly("/home", "swap"),
-              max_size_fallback_for: contain_exactly("/home")
-            ),
-            an_object_having_attributes(
-              mount_path:            "/home",
-              min_size_fallback_for: be_empty,
-              max_size_fallback_for: contain_exactly("swap")
-            )
-          )
-        )
-      end
+      expect(settings.space.actions).to eq(
+        "/dev/sda"  => :force_delete,
+        "/dev/sdb1" => :resize
+      )
     end
   end
 end
diff --git a/service/test/agama/storage/proposal_settings_conversion/to_y2storage_test.rb b/service/test/agama/storage/proposal_settings_conversion/to_y2storage_test.rb
index 8eae303204..1fc6087951 100644
--- a/service/test/agama/storage/proposal_settings_conversion/to_y2storage_test.rb
+++ b/service/test/agama/storage/proposal_settings_conversion/to_y2storage_test.rb
@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-# Copyright (c) [2023] SUSE LLC
+# Copyright (c) [2023-2024] SUSE LLC
 #
 # All Rights Reserved.
 #
@@ -21,9 +21,10 @@
 
 require_relative "../../../test_helper"
 require_relative "../storage_helpers"
-require "agama/storage/proposal_settings_conversion/to_y2storage"
-require "agama/storage/proposal_settings"
 require "agama/config"
+require "agama/storage/device_settings"
+require "agama/storage/proposal_settings"
+require "agama/storage/proposal_settings_conversion/to_y2storage"
 require "y2storage"
 
 describe Agama::Storage::ProposalSettingsConversion::ToY2Storage do
@@ -36,9 +37,8 @@
   describe "#convert" do
     let(:settings) do
       Agama::Storage::ProposalSettings.new.tap do |settings|
-        settings.boot_device = "/dev/sda"
-        settings.lvm.enabled = true
-        settings.lvm.system_vg_devices = ["/dev/sda", "/dev/sdb"]
+        settings.device.name = "/dev/sdc"
+        settings.boot.device = "/dev/sda"
         settings.encryption.password = "notsecret"
         settings.encryption.method = Y2Storage::EncryptionMethod::LUKS2
         settings.encryption.pbkd_function = Y2Storage::PbkdFunction::ARGON2ID
@@ -46,7 +46,7 @@
         settings.space.actions = { "/dev/sda" => :force_delete }
         volume = Agama::Storage::Volume.new("/test").tap do |vol|
           vol.location.target = :new_partition
-          vol.location.device = "/dev/sdc"
+          vol.location.device = "/dev/sdb"
         end
         settings.volumes = [volume]
       end
@@ -56,111 +56,202 @@
       y2storage_settings = subject.convert
 
       expect(y2storage_settings).to be_a(Y2Storage::ProposalSettings)
-      expect(y2storage_settings).to have_attributes(
-        candidate_devices:   contain_exactly("/dev/sda", "/dev/sdb"),
-        root_device:         "/dev/sda",
-        swap_reuse:          :none,
-        lvm:                 true,
-        separate_vgs:        true,
-        lvm_vg_reuse:        false,
-        encryption_password: "notsecret",
-        encryption_method:   Y2Storage::EncryptionMethod::LUKS2,
-        encryption_pbkdf:    Y2Storage::PbkdFunction::ARGON2ID,
-        space_settings:      an_object_having_attributes(
-          strategy: :bigger_resize,
-          actions:  { "/dev/sda" => :force_delete }
-        ),
-        volumes:             include(an_object_having_attributes(mount_point: "/test"))
+      expect(y2storage_settings.root_device).to eq("/dev/sda")
+      expect(y2storage_settings.candidate_devices).to eq(["/dev/sda"])
+      expect(y2storage_settings.swap_reuse).to eq(:none)
+      expect(y2storage_settings.lvm).to eq(false)
+      expect(y2storage_settings.encryption_password).to eq("notsecret")
+      expect(y2storage_settings.encryption_method).to eq(Y2Storage::EncryptionMethod::LUKS2)
+      expect(y2storage_settings.encryption_pbkdf).to eq(Y2Storage::PbkdFunction::ARGON2ID)
+      expect(y2storage_settings.space_settings.strategy).to eq(:bigger_resize)
+      expect(y2storage_settings.space_settings.actions).to eq({ "/dev/sda" => :force_delete })
+      expect(y2storage_settings.volumes).to include(
+        an_object_having_attributes(
+          mount_point: "/test",
+          device:      "/dev/sdb"
+        )
       )
     end
 
-    context "candidate devices conversion" do
-      context "when LVM is not set" do
-        before do
-          settings.lvm.enabled = false
-          settings.lvm.system_vg_devices = ["/dev/sdb"]
+    context "device conversion" do
+      shared_examples "lvm conversion" do
+        it "configures LVM settings" do
+          y2storage_settings = subject.convert
+
+          expect(y2storage_settings.lvm).to eq(true)
+          expect(y2storage_settings.separate_vgs).to eq(true)
+          expect(y2storage_settings.lvm_vg_reuse).to eq(false)
+          expect(y2storage_settings.lvm_vg_strategy).to eq(:use_needed)
         end
+      end
 
-        context "and there is a boot device" do
-          before do
-            settings.boot_device = "/dev/sda"
+      before do
+        settings.volumes = [
+          Agama::Storage::Volume.new("/test1"),
+          Agama::Storage::Volume.new("/test2"),
+          Agama::Storage::Volume.new("/test3").tap do |volume|
+            volume.location.target = :new_partition
+            volume.location.device = "/dev/sdb"
           end
+        ]
+      end
 
-          it "uses the boot device as candidate device" do
-            y2storage_settings = subject.convert
+      context "when the device settings is set to use a disk" do
+        before do
+          settings.device = Agama::Storage::DeviceSettings::Disk.new("/dev/sda")
+          settings.boot.device = "/dev/sdb"
+        end
 
-            expect(y2storage_settings).to have_attributes(
-              candidate_devices: contain_exactly("/dev/sda")
-            )
-          end
+        it "sets lvm to false" do
+          y2storage_settings = subject.convert
+
+          expect(y2storage_settings.lvm).to eq(false)
+        end
+
+        it "sets the target device as device for the volumes with missing device" do
+          y2storage_settings = subject.convert
+
+          expect(y2storage_settings.volumes).to contain_exactly(
+            an_object_having_attributes(mount_point: "/test1", device: "/dev/sda"),
+            an_object_having_attributes(mount_point: "/test2", device: "/dev/sda"),
+            an_object_having_attributes(mount_point: "/test3", device: "/dev/sdb")
+          )
+        end
+
+        it "sets the boot device as candidate device" do
+          y2storage_settings = subject.convert
+
+          expect(y2storage_settings.candidate_devices).to contain_exactly("/dev/sdb")
         end
 
-        context "and there is no boot device" do
+        context "and no boot device is selected" do
           before do
-            settings.boot_device = nil
+            settings.boot.device = nil
           end
 
-          it "does not set candidate devices" do
+          it "sets the target device as candidate device" do
             y2storage_settings = subject.convert
 
-            expect(y2storage_settings).to have_attributes(
-              candidate_devices: be_empty
-            )
+            expect(y2storage_settings.candidate_devices).to contain_exactly("/dev/sda")
           end
         end
       end
 
-      context "when LVM is set but no system VG devices are indicated" do
+      context "when the device settings is set to create a new LVM volume group" do
         before do
-          settings.lvm.enabled = true
-          settings.lvm.system_vg_devices = []
+          settings.device = Agama::Storage::DeviceSettings::NewLvmVg.new(["/dev/sda", "/dev/sdb"])
         end
 
-        context "and there is a boot device" do
-          before do
-            settings.boot_device = "/dev/sda"
-          end
+        include_examples "lvm conversion"
 
-          it "uses the boot device as candidate device" do
-            y2storage_settings = subject.convert
+        it "sets the candidate PV devices as candidate devices" do
+          y2storage_settings = subject.convert
 
-            expect(y2storage_settings).to have_attributes(
-              candidate_devices: contain_exactly("/dev/sda")
-            )
-          end
+          expect(y2storage_settings.candidate_devices).to contain_exactly("/dev/sda", "/dev/sdb")
         end
 
-        context "and there is no boot device" do
-          before do
-            settings.boot_device = nil
-          end
-
-          it "does not set candidate device" do
-            y2storage_settings = subject.convert
+        it "does not set the device for the volumes with missing device" do
+          y2storage_settings = subject.convert
 
-            expect(y2storage_settings).to have_attributes(
-              candidate_devices: be_empty
-            )
-          end
+          expect(y2storage_settings.volumes).to contain_exactly(
+            an_object_having_attributes(mount_point: "/test1", device: nil),
+            an_object_having_attributes(mount_point: "/test2", device: nil),
+            an_object_having_attributes(mount_point: "/test3", device: "/dev/sdb")
+          )
         end
       end
 
-      context "when LVM is set and some system VG devices are indicated" do
+      context "when the device settings is set to reuse a LVM volume group" do
         before do
-          settings.lvm.enabled = true
-          settings.lvm.system_vg_devices = ["/dev/sdb", "/dev/sdc"]
+          settings.device = Agama::Storage::DeviceSettings::ReusedLvmVg.new("/dev/vg0")
         end
 
-        it "uses the system VG devices as candidate devices" do
+        include_examples "lvm conversion"
+
+        xit "sets the reused LVM volume group as target device" do
+          # TODO: Feature not supported yet by yast2-storage-ng.
+        end
+
+        it "does not set the device for the volumes with missing device" do
           y2storage_settings = subject.convert
 
-          expect(y2storage_settings).to have_attributes(
-            candidate_devices: contain_exactly("/dev/sdb", "/dev/sdc")
+          expect(y2storage_settings.volumes).to contain_exactly(
+            an_object_having_attributes(mount_point: "/test1", device: nil),
+            an_object_having_attributes(mount_point: "/test2", device: nil),
+            an_object_having_attributes(mount_point: "/test3", device: "/dev/sdb")
           )
         end
       end
     end
 
+    context "boot conversion" do
+      context "if boot configuration is enabled" do
+        before do
+          settings.boot.configure = true
+        end
+
+        it "sets boot to true" do
+          y2storage_settings = subject.convert
+
+          expect(y2storage_settings.boot).to eq(true)
+        end
+      end
+
+      context "if boot configuration is disabled" do
+        before do
+          settings.boot.configure = false
+        end
+
+        it "sets boot to false" do
+          y2storage_settings = subject.convert
+
+          expect(y2storage_settings.boot).to eq(false)
+        end
+      end
+
+      context "if a boot device is selected" do
+        before do
+          settings.boot.device = "/dev/sda"
+        end
+
+        it "sets the boot device as root device" do
+          y2storage_settings = subject.convert
+
+          expect(y2storage_settings.root_device).to eq("/dev/sda")
+        end
+      end
+
+      context "if no boot device is selected" do
+        before do
+          settings.boot.device = nil
+        end
+
+        context "and the device settings is set to use a disk" do
+          before do
+            settings.device = Agama::Storage::DeviceSettings::Disk.new("/dev/sda")
+          end
+
+          it "sets the target device as root device" do
+            y2storage_settings = subject.convert
+
+            expect(y2storage_settings.root_device).to eq("/dev/sda")
+          end
+        end
+
+        context "and the device settings is set to create a new LVM volume group" do
+          before do
+            settings.device = Agama::Storage::DeviceSettings::NewLvmVg.new(["/dev/sda", "/dev/sdb"])
+          end
+
+          it "sets the first candidate device as root device" do
+            y2storage_settings = subject.convert
+
+            expect(y2storage_settings.root_device).to eq("/dev/sda")
+          end
+        end
+      end
+    end
+
     context "space policy conversion" do
       before do
         mock_storage(devicegraph: "staging-plain-partitions.yaml")
diff --git a/service/test/agama/storage/proposal_settings_conversion_test.rb b/service/test/agama/storage/proposal_settings_conversion_test.rb
index 63f9cde502..085e35f37b 100644
--- a/service/test/agama/storage/proposal_settings_conversion_test.rb
+++ b/service/test/agama/storage/proposal_settings_conversion_test.rb
@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-# Copyright (c) [2023] SUSE LLC
+# Copyright (c) [2023-2024] SUSE LLC
 #
 # All Rights Reserved.
 #
@@ -20,19 +20,19 @@
 # find current contact information at www.suse.com.
 
 require_relative "../../test_helper"
-require "agama/storage/proposal_settings_conversion"
-require "agama/storage/proposal_settings"
 require "agama/config"
+require "agama/storage/proposal_settings"
+require "agama/storage/proposal_settings_conversion"
 require "y2storage"
 
 describe Agama::Storage::ProposalSettingsConversion do
   describe "#from_y2storage" do
-    let(:config) { Agama::Config.new }
-
     let(:y2storage_settings) { Y2Storage::ProposalSettings.new }
 
+    let(:settings) { Agama::Storage::ProposalSettings.new }
+
     it "generates proposal settings from Y2Storage settings" do
-      result = described_class.from_y2storage(y2storage_settings, config: config)
+      result = described_class.from_y2storage(y2storage_settings, settings)
       expect(result).to be_a(Agama::Storage::ProposalSettings)
     end
   end
diff --git a/service/test/agama/storage/proposal_settings_reader_test.rb b/service/test/agama/storage/proposal_settings_reader_test.rb
index b5bed59cf0..ed7b77b199 100644
--- a/service/test/agama/storage/proposal_settings_reader_test.rb
+++ b/service/test/agama/storage/proposal_settings_reader_test.rb
@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-# Copyright (c) [2022-2023] SUSE LLC
+# Copyright (c) [2022-2024] SUSE LLC
 #
 # All Rights Reserved.
 #
@@ -20,9 +20,10 @@
 # find current contact information at www.suse.com.
 
 require_relative "../../test_helper"
-require "agama/storage/proposal_settings_reader"
-require "agama/storage/proposal_settings"
 require "agama/config"
+require "agama/storage/device_settings"
+require "agama/storage/proposal_settings"
+require "agama/storage/proposal_settings_reader"
 require "y2storage"
 
 describe Agama::Storage::ProposalSettingsReader do
@@ -31,147 +32,132 @@
   subject { described_class.new(config) }
 
   describe "#read" do
-    let(:config_data) do
-      {
-        "storage" => {
-          "lvm"              => true,
-          "space_policy"     => "delete",
-          "encryption"       => {
-            "method"        => "luks2",
-            "pbkd_function" => "argon2id"
-          },
-          "volumes"          => ["/", "swap"],
-          "volume_templates" => [
-            {
-              "mount_path" => "/",
-              "outline"    => { "required" => true }
-            },
-            {
-              "mount_path" => "/home",
-              "outline"    => { "required" => false }
-            },
-            {
-              "mount_path" => "swap",
-              "outline"    => { "required" => false }
-            }
-          ]
-        }
-      }
-    end
-
-    it "generates proposal settings from the config" do
-      settings = subject.read
-
-      expect(settings).to be_a(Agama::Storage::ProposalSettings)
-      expect(settings).to have_attributes(
-        boot_device: nil,
-        lvm:         an_object_having_attributes(
-          enabled?:          true,
-          system_vg_devices: be_empty
-        ),
-        encryption:  an_object_having_attributes(
-          password:      nil,
-          method:        Y2Storage::EncryptionMethod::LUKS2,
-          pbkd_function: Y2Storage::PbkdFunction::ARGON2ID
-        ),
-        space:       an_object_having_attributes(
-          policy:  :delete,
-          actions: {}
-        ),
-        volumes:     contain_exactly(
-          an_object_having_attributes(mount_path: "/"),
-          an_object_having_attributes(mount_path: "swap")
-        )
-      )
-    end
-
     context "when the config does not contain storage section" do
       let(:config_data) { {} }
 
       it "generates proposal settings with default values" do
         settings = subject.read
 
-        expect(settings).to have_attributes(
-          boot_device: nil,
-          lvm:         an_object_having_attributes(
-            enabled?:          false,
-            system_vg_devices: be_empty
-          ),
-          encryption:  an_object_having_attributes(
-            password:      nil,
-            method:        Y2Storage::EncryptionMethod::LUKS2,
-            pbkd_function: Y2Storage::PbkdFunction::PBKDF2
-          ),
-          space:       an_object_having_attributes(
-            policy:  :keep,
-            actions: {}
-          ),
-          volumes:     be_empty
-        )
+        expect(settings).to be_a(Agama::Storage::ProposalSettings)
+        expect(settings.device).to be_a(Agama::Storage::DeviceSettings::Disk)
+        expect(settings.device.name).to be_nil
+        expect(settings.boot.device).to be_nil
+        expect(settings.encryption.password).to be_nil
+        expect(settings.encryption.method).to eq(Y2Storage::EncryptionMethod::LUKS2)
+        expect(settings.encryption.pbkd_function).to eq(Y2Storage::PbkdFunction::PBKDF2)
+        expect(settings.space.policy).to eq(:keep)
+        expect(settings.space.actions).to eq({})
+        expect(settings.volumes).to be_empty
       end
     end
 
-    context "when the config contains an unknown encryption method" do
+    context "when the config contains a storage section" do
       let(:config_data) do
         {
           "storage" => {
-            "encyption" => {
-              "method" => "fooenc"
-            }
+            "lvm"              => false,
+            "space_policy"     => "delete",
+            "encryption"       => {
+              "method"        => "luks2",
+              "pbkd_function" => "argon2id"
+            },
+            "volumes"          => ["/", "swap"],
+            "volume_templates" => [
+              {
+                "mount_path" => "/",
+                "outline"    => { "required" => true }
+              },
+              {
+                "mount_path" => "/home",
+                "outline"    => { "required" => false }
+              },
+              {
+                "mount_path" => "swap",
+                "outline"    => { "required" => false }
+              }
+            ]
           }
         }
       end
 
-      it "uses the default encryption method" do
+      it "generates proposal settings from the config" do
         settings = subject.read
 
-        expect(settings).to have_attributes(
-          encryption: an_object_having_attributes(
-            method: Y2Storage::EncryptionMethod::LUKS2
-          )
+        expect(settings).to be_a(Agama::Storage::ProposalSettings)
+        expect(settings.device).to be_a(Agama::Storage::DeviceSettings::Disk)
+        expect(settings.device.name).to be_nil
+        expect(settings.boot.device).to be_nil
+        expect(settings.encryption.password).to be_nil
+        expect(settings.encryption.method).to eq(Y2Storage::EncryptionMethod::LUKS2)
+        expect(settings.encryption.pbkd_function).to eq(Y2Storage::PbkdFunction::ARGON2ID)
+        expect(settings.space.policy).to eq(:delete)
+        expect(settings.space.actions).to eq({})
+        expect(settings.volumes).to contain_exactly(
+          an_object_having_attributes(mount_path: "/"),
+          an_object_having_attributes(mount_path: "swap")
         )
       end
-    end
 
-    context "when the config contains an unknown password derivation function" do
-      let(:config_data) do
-        {
-          "storage" => {
-            "encyption" => {
-              "pbkd_function" => "foo"
-            }
-          }
-        }
+      context "if lvm is disabled" do
+        before do
+          config_data["storage"]["lvm"] = false
+        end
+
+        it "generates device settings to use a disk as target device" do
+          settings = subject.read
+
+          expect(settings.device).to be_a(Agama::Storage::DeviceSettings::Disk)
+          expect(settings.device.name).to be_nil
+        end
       end
 
-      it "sets the default derivation function" do
-        settings = subject.read
+      context "if lvm is enabled" do
+        before do
+          config_data["storage"]["lvm"] = true
+        end
 
-        expect(settings).to have_attributes(
-          encryption: an_object_having_attributes(
-            pbkd_function: Y2Storage::PbkdFunction::PBKDF2
-          )
-        )
+        it "generates device settings to use a new LVM volume group as target device" do
+          settings = subject.read
+
+          expect(settings.device).to be_a(Agama::Storage::DeviceSettings::NewLvmVg)
+          expect(settings.device.candidate_pv_devices).to be_empty
+        end
       end
-    end
 
-    context "when the config contains an unknown space policy" do
-      let(:config_data) do
-        {
-          "storage" => {
-            "space_policy" => "foo"
-          }
-        }
+      context "if the encryption method is unknown" do
+        before do
+          config_data["storage"]["encryption"]["method"] = "fooenc"
+        end
+
+        it "uses the default encryption method" do
+          settings = subject.read
+
+          expect(settings.encryption.method).to eq(Y2Storage::EncryptionMethod::LUKS2)
+        end
       end
 
-      it "uses the default space policy" do
-        settings = subject.read
+      context "if the password derivation function is unknown" do
+        before do
+          config_data["storage"]["encryption"]["pbkd_function"] = "foo"
+        end
 
-        expect(settings).to have_attributes(
-          space: an_object_having_attributes(
-            policy: :keep
-          )
-        )
+        it "uses the default derivation function" do
+          settings = subject.read
+
+          expect(settings.encryption.pbkd_function).to eq(Y2Storage::PbkdFunction::PBKDF2)
+        end
+      end
+
+      context "if the space policy is unknown" do
+        before do
+          config_data["storage"]["space_policy"] = "foo"
+        end
+
+        it "uses the default space policy" do
+          settings = subject.read
+
+          expect(settings.space.policy).to eq(:keep)
+        end
       end
     end
   end
diff --git a/service/test/agama/storage/proposal_settings_test.rb b/service/test/agama/storage/proposal_settings_test.rb
new file mode 100644
index 0000000000..82fcc58d8b
--- /dev/null
+++ b/service/test/agama/storage/proposal_settings_test.rb
@@ -0,0 +1,173 @@
+# frozen_string_literal: true
+
+# Copyright (c) [2024] SUSE LLC
+#
+# All Rights Reserved.
+#
+# This program is free software; you can redistribute it and/or modify it
+# under the terms of version 2 of the GNU General Public License as published
+# by the Free Software Foundation.
+#
+# This program is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+# FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+# more details.
+#
+# You should have received a copy of the GNU General Public License along
+# with this program; if not, contact SUSE LLC.
+#
+# To contact SUSE LLC about this file by physical or electronic mail, you may
+# find current contact information at www.suse.com.
+
+require_relative "../../test_helper"
+require "agama/storage/device_settings"
+require "agama/storage/proposal_settings"
+require "agama/storage/volume"
+
+describe Agama::Storage::ProposalSettings do
+  describe "#default_boot_device" do
+    context "when the device is configured to use a disk" do
+      before do
+        subject.device = Agama::Storage::DeviceSettings::Disk.new
+      end
+
+      context "and no device is selected yet" do
+        before do
+          subject.device.name = nil
+        end
+
+        it "returns nil" do
+          expect(subject.default_boot_device).to be_nil
+        end
+      end
+
+      context "and a device is selected" do
+        before do
+          subject.device.name = "/dev/sda"
+        end
+
+        it "returns the target device" do
+          expect(subject.default_boot_device).to eq("/dev/sda")
+        end
+      end
+    end
+
+    context "when the device is configured to create a new LVM volume group" do
+      before do
+        subject.device = Agama::Storage::DeviceSettings::NewLvmVg.new
+      end
+
+      context "and no device is selected yet" do
+        before do
+          subject.device.candidate_pv_devices = []
+        end
+
+        it "returns nil" do
+          expect(subject.default_boot_device).to be_nil
+        end
+      end
+
+      context "and some candidate devices for creating the LVM physical volumes are selected" do
+        before do
+          subject.device.candidate_pv_devices = ["/dev/sdc", "/dev/sda", "/dev/sdb"]
+        end
+
+        it "returns the first candidate device in alphabetical order" do
+          expect(subject.default_boot_device).to eq("/dev/sda")
+        end
+      end
+    end
+  end
+
+  describe "#installation_devices" do
+    shared_examples "boot device" do
+      context "when boot is set to be configured" do
+        before do
+          subject.boot.configure = true
+          subject.boot.device = "/dev/sdc"
+        end
+
+        it "includes the boot device" do
+          expect(subject.installation_devices).to include("/dev/sdc")
+        end
+      end
+
+      context "when boot is not set to be configured" do
+        before do
+          subject.boot.configure = false
+          subject.boot.device = "/dev/sdc"
+        end
+
+        it "does not include the boot device" do
+          expect(subject.installation_devices).to_not include("/dev/sdc")
+        end
+      end
+    end
+
+    shared_examples "volume devices" do
+      before do
+        subject.volumes = [volume1, volume2]
+      end
+
+      let(:volume1) do
+        Agama::Storage::Volume.new("/").tap do |volume|
+          volume.location.target = :new_partition
+          volume.location.device = "/dev/sdd"
+        end
+      end
+
+      let(:volume2) do
+        Agama::Storage::Volume.new("/").tap do |volume|
+          volume.location.target = :new_partition
+          volume.location.device = "/dev/sde"
+        end
+      end
+
+      it "includes the devices assigned to the volumes" do
+        expect(subject.installation_devices).to include("/dev/sdd", "/dev/sde")
+      end
+    end
+
+    context "when the device is configured to use a disk" do
+      before do
+        subject.device = Agama::Storage::DeviceSettings::Disk.new("/dev/sda")
+      end
+
+      it "includes the target device" do
+        expect(subject.installation_devices).to include("/dev/sda")
+      end
+
+      include_examples "boot device"
+
+      include_examples "volume devices"
+    end
+
+    context "when the device is configured to create a new LVM volume group" do
+      before do
+        subject.device = Agama::Storage::DeviceSettings::NewLvmVg.new(["/dev/sda", "/dev/sdb"])
+      end
+
+      it "includes the target devices for creating new LVM physical volumes" do
+        expect(subject.installation_devices).to include("/dev/sda", "/dev/sdb")
+      end
+
+      include_examples "boot device"
+
+      include_examples "volume devices"
+    end
+
+    context "when the device is configured to reuse a LVM volume group" do
+      before do
+        subject.device = Agama::Storage::DeviceSettings::ReusedLvmVg.new("/dev/vg0")
+      end
+
+      it "includes the target LVM volume group" do
+        expect(subject.installation_devices).to include("/dev/vg0")
+      end
+
+      include_examples "boot device"
+
+      include_examples "volume devices"
+    end
+  end
+end
diff --git a/service/test/agama/storage/proposal_test.rb b/service/test/agama/storage/proposal_test.rb
index c56237b394..a9bf94206c 100644
--- a/service/test/agama/storage/proposal_test.rb
+++ b/service/test/agama/storage/proposal_test.rb
@@ -21,9 +21,10 @@
 
 require_relative "../../test_helper"
 require_relative "storage_helpers"
+require "agama/config"
+require "agama/storage/device_settings"
 require "agama/storage/proposal"
 require "agama/storage/proposal_settings"
-require "agama/config"
 require "y2storage"
 
 describe Agama::Storage::Proposal do
@@ -39,14 +40,15 @@
 
   let(:achievable_settings) do
     Agama::Storage::ProposalSettings.new.tap do |settings|
-      settings.boot_device = "/dev/sdb"
+      settings.device.name = "/dev/sdb"
+      settings.boot.device = "/dev/sda"
       settings.volumes = [Agama::Storage::Volume.new("/")]
     end
   end
 
   let(:impossible_settings) do
     Agama::Storage::ProposalSettings.new.tap do |settings|
-      settings.boot_device = "/dev/sdb"
+      settings.device.name = "/dev/sdb"
       settings.volumes = [
         # The boot disk size is 500 GiB, so it cannot accomodate a 1 TiB volume.
         Agama::Storage::Volume.new("/").tap { |v| v.min_size = Y2Storage::DiskSize.TiB(1) }
@@ -89,11 +91,10 @@
       subject.calculate(achievable_settings)
 
       expect(Y2Storage::StorageManager.instance.proposal).to_not be_nil
-      expect(Y2Storage::StorageManager.instance.proposal.settings).to have_attributes(
-        root_device: "/dev/sdb",
-        volumes:     contain_exactly(
-          an_object_having_attributes(mount_point: "/")
-        )
+      y2storage_settings = Y2Storage::StorageManager.instance.proposal.settings
+      expect(y2storage_settings.root_device).to eq("/dev/sda")
+      expect(y2storage_settings.volumes).to contain_exactly(
+        an_object_having_attributes(mount_point: "/", device: "/dev/sdb")
       )
     end
 
@@ -115,17 +116,43 @@
       expect(subject.calculate(impossible_settings)).to eq(false)
     end
 
-    context "if the given settings does not indicate a boot device" do
-      let(:settings) do
-        achievable_settings.tap { |s| s.boot_device = nil }
+    context "if the given device settings sets a disk as target" do
+      before do
+        achievable_settings.device = Agama::Storage::DeviceSettings::Disk.new
       end
 
-      it "calculates a new proposal using the first disk as boot device" do
-        subject.calculate(settings)
+      context "and the target disk is not indicated" do
+        before do
+          achievable_settings.device.name = nil
+        end
 
-        expect(Y2Storage::StorageManager.instance.proposal.settings).to have_attributes(
-          root_device: "/dev/sda"
-        )
+        it "sets the first available device as target device for volumes" do
+          subject.calculate(achievable_settings)
+          y2storage_settings = Y2Storage::StorageManager.instance.proposal.settings
+
+          expect(y2storage_settings.volumes).to contain_exactly(
+            an_object_having_attributes(mount_point: "/", device: "/dev/sda")
+          )
+        end
+      end
+    end
+
+    context "if the given device settings sets a new LVM volume group as target" do
+      before do
+        achievable_settings.device = Agama::Storage::DeviceSettings::NewLvmVg.new
+      end
+
+      context "and the target disks for physical volumes are not indicated" do
+        before do
+          achievable_settings.device.candidate_pv_devices = []
+        end
+
+        it "sets the first available device as candidate device" do
+          subject.calculate(achievable_settings)
+          y2storage_settings = Y2Storage::StorageManager.instance.proposal.settings
+
+          expect(y2storage_settings.candidate_devices).to contain_exactly("/dev/sda")
+        end
       end
     end
   end
@@ -137,79 +164,19 @@
 
     context "if the proposal was already calculated" do
       before do
-        subject.calculate(settings)
-      end
-
-      let(:settings) do
-        achievable_settings.tap do |settings|
-          settings.space.policy = :custom
-          settings.space.actions = { "/dev/sda" => :force_delete }
-        end
+        subject.calculate(achievable_settings)
       end
 
       it "returns the settings used for calculating the proposal" do
         expect(subject.settings).to be_a(Agama::Storage::ProposalSettings)
 
         expect(subject.settings).to have_attributes(
-          boot_device: "/dev/sdb",
-          volumes:     contain_exactly(
+          device:  an_object_having_attributes(name: "/dev/sdb"),
+          volumes: contain_exactly(
             an_object_having_attributes(mount_path: "/")
-          ),
-          # Checking space policy explicitly here because the settings converter cannot infer the
-          # space policy from the Y2Storage settings. The space policy is directly recovered from
-          # the original settings passed to #calculate.
-          space:       an_object_having_attributes(policy: :custom)
+          )
         )
       end
-
-      # Checking system VG devices explicitly here because the settings converter cannot infer the
-      # system VG devices from the Y2Storage settings in all cases. The system VG devices are
-      # directly recovered from the original settings passed to #calculate.
-      context "system VG devices" do
-        let(:settings) do
-          achievable_settings.tap do |settings|
-            settings.lvm.system_vg_devices = system_vg_devices
-          end
-        end
-
-        context "if no devices were assigned as system VG devices" do
-          let(:system_vg_devices) { [] }
-
-          it "returns settings containing no system VG devices " do
-            expect(subject.settings).to have_attributes(
-              lvm: an_object_having_attributes(
-                system_vg_devices: be_empty
-              )
-            )
-          end
-        end
-
-        context "if only boot device was assigned as system VG device" do
-          let(:system_vg_devices) { ["/dev/sdb"] }
-
-          # This case cannot be inferred by conversion from Y2Storage, so the test does not pass if
-          # system VG devices are not copied from the settings passed to #calculate.
-          it "returns settings containing only boot device as system VG device" do
-            expect(subject.settings).to have_attributes(
-              lvm: an_object_having_attributes(
-                system_vg_devices: contain_exactly("/dev/sdb")
-              )
-            )
-          end
-        end
-
-        context "if several devices were assigned as system VG devices" do
-          let(:system_vg_devices) { ["/dev/sdb", "/dev/sdc"] }
-
-          it "returns settings containing the system VG devices" do
-            expect(subject.settings).to have_attributes(
-              lvm: an_object_having_attributes(
-                system_vg_devices: contain_exactly("/dev/sdb", "/dev/sdc")
-              )
-            )
-          end
-        end
-      end
     end
   end
 
@@ -263,13 +230,13 @@
         )
       end
 
-      context "and the settings does not indicate a boot device" do
+      context "and the settings does not indicate a target device" do
         before do
           # Avoid to automatically set the first device
           allow(subject).to receive(:available_devices).and_return([])
         end
 
-        let(:settings) { impossible_settings.tap { |s| s.boot_device = nil } }
+        let(:settings) { impossible_settings.tap { |s| s.device.name = nil } }
 
         it "includes an error because a device is not selected" do
           subject.calculate(settings)
@@ -279,19 +246,23 @@
           )
 
           expect(subject.issues).to_not include(
-            an_object_having_attributes(description: /device is not found/)
+            an_object_having_attributes(description: /is not found/)
+          )
+
+          expect(subject.issues).to_not include(
+            an_object_having_attributes(description: /are not found/)
           )
         end
       end
 
-      context "and the boot device is missing in the system" do
-        let(:settings) { impossible_settings.tap { |s| s.boot_device = "/dev/vdz" } }
+      context "and some installation device is missing in the system" do
+        let(:settings) { impossible_settings.tap { |s| s.device.name = "/dev/vdz" } }
 
         it "includes an error because the device is not found" do
           subject.calculate(settings)
 
           expect(subject.issues).to include(
-            an_object_having_attributes(description: /device is not found/)
+            an_object_having_attributes(description: /is not found/)
           )
         end
       end
diff --git a/service/test/agama/storage/proposal_volumes_test.rb b/service/test/agama/storage/proposal_volumes_test.rb
index e571321799..d6f3867f6a 100644
--- a/service/test/agama/storage/proposal_volumes_test.rb
+++ b/service/test/agama/storage/proposal_volumes_test.rb
@@ -83,11 +83,14 @@
   end
 
   let(:y2storage_proposal) do
-    instance_double(Y2Storage::MinGuidedProposal, propose: true, failed?: false)
+    instance_double(Y2Storage::MinGuidedProposal,
+      propose: true, failed?: false, settings: y2storage_settings, planned_devices: [])
   end
 
   let(:vol_builder) { Agama::Storage::VolumeTemplatesBuilder.new_from_config(config) }
 
+  let(:y2storage_settings) { Y2Storage::ProposalSettings.new }
+
   # Constructs a Agama volume with the given set of attributes
   #
   # @param attrs [Hash] set of attributes and their values (sizes can be provided as strings)
@@ -113,7 +116,7 @@ def test_vol(path, attrs = {})
   # 'y2storage_proposal'
   #
   # @param specs [Hash] arguments to check on each VolumeSpecification object
-  def expect_proposal_with_expects(*specs)
+  def expect_proposal_with_specs(*specs)
     expect(Y2Storage::MinGuidedProposal).to receive(:new) do |**args|
       expect(args[:settings]).to be_a(Y2Storage::ProposalSettings)
       expect(args[:settings].volumes).to all(be_a(Y2Storage::VolumeSpecification))
@@ -130,11 +133,14 @@ def expect_proposal_with_expects(*specs)
 
     describe "#calculate" do
       before do
+        allow(Y2Storage::StorageManager.instance)
+          .to receive(:proposal).and_return(y2storage_proposal)
+
         allow(Y2Storage::StorageManager.instance).to receive(:proposal=)
       end
 
       it "runs the Y2Storage proposal with the correct set of VolumeSpecification" do
-        expect_proposal_with_expects(
+        expect_proposal_with_specs(
           {
             mount_point: "/", proposed: true, snapshots: false,
             ignore_fallback_sizes: false, ignore_snapshots_sizes: false,
@@ -168,11 +174,14 @@ def expect_proposal_with_expects(*specs)
 
     describe "#calculate" do
       before do
+        allow(Y2Storage::StorageManager.instance)
+          .to receive(:proposal).and_return(y2storage_proposal)
+
         allow(Y2Storage::StorageManager.instance).to receive(:proposal=)
       end
 
       it "runs the Y2Storage proposal with the correct set of VolumeSpecification" do
-        expect_proposal_with_expects(
+        expect_proposal_with_specs(
           {
             mount_point: "/", proposed: true, snapshots: true,
             ignore_fallback_sizes: false, ignore_snapshots_sizes: false,
@@ -207,11 +216,14 @@ def expect_proposal_with_expects(*specs)
 
     describe "#calculate" do
       before do
+        allow(Y2Storage::StorageManager.instance)
+          .to receive(:proposal).and_return(y2storage_proposal)
+
         allow(Y2Storage::StorageManager.instance).to receive(:proposal=)
       end
 
       it "runs the Y2Storage proposal with the correct set of VolumeSpecification" do
-        expect_proposal_with_expects(
+        expect_proposal_with_specs(
           {
             mount_point: "/", proposed: true, snapshots: true,
             ignore_fallback_sizes: false, ignore_snapshots_sizes: false,
@@ -246,11 +258,14 @@ def expect_proposal_with_expects(*specs)
 
     describe "#calculate" do
       before do
+        allow(Y2Storage::StorageManager.instance)
+          .to receive(:proposal).and_return(y2storage_proposal)
+
         allow(Y2Storage::StorageManager.instance).to receive(:proposal=)
       end
 
       it "runs the Y2Storage proposal with the correct set of VolumeSpecification" do
-        expect_proposal_with_expects(
+        expect_proposal_with_specs(
           { mount_point: "/", proposed: true },
           { mount_point: "/two", proposed: false },
           {
@@ -288,11 +303,14 @@ def expect_proposal_with_expects(*specs)
 
     describe "#calculate" do
       before do
+        allow(Y2Storage::StorageManager.instance)
+          .to receive(:proposal).and_return(y2storage_proposal)
+
         allow(Y2Storage::StorageManager.instance).to receive(:proposal=)
       end
 
       it "runs the Y2Storage proposal with the correct set of VolumeSpecification" do
-        expect_proposal_with_expects(
+        expect_proposal_with_specs(
           {
             mount_point: "/", proposed: true, snapshots: false,
             ignore_fallback_sizes: true, ignore_snapshots_sizes: true,
diff --git a/service/test/agama/storage/volume_conversion/from_y2storage_test.rb b/service/test/agama/storage/volume_conversion/from_y2storage_test.rb
index 22108805de..55da4f8edb 100644
--- a/service/test/agama/storage/volume_conversion/from_y2storage_test.rb
+++ b/service/test/agama/storage/volume_conversion/from_y2storage_test.rb
@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-# Copyright (c) [2023] SUSE LLC
+# Copyright (c) [2023-2024] SUSE LLC
 #
 # All Rights Reserved.
 #
@@ -22,8 +22,8 @@
 require_relative "../../../test_helper"
 require_relative "../storage_helpers"
 require_relative "../../rspec/matchers/storage"
+require "agama/storage/volume"
 require "agama/storage/volume_conversion/from_y2storage"
-require "agama/config"
 require "y2storage"
 
 describe Agama::Storage::VolumeConversion::FromY2Storage do
@@ -31,86 +31,53 @@
 
   before { mock_storage }
 
-  subject { described_class.new(spec, config: config) }
-
-  let(:config) { Agama::Config.new }
-
-  describe "#convert" do
-    let(:spec) do
-      Y2Storage::VolumeSpecification.new({}).tap do |spec|
-        spec.mount_point = "/"
-        spec.device = "/dev/sda"
-        spec.separate_vg_name = "/dev/vg0"
-        spec.mount_options = ["defaults", "ro"]
-        spec.fs_type = Y2Storage::Filesystems::Type::BTRFS
-        spec.min_size = Y2Storage::DiskSize.GiB(5)
-        spec.max_size = Y2Storage::DiskSize.GiB(20)
-        spec.snapshots = true
-        spec.subvolumes = ["@/home", "@/var"]
-        spec.btrfs_default_subvolume = "@"
-        spec.btrfs_read_only = true
-      end
-    end
-
-    it "converts the Y2Storage volume spec to an Agama volume" do
-      volume = subject.convert
-
-      expect(volume).to be_a(Agama::Storage::Volume)
-      expect(volume).to have_attributes(
-        mount_path:    "/",
-        location:      an_object_having_attributes(
-          device: "/dev/sda",
-          target: :new_vg
-        ),
-        mount_options: contain_exactly("defaults", "ro"),
-        fs_type:       Y2Storage::Filesystems::Type::BTRFS,
-        min_size:      Y2Storage::DiskSize.GiB(5),
-        max_size:      Y2Storage::DiskSize.GiB(20),
-        btrfs:         an_object_having_attributes(
-          snapshots?:        true,
-          subvolumes:        contain_exactly("@/home", "@/var"),
-          default_subvolume: "@",
-          read_only?:        true
-        )
-      )
-
-      outline = Agama::Storage::VolumeTemplatesBuilder.new_from_config(config).for("/").outline
-      expect(volume.outline).to eq_outline(outline)
+  subject { described_class.new(volume) }
+
+  let(:btrfs) { Y2Storage::Filesystems::Type::BTRFS }
+  let(:ext4) { Y2Storage::Filesystems::Type::EXT4 }
+  let(:xfs) { Y2Storage::Filesystems::Type::XFS }
+
+  let(:volume) do
+    Agama::Storage::Volume.new("/").tap do |volume|
+      volume.location.target = :new_vg
+      volume.location.device = "/dev/sda"
+      volume.mount_options = ["defaults"]
+      volume.fs_type = btrfs
+      volume.auto_size = false
+      volume.min_size = Y2Storage::DiskSize.GiB(5)
+      volume.max_size = Y2Storage::DiskSize.GiB(20)
+      volume.btrfs.snapshots = true
+      volume.btrfs.subvolumes = ["@/home", "@/var"]
+      volume.btrfs.default_subvolume = "@"
+      volume.btrfs.read_only = true
+      volume.outline.required = true
+      volume.outline.filesystems = [btrfs, ext4, xfs]
+      volume.outline.adjust_by_ram = false
+      volume.outline.snapshots_configurable = true
+      volume.outline.snapshots_size = Y2Storage::DiskSize.GiB(10)
+      volume.outline.snapshots_percentage = 20
     end
+  end
 
-    context "auto size conversion" do
-      before do
-        spec.ignore_fallback_sizes = ignore_fallback_sizes
-        spec.ignore_snapshots_sizes = ignore_snapshots_sizes
-      end
-
-      context "if :ignore_fallback_sizes and :ignore_snapshots_sizes are set" do
-        let(:ignore_fallback_sizes) { true }
-
-        let(:ignore_snapshots_sizes) { true }
-
-        it "does not set auto size" do
-          volume = subject.convert
-
-          expect(volume).to have_attributes(
-            auto_size?: false
-          )
-        end
-      end
-
-      context "if :ignore_fallback_sizes and :ignore_snapshots_sizes are not set" do
-        let(:ignore_fallback_sizes) { false }
-
-        let(:ignore_snapshots_sizes) { false }
-
-        it "sets auto size" do
-          volume = subject.convert
-
-          expect(volume).to have_attributes(
-            auto_size?: true
-          )
-        end
-      end
+  describe "#convert" do
+    it "generates a volume with the same values as the given volume" do
+      result = subject.convert
+
+      expect(result).to be_a(Agama::Storage::Volume)
+      expect(result).to_not equal(volume)
+      expect(result.location.target).to eq(:new_vg)
+      expect(result.location.device).to eq("/dev/sda")
+      expect(result.mount_path).to eq("/")
+      expect(result.mount_options).to contain_exactly("defaults")
+      expect(result.fs_type).to eq(btrfs)
+      expect(result.auto_size).to eq(false)
+      expect(result.min_size).to eq(Y2Storage::DiskSize.GiB(5))
+      expect(result.max_size).to eq(Y2Storage::DiskSize.GiB(20))
+      expect(result.btrfs.snapshots).to eq(true)
+      expect(result.btrfs.subvolumes).to contain_exactly("@/home", "@/var")
+      expect(result.btrfs.default_subvolume).to eq("@")
+      expect(result.btrfs.read_only).to eq(true)
+      expect(result.outline).to eq_outline(volume.outline)
     end
 
     context "sizes conversion" do
@@ -133,12 +100,10 @@
         end
 
         it "sets the min and max sizes according to the planned device" do
-          volume = subject.convert
+          result = subject.convert
 
-          expect(volume).to have_attributes(
-            min_size: Y2Storage::DiskSize.GiB(10),
-            max_size: Y2Storage::DiskSize.GiB(40)
-          )
+          expect(result.min_size).to eq(Y2Storage::DiskSize.GiB(10))
+          expect(result.max_size).to eq(Y2Storage::DiskSize.GiB(40))
         end
       end
 
@@ -152,13 +117,11 @@
           end
         end
 
-        it "sets the min and max sizes according to the volume spec" do
-          volume = subject.convert
+        it "sets the sizes of the given volume" do
+          result = subject.convert
 
-          expect(volume).to have_attributes(
-            min_size: Y2Storage::DiskSize.GiB(5),
-            max_size: Y2Storage::DiskSize.GiB(20)
-          )
+          expect(result.min_size).to eq(Y2Storage::DiskSize.GiB(5))
+          expect(result.max_size).to eq(Y2Storage::DiskSize.GiB(20))
         end
       end
     end
diff --git a/service/test/agama/storage/volume_conversion/to_y2storage_test.rb b/service/test/agama/storage/volume_conversion/to_y2storage_test.rb
index 792ee31eec..8b52a1372f 100644
--- a/service/test/agama/storage/volume_conversion/to_y2storage_test.rb
+++ b/service/test/agama/storage/volume_conversion/to_y2storage_test.rb
@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-# Copyright (c) [2023] SUSE LLC
+# Copyright (c) [2023-2024] SUSE LLC
 #
 # All Rights Reserved.
 #
@@ -57,31 +57,29 @@
       spec = subject.convert
 
       expect(spec).to be_a(Y2Storage::VolumeSpecification)
-      expect(spec).to have_attributes(
-        device:                  "/dev/sda",
-        separate_vg_name:        "vg-root",
-        mount_point:             "/",
-        mount_options:           "defaults",
-        proposed?:               true,
-        proposed_configurable?:  false,
-        fs_types:                contain_exactly(btrfs, ext4, xfs),
-        fs_type:                 btrfs,
-        weight:                  100,
-        adjust_by_ram?:          false,
-        ignore_fallback_sizes:   true,
-        ignore_snapshots_sizes:  true,
-        ignore_adjust_by_ram:    true,
-        min_size:                Y2Storage::DiskSize.GiB(5),
-        max_size:                Y2Storage::DiskSize.GiB(20),
-        max_size_lvm:            Y2Storage::DiskSize.GiB(20),
-        snapshots:               true,
-        snapshots_configurable?: true,
-        snapshots_size:          Y2Storage::DiskSize.GiB(10),
-        snapshots_percentage:    20,
-        subvolumes:              ["@/home", "@/var"],
-        btrfs_default_subvolume: "@",
-        btrfs_read_only:         true
-      )
+      expect(spec.device).to eq("/dev/sda")
+      expect(spec.separate_vg_name).to eq("vg-root")
+      expect(spec.mount_point).to eq("/")
+      expect(spec.mount_options).to eq("defaults")
+      expect(spec.proposed).to eq(true)
+      expect(spec.proposed_configurable).to eq(false)
+      expect(spec.fs_types).to contain_exactly(btrfs, ext4, xfs)
+      expect(spec.fs_type).to eq(btrfs)
+      expect(spec.weight).to eq(100)
+      expect(spec.adjust_by_ram).to eq(false)
+      expect(spec.ignore_fallback_sizes).to eq(true)
+      expect(spec.ignore_snapshots_sizes).to eq(true)
+      expect(spec.ignore_adjust_by_ram).to eq(true)
+      expect(spec.min_size).to eq(Y2Storage::DiskSize.GiB(5))
+      expect(spec.max_size).to eq(Y2Storage::DiskSize.GiB(20))
+      expect(spec.max_size_lvm).to eq(Y2Storage::DiskSize.GiB(20))
+      expect(spec.snapshots).to eq(true)
+      expect(spec.snapshots_configurable).to eq(true)
+      expect(spec.snapshots_size).to eq(Y2Storage::DiskSize.GiB(10))
+      expect(spec.snapshots_percentage).to eq(20)
+      expect(spec.subvolumes).to contain_exactly("@/home", "@/var")
+      expect(spec.btrfs_default_subvolume).to eq("@")
+      expect(spec.btrfs_read_only).to eq(true)
     end
 
     context "when auto size is used" do
@@ -94,14 +92,12 @@
       it "sets the min and max spec sizes according to the volume outline" do
         spec = subject.convert
 
-        expect(spec).to have_attributes(
-          ignore_fallback_sizes:  false,
-          ignore_snapshots_sizes: false,
-          ignore_adjust_by_ram:   false,
-          min_size:               Y2Storage::DiskSize.GiB(10),
-          max_size:               Y2Storage::DiskSize.GiB(50),
-          max_size_lvm:           Y2Storage::DiskSize.GiB(50)
-        )
+        expect(spec.ignore_fallback_sizes).to eq(false)
+        expect(spec.ignore_snapshots_sizes).to eq(false)
+        expect(spec.ignore_adjust_by_ram).to eq(false)
+        expect(spec.min_size).to eq(Y2Storage::DiskSize.GiB(10))
+        expect(spec.max_size).to eq(Y2Storage::DiskSize.GiB(50))
+        expect(spec.max_size_lvm).to eq(Y2Storage::DiskSize.GiB(50))
       end
     end
 
diff --git a/service/test/agama/storage/volume_conversion_test.rb b/service/test/agama/storage/volume_conversion_test.rb
index e9aec67a44..141831b385 100644
--- a/service/test/agama/storage/volume_conversion_test.rb
+++ b/service/test/agama/storage/volume_conversion_test.rb
@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-# Copyright (c) [2023] SUSE LLC
+# Copyright (c) [2023-2024] SUSE LLC
 #
 # All Rights Reserved.
 #
@@ -20,19 +20,18 @@
 # find current contact information at www.suse.com.
 
 require_relative "../../test_helper"
-require "agama/storage/volume_conversion"
-require "agama/storage/volume"
 require "agama/config"
+require "agama/storage/proposal_settings"
+require "agama/storage/volume"
+require "agama/storage/volume_conversion"
 require "y2storage"
 
 describe Agama::Storage::VolumeConversion do
   describe "#from_y2storage" do
-    let(:config) { Agama::Config.new }
-
-    let(:spec) { Y2Storage::VolumeSpecification.new({}) }
+    let(:volume) { Agama::Storage::Volume.new("/test") }
 
-    it "generates a volume from a Y2Storage volume spec" do
-      result = described_class.from_y2storage(spec, config: config)
+    it "generates a volume" do
+      result = described_class.from_y2storage(volume)
       expect(result).to be_a(Agama::Storage::Volume)
     end
   end
@@ -40,7 +39,7 @@
   describe "#to_y2storage" do
     let(:volume) { Agama::Storage::Volume.new("/test") }
 
-    it "generates a Y2Storage volume spec from a volume" do
+    it "generates a Y2Storage volume spec" do
       result = described_class.to_y2storage(volume)
       expect(result).to be_a(Y2Storage::VolumeSpecification)
     end
diff --git a/web/package/cockpit-agama.changes b/web/package/cockpit-agama.changes
index 03ccc839dd..66c5fb7306 100644
--- a/web/package/cockpit-agama.changes
+++ b/web/package/cockpit-agama.changes
@@ -1,3 +1,9 @@
+-------------------------------------------------------------------
+Wed Apr  3 15:16:07 UTC 2024 - José Iván López González <jlopez@suse.com>
+
+- Add new selection for the target device and for configuring the
+  boot device (gh#openSUSE/agama#1068).
+
 -------------------------------------------------------------------
 Wed Mar 27 12:41:11 UTC 2024 - Ladislav Slezák <lslezak@suse.com>
 
diff --git a/web/src/assets/styles/blocks.scss b/web/src/assets/styles/blocks.scss
index 43b336bf31..50b32062af 100644
--- a/web/src/assets/styles/blocks.scss
+++ b/web/src/assets/styles/blocks.scss
@@ -424,6 +424,51 @@ ul[data-type="agama/list"][role="grid"] {
   }
 }
 
+[data-type="agama/controlled-panels"] {
+  [data-type="agama/option"] {
+    label, input {
+      cursor: pointer;
+    }
+
+    label {
+      display: flex;
+      gap: var(--spacer-smaller);
+    }
+  }
+
+  [data-variant="buttons"] {
+    input { position: absolute; opacity: 0 }
+
+    label {
+      border: 1px solid var(--color-primary);
+      padding: var(--spacer-small);
+      gap: var(--spacer-small);
+      border-radius: var(--spacer-smaller);
+      position: relative;
+
+      &:has(input:checked) {
+        background: var(--color-primary);
+        color: white;
+      }
+
+      &:has(input:focus-visible) {
+        // outline: 1px dotted;
+        // outline-offset: 0.25rem;
+        box-shadow: 0 0 0 3px var(--focus-color);
+      }
+    }
+
+    [data-type="agama/option"]:not(:last-child) {
+      border-inline-end: 2px solid var(--color-gray-darker);
+      padding-inline-end: var(--spacer-small);
+    }
+  }
+
+  > div[aria-expanded="false"] {
+    display: none;
+  }
+}
+
 table[data-type="agama/tree-table"] {
   th:first-child {
     block-size: fit-content;
@@ -481,6 +526,8 @@ table[data-type="agama/tree-table"] {
   }
 }
 
+// FIXME: use a single selector
+table.devices-table,
 table.proposal-result {
   tr.dimmed-row {
     background-color: #fff;
@@ -670,3 +717,36 @@ section [data-type="agama/reminder"] {
     max-inline-size: 100%;
   }
 }
+
+
+[data-type="agama/expandable-selector"] {
+  // The expandable selector is built on top of PF/Table#expandable
+  // Let's tweak some styles
+  tr {
+    td:first-child {
+      padding-inline-start: 0;
+    }
+
+    td:last-child {
+      padding-inline-end: 0;
+    }
+  }
+
+  tr.pf-v5-c-table__expandable-row.pf-m-expanded {
+    border-bottom: 0;
+
+    .pf-v5-c-table__expandable-row-content {
+      font-size: var(--fs-medium);
+      padding-block: var(--spacer-small);
+    }
+  }
+}
+
+#boot-form {
+  legend {
+    label {
+      font-size: var(--fs-large);
+      font-weight: bold;
+    }
+  }
+}
diff --git a/web/src/assets/styles/variables.scss b/web/src/assets/styles/variables.scss
index 490429fe54..71a5d7e024 100644
--- a/web/src/assets/styles/variables.scss
+++ b/web/src/assets/styles/variables.scss
@@ -9,6 +9,7 @@
   --fw-bold: 700;
 
   --fs-small: 0.7rem;
+  --fs-medium: 12px;
   --fs-base: 14px;
   --fs-large: 1rem;
   --fs-h1: 1.5rem;
diff --git a/web/src/client/storage.js b/web/src/client/storage.js
index 4c2b2153bd..1412d80d8c 100644
--- a/web/src/client/storage.js
+++ b/web/src/client/storage.js
@@ -22,9 +22,9 @@
 // @ts-check
 // cspell:ignore ptable
 
+import { compact, hex, uniq } from "~/utils";
 import DBusClient from "./dbus";
 import { WithIssues, WithStatus, WithProgress } from "./mixins";
-import { hex } from "~/utils";
 
 const STORAGE_OBJECT = "/org/opensuse/Agama/Storage1";
 const STORAGE_IFACE = "org.opensuse.Agama.Storage1";
@@ -111,13 +111,16 @@ const ZFCP_DISK_IFACE = "org.opensuse.Agama.Storage1.ZFCP.Disk";
  * @property {boolean} delete
  *
  * @typedef {object} ProposalSettings
+ * @property {string} target
+ * @property {string} [targetDevice]
+ * @property {string[]} targetPVDevices
+ * @property {boolean} configureBoot
  * @property {string} bootDevice
+ * @property {string} defaultBootDevice
  * @property {string} encryptionPassword
  * @property {string} encryptionMethod
- * @property {boolean} lvm
  * @property {string} spacePolicy
  * @property {SpaceAction[]} spaceActions
- * @property {string[]} systemVGDevices
  * @property {Volume[]} volumes
  * @property {StorageDevice[]} installationDevices
  *
@@ -127,6 +130,8 @@ const ZFCP_DISK_IFACE = "org.opensuse.Agama.Storage1.ZFCP.Disk";
  *
  * @typedef {object} Volume
  * @property {string} mountPath
+ * @property {string} target
+ * @property {string} [targetDevice]
  * @property {string} fsType
  * @property {number} minSize
  * @property {number} [maxSize]
@@ -457,8 +462,15 @@ class ProposalManager {
         };
       };
 
-      const buildInstallationDevices = (proxy, devices) => {
-        const findDevice = (devices, name) => {
+      const buildTargetPVDevices = dbusTargetPVDevices => {
+        if (!dbusTargetPVDevices) return [];
+
+        return dbusTargetPVDevices.v.map(d => d.v);
+      };
+
+      // TODO: Read installation devices from D-Bus.
+      const buildInstallationDevices = (dbusSettings, devices) => {
+        const findDevice = (name) => {
           const device = devices.find(d => d.name === name);
 
           if (device === undefined) console.log("D-Bus object not found: ", name);
@@ -466,26 +478,39 @@ class ProposalManager {
           return device;
         };
 
-        const names = proxy.SystemVGDevices.filter(n => n !== proxy.BootDevice).concat([proxy.BootDevice]);
+        const values = [
+          dbusSettings.TargetDevice?.v,
+          buildTargetPVDevices(dbusSettings.TargetPVDevices),
+          dbusSettings.BootDevice.v,
+          dbusSettings.Volumes.v.map(vol => vol.v.TargetDevice.v)
+        ].flat();
+
+        const names = uniq(compact(values)).filter(d => d.length > 0);
+
         // #findDevice returns undefined if no device is found with the given name.
-        return names.map(dev => findDevice(devices, dev)).filter(dev => dev !== undefined);
+        return compact(names.map(n => findDevice(n)));
       };
 
+      const dbusSettings = proxy.Settings;
+
       return {
         settings: {
-          bootDevice: proxy.BootDevice,
-          lvm: proxy.LVM,
-          spacePolicy: proxy.SpacePolicy,
-          spaceActions: proxy.SpaceActions.map(buildSpaceAction),
-          systemVGDevices: proxy.SystemVGDevices,
-          encryptionPassword: proxy.EncryptionPassword,
-          encryptionMethod: proxy.EncryptionMethod,
-          volumes: proxy.Volumes.map(this.buildVolume),
+          target: dbusSettings.Target.v,
+          targetDevice: dbusSettings.TargetDevice?.v,
+          targetPVDevices: buildTargetPVDevices(dbusSettings.TargetPVDevices),
+          configureBoot: dbusSettings.ConfigureBoot.v,
+          bootDevice: dbusSettings.BootDevice.v,
+          defaultBootDevice: dbusSettings.DefaultBootDevice.v,
+          spacePolicy: dbusSettings.SpacePolicy.v,
+          spaceActions: dbusSettings.SpaceActions.v.map(a => buildSpaceAction(a.v)),
+          encryptionPassword: dbusSettings.EncryptionPassword.v,
+          encryptionMethod: dbusSettings.EncryptionMethod.v,
+          volumes: dbusSettings.Volumes.v.map(vol => this.buildVolume(vol.v)),
           // NOTE: strictly speaking, installation devices does not belong to the settings. It
           // should be a separate method instead of an attribute in the settings object.
           // Nevertheless, it was added here for simplicity and to avoid passing more props in some
           // react components. Please, do not use settings as a jumble.
-          installationDevices: buildInstallationDevices(proxy, systemDevices)
+          installationDevices: buildInstallationDevices(proxy.Settings, systemDevices)
         },
         actions: proxy.Actions.map(buildAction)
       };
@@ -502,13 +527,15 @@ class ProposalManager {
    */
   async calculate(settings) {
     const {
+      target,
+      targetDevice,
+      targetPVDevices,
+      configureBoot,
       bootDevice,
       encryptionPassword,
       encryptionMethod,
-      lvm,
       spacePolicy,
       spaceActions,
-      systemVGDevices,
       volumes
     } = settings;
 
@@ -538,13 +565,15 @@ class ProposalManager {
     };
 
     const dbusSettings = removeUndefinedCockpitProperties({
+      Target: { t: "s", v: target },
+      TargetDevice: { t: "s", v: targetDevice },
+      TargetPVDevices: { t: "as", v: targetPVDevices },
+      ConfigureBoot: { t: "b", v: configureBoot },
       BootDevice: { t: "s", v: bootDevice },
       EncryptionPassword: { t: "s", v: encryptionPassword },
       EncryptionMethod: { t: "s", v: encryptionMethod },
-      LVM: { t: "b", v: lvm },
       SpacePolicy: { t: "s", v: spacePolicy },
       SpaceActions: { t: "aa{sv}", v: dbusSpaceActions() },
-      SystemVGDevices: { t: "as", v: systemVGDevices },
       Volumes: { t: "aa{sv}", v: volumes?.map(dbusVolume) }
     });
 
@@ -559,6 +588,8 @@ class ProposalManager {
    * @param {DBusVolume} dbusVolume
    *
    * @typedef {Object} DBusVolume
+   * @property {CockpitString} Target
+   * @property {CockpitString} [TargetDevice]
    * @property {CockpitString} MountPath
    * @property {CockpitString} FsType
    * @property {CockpitNumber} MinSize
@@ -614,6 +645,8 @@ class ProposalManager {
     };
 
     return {
+      target: dbusVolume.Target.v,
+      targetDevice: dbusVolume.TargetDevice?.v,
       mountPath: dbusVolume.MountPath.v,
       fsType: dbusVolume.FsType.v,
       minSize: dbusVolume.MinSize.v,
diff --git a/web/src/client/storage.test.js b/web/src/client/storage.test.js
index 1604c04449..7fc98b979d 100644
--- a/web/src/client/storage.test.js
+++ b/web/src/client/storage.test.js
@@ -446,65 +446,98 @@ const contexts = {
   },
   withProposal: () => {
     cockpitProxies.proposal = {
-      BootDevice: "/dev/sda",
-      LVM: true,
-      SystemVGDevices: ["/dev/sda", "/dev/sdb"],
-      EncryptionPassword: "00000",
-      SpacePolicy: "custom",
-      SpaceActions: [
-        {
-          Device: { t: "s", v: "/dev/sda" },
-          Action: { t: "s", v: "force_delete" }
+      Settings: {
+        Target: { t: "s", v: "newLvmVg" },
+        TargetPVDevices: {
+          t: "av",
+          v: [
+            { t: "s", v: "/dev/sda" },
+            { t: "s", v: "/dev/sdb" }
+          ]
         },
-        {
-          Device: { t: "s", v: "/dev/sdb" },
-          Action: { t: "s", v: "resize" }
-        }
-      ],
-      Volumes: [
-        {
-          MountPath: { t: "s", v: "/" },
-          FsType: { t: "s", v: "Btrfs" },
-          MinSize: { t: "x", v: 1024 },
-          MaxSize: { t: "x", v: 2048 },
-          AutoSize: { t: "b", v: true },
-          Snapshots: { t: "b", v: true },
-          Transactional: { t: "b", v: true },
-          Outline: {
-            t: "a{sv}",
-            v: {
-              Required: { t: "b", v: true },
-              FsTypes: { t: "as", v: [{ t: "s", v: "Btrfs" }, { t: "s", v: "Ext3" }] },
-              SupportAutoSize: { t: "b", v: true },
-              SnapshotsConfigurable: { t: "b", v: true },
-              SnapshotsAffectSizes: { t: "b", v: true },
-              AdjustByRam: { t: "b", v: false },
-              SizeRelevantVolumes: { t: "as", v: [{ t: "s", v: "/home" }] }
+        ConfigureBoot: { t: "b", v: true },
+        BootDevice: { t: "s", v: "/dev/sda" },
+        DefaultBootDevice: { t: "s", v: "/dev/sdb" },
+        EncryptionPassword: { t: "s", v: "00000" },
+        EncryptionMethod: { t: "s", v: "luks1" },
+        SpacePolicy: { t: "s", v: "custom" },
+        SpaceActions: {
+          t: "av",
+          v: [
+            {
+              t: "a{sv}",
+              v: {
+                Device: { t: "s", v: "/dev/sda" },
+                Action: { t: "s", v: "force_delete" }
+              }
+            },
+            {
+              t: "a{sv}",
+              v: {
+                Device: { t: "s", v: "/dev/sdb" },
+                Action: { t: "s", v: "resize" }
+              }
             }
-          }
+          ]
         },
-        {
-          MountPath: { t: "s", v: "/home" },
-          FsType: { t: "s", v: "XFS" },
-          MinSize: { t: "x", v: 2048 },
-          MaxSize: { t: "x", v: 4096 },
-          AutoSize: { t: "b", v: false },
-          Snapshots: { t: "b", v: false },
-          Transactional: { t: "b", v: false },
-          Outline: {
-            t: "a{sv}",
-            v: {
-              Required: { t: "b", v: false },
-              FsTypes: { t: "as", v: [{ t: "s", v: "Ext4" }, { t: "s", v: "XFS" }] },
-              SupportAutoSize: { t: "b", v: false },
-              SnapshotsConfigurable: { t: "b", v: false },
-              SnapshotsAffectSizes: { t: "b", v: false },
-              AdjustByRam: { t: "b", v: false },
-              SizeRelevantVolumes: { t: "as", v: [] }
+        Volumes: {
+          t: "av",
+          v: [
+            {
+              t: "a{sv}",
+              v: {
+                MountPath: { t: "s", v: "/" },
+                Target: { t: "s", v: "default" },
+                TargetDevice: { t: "s", v: "" },
+                FsType: { t: "s", v: "Btrfs" },
+                MinSize: { t: "x", v: 1024 },
+                MaxSize: { t: "x", v: 2048 },
+                AutoSize: { t: "b", v: true },
+                Snapshots: { t: "b", v: true },
+                Transactional: { t: "b", v: true },
+                Outline: {
+                  t: "a{sv}",
+                  v: {
+                    Required: { t: "b", v: true },
+                    FsTypes: { t: "as", v: [{ t: "s", v: "Btrfs" }, { t: "s", v: "Ext3" }] },
+                    SupportAutoSize: { t: "b", v: true },
+                    SnapshotsConfigurable: { t: "b", v: true },
+                    SnapshotsAffectSizes: { t: "b", v: true },
+                    AdjustByRam: { t: "b", v: false },
+                    SizeRelevantVolumes: { t: "as", v: [{ t: "s", v: "/home" }] }
+                  }
+                }
+              }
+            },
+            {
+              t: "a{sv}",
+              v: {
+                MountPath: { t: "s", v: "/home" },
+                Target: { t: "s", v: "default" },
+                TargetDevice: { t: "s", v: "" },
+                FsType: { t: "s", v: "XFS" },
+                MinSize: { t: "x", v: 2048 },
+                MaxSize: { t: "x", v: 4096 },
+                AutoSize: { t: "b", v: false },
+                Snapshots: { t: "b", v: false },
+                Transactional: { t: "b", v: false },
+                Outline: {
+                  t: "a{sv}",
+                  v: {
+                    Required: { t: "b", v: false },
+                    FsTypes: { t: "as", v: [{ t: "s", v: "Ext4" }, { t: "s", v: "XFS" }] },
+                    SupportAutoSize: { t: "b", v: false },
+                    SnapshotsConfigurable: { t: "b", v: false },
+                    SnapshotsAffectSizes: { t: "b", v: false },
+                    AdjustByRam: { t: "b", v: false },
+                    SizeRelevantVolumes: { t: "as", v: [] }
+                  }
+                }
+              }
             }
-          }
-        }
-      ],
+          ]
+        },
+      },
       Actions: [
         {
           Device: { t: "u", v: 2 },
@@ -1379,6 +1412,8 @@ describe("#proposal", () => {
         switch (mountPath) {
           case "/home": return {
             MountPath: { t: "s", v: "/home" },
+            Target: { t: "s", v: "default" },
+            TargetDevice: { t: "s", v: "" },
             FsType: { t: "s", v: "XFS" },
             MinSize: { t: "x", v: 2048 },
             MaxSize: { t: "x", v: 4096 },
@@ -1400,6 +1435,8 @@ describe("#proposal", () => {
           };
           case "": return {
             MountPath: { t: "s", v: "" },
+            Target: { t: "s", v: "default" },
+            TargetDevice: { t: "s", v: "" },
             FsType: { t: "s", v: "Ext4" },
             MinSize: { t: "x", v: 1024 },
             MaxSize: { t: "x", v: 2048 },
@@ -1430,6 +1467,8 @@ describe("#proposal", () => {
 
       expect(home).toStrictEqual({
         mountPath: "/home",
+        target: "default",
+        targetDevice: "",
         fsType: "XFS",
         minSize: 2048,
         maxSize: 4096,
@@ -1451,6 +1490,8 @@ describe("#proposal", () => {
 
       expect(generic).toStrictEqual({
         mountPath: "",
+        target: "default",
+        targetDevice: "",
         fsType: "Ext4",
         minSize: 1024,
         maxSize: 2048,
@@ -1494,9 +1535,11 @@ describe("#proposal", () => {
         const { settings, actions } = await client.proposal.getResult();
 
         expect(settings).toMatchObject({
+          target: "newLvmVg",
+          targetPVDevices: ["/dev/sda", "/dev/sdb"],
+          configureBoot: true,
           bootDevice: "/dev/sda",
-          lvm: true,
-          systemVGDevices: ["/dev/sda", "/dev/sdb"],
+          defaultBootDevice: "/dev/sdb",
           encryptionPassword: "00000",
           spacePolicy: "custom",
           spaceActions: [
@@ -1506,6 +1549,8 @@ describe("#proposal", () => {
           volumes: [
             {
               mountPath: "/",
+              target: "default",
+              targetDevice: "",
               fsType: "Btrfs",
               minSize: 1024,
               maxSize: 2048,
@@ -1523,6 +1568,8 @@ describe("#proposal", () => {
             },
             {
               mountPath: "/home",
+              target: "default",
+              targetDevice: "",
               fsType: "XFS",
               minSize: 2048,
               maxSize: 4096,
@@ -1568,10 +1615,11 @@ describe("#proposal", () => {
 
     it("calculates a proposal with the given settings", async () => {
       await client.proposal.calculate({
+        target: "disk",
+        targetDevice: "/dev/vdc",
+        configureBoot: true,
         bootDevice: "/dev/vdb",
         encryptionPassword: "12345",
-        lvm: true,
-        systemVGDevices: ["/dev/sdc"],
         spacePolicy: "custom",
         spaceActions: [{ device: "/dev/sda", action: "resize" }],
         volumes: [
@@ -1591,10 +1639,11 @@ describe("#proposal", () => {
       });
 
       expect(cockpitProxies.proposalCalculator.Calculate).toHaveBeenCalledWith({
+        Target: { t: "s", v: "disk" },
+        TargetDevice: { t: "s", v: "/dev/vdc" },
+        ConfigureBoot: { t: "b", v: true },
         BootDevice: { t: "s", v: "/dev/vdb" },
         EncryptionPassword: { t: "s", v: "12345" },
-        LVM: { t: "b", v: true },
-        SystemVGDevices: { t: "as", v: ["/dev/sdc"] },
         SpacePolicy: { t: "s", v: "custom" },
         SpaceActions: {
           t: "aa{sv}",
diff --git a/web/src/components/core/ControlledPanels.jsx b/web/src/components/core/ControlledPanels.jsx
new file mode 100644
index 0000000000..6c164607f9
--- /dev/null
+++ b/web/src/components/core/ControlledPanels.jsx
@@ -0,0 +1,108 @@
+/*
+ * Copyright (c) [2024] SUSE LLC
+ *
+ * All Rights Reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of version 2 of the GNU General Public License as published
+ * by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, contact SUSE LLC.
+ *
+ * To contact SUSE LLC about this file by physical or electronic mail, you may
+ * find current contact information at www.suse.com.
+ */
+
+// @ts-check
+
+import React from "react";
+
+/**
+ * Wrapper component for holding ControlledPanel options
+ *
+ * Useful for rendering the ControlledPanel options horizontally.
+ *
+ * @see ControlledPanel examples.
+ *
+ * @param {React.PropsWithChildren} props
+ */
+const Options = ({ children, ...props }) => {
+  return (
+    <div className="split" {...props}>
+      { children }
+    </div>
+  );
+};
+
+/**
+ * Renders an option intended to control the visibility of panels referenced by
+ * the controls prop.
+ *
+ * @typedef {object} OptionProps
+ * @property {string} id - The option id.
+ * @property {React.AriaAttributes["aria-controls"]} controls - A space-separated of one or more ID values
+ *   referencing the elements whose contents or presence are controlled by the option.
+ * @property {boolean} isSelected - Whether the option is selected or not.
+ * @typedef {Omit<React.ComponentPropsWithoutRef<"input">, "aria-controls">} InputProps
+ *
+ * @param {React.PropsWithChildren<InputProps & OptionProps>} props
+ */
+const Option = ({ id, controls, isSelected, children, ...props }) => {
+  return (
+    <div data-type="agama/option">
+      <label htmlFor={id}>
+        <input id={id} checked={isSelected} type="radio" aria-controls={controls} {...props} />
+        {children}
+      </label>
+    </div>
+  );
+};
+
+/**
+ * Renders content whose visibility will be controlled by an option
+ *
+ * @typedef {object} PanelBaseProps
+ * @property {string} id - The option id.
+ * @property {boolean} isExpanded - The value for the aria-expanded attribute
+ *   which will determine if the panel is visible or not.
+ *
+ * @typedef {PanelBaseProps & Omit<React.HTMLAttributes<HTMLDivElement>, "id" | "aria-expanded">} PanelProps
+ *
+ * @param {PanelProps} props
+ */
+const Panel = ({ id, isExpanded = false, children, ...props }) => {
+  return (
+    <div {...props} id={id} aria-expanded={isExpanded}>
+      { children }
+    </div>
+  );
+};
+
+/**
+ * TODO: Write the documentation and examples.
+ * TODO: Find a better name.
+ * TODO: Improve it.
+ * NOTE: Please, be aware that despite the name, this has no relation with so
+ * called React controlled components https://react.dev/learn/sharing-state-between-components#controlled-and-uncontrolled-components
+ * This is just a convenient, dummy component for simplifying the use of this
+ * options/tabs pattern across Agama UI.
+ */
+const ControlledPanels = ({ children, ...props }) => {
+  return (
+    <div {...props} data-type="agama/controlled-panels">
+      { children }
+    </div>
+  );
+};
+
+ControlledPanels.Options = Options;
+ControlledPanels.Option = Option;
+ControlledPanels.Panel = Panel;
+
+export default ControlledPanels;
diff --git a/web/src/components/core/ExpandableSelector.jsx b/web/src/components/core/ExpandableSelector.jsx
new file mode 100644
index 0000000000..7499f37f1d
--- /dev/null
+++ b/web/src/components/core/ExpandableSelector.jsx
@@ -0,0 +1,240 @@
+/*
+ * Copyright (c) [2024] SUSE LLC
+ *
+ * All Rights Reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of version 2 of the GNU General Public License as published
+ * by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, contact SUSE LLC.
+ *
+ * To contact SUSE LLC about this file by physical or electronic mail, you may
+ * find current contact information at www.suse.com.
+ */
+
+// @ts-check
+
+import React, { useState } from "react";
+import { Table, Thead, Tr, Th, Tbody, Td, ExpandableRowContent, RowSelectVariant } from "@patternfly/react-table";
+
+/**
+ * An object for sharing data across nested maps
+ *
+ * Since function arguments are always passed by value, an object passed by
+ * sharing is needed for sharing data that might be mutated from different
+ * places, as it is the case of the rowIndex prop here.
+ *
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Functions#passing_arguments
+ *
+ * @typedef {object} SharedData
+ * @property {number} rowIndex - The current row index, to be incremented each time a table row is generated.
+ */
+
+/**
+ * @typedef {object} ExpandableSelectorColumn
+ * @property {string} name - The column header text.
+ * @property {(object) => React.ReactNode} value - A function receiving
+ *   the item to work with and returning the column value.
+ * @property {string} [classNames] - space-separated list of additional CSS class names.
+ */
+
+/**
+ * Internal component for building the table header
+ *
+ * @param {object} props
+ * @param {ExpandableSelectorColumn[]} props.columns
+ */
+const TableHeader = ({ columns }) => (
+  <Thead>
+    <Tr>
+      <Th />
+      <Th />
+      { columns?.map((c, i) => <Th key={i} className={c.classNames}>{c.name}</Th>) }
+    </Tr>
+  </Thead>
+);
+
+/**
+ * Helper function for ensuring a good value for ExpandableSelector#itemsSelected prop
+ *
+ * It logs information to console.error if given value does not match
+ * expectations.
+ *
+ * @param {*} selection - The value to check.
+ * @param {boolean} allowMultiple - Whether the returned collection can have
+ *   more than one item
+ * @return {Array} Empty array if given value is not valid. The first element if
+ *   it is a collection with more than one but selector does not allow multiple.
+ *   The original value otherwise.
+ */
+const sanitizeSelection = (selection, allowMultiple) => {
+  if (!Array.isArray(selection)) {
+    console.error("`itemSelected` prop must be an array. Ignoring given value", selection);
+    return [];
+  }
+
+  if (!allowMultiple && selection.length > 1) {
+    console.error(
+      "`itemsSelected` prop can only have more than one item when selector `isMultiple`. " +
+        "Using only the first element"
+    );
+
+    return [selection[0]];
+  }
+
+  return selection;
+};
+
+/**
+ * Build a expandable table with selectable items
+ * @component
+ *
+ * @note It only accepts one nesting level.
+ *
+ * @param {object} props
+ * @param {ExpandableSelectorColumn[]} props.columns - Collection of objects defining columns.
+ * @param {boolean} [props.isMultiple=false] - Whether multiple selection is allowed.
+ * @param {object[]} props.items - Collection of items to be rendered.
+ * @param {string} [props.itemIdKey="id"] - The key for retrieving the item id.
+ * @param {(item: object) => Array<object>} [props.itemChildren=() => []] - Lookup method to retrieve children from given item.
+ * @param {(item: object) => boolean} [props.itemSelectable=() => true] - Whether an item will be selectable or not.
+ * @param {(item: object) => (string|undefined)} [props.itemClassNames=() => ""] - Callback that allows adding additional CSS class names to item row.
+ * @param {object[]} [props.itemsSelected=[]] - Collection of selected items.
+ * @param {string[]} [props.initialExpandedKeys=[]] - Ids of initially expanded items.
+ * @param {(selection: Array<object>) => void} [props.onSelectionChange=noop] - Callback to be triggered when selection changes.
+ * @param {object} [props.tableProps] - Props for {@link https://www.patternfly.org/components/table/#table PF/Table}.
+ */
+export default function ExpandableSelector({
+  columns = [],
+  isMultiple = false,
+  items = [],
+  itemIdKey = "id",
+  itemChildren = () => [],
+  itemSelectable = () => true,
+  itemClassNames = () => "",
+  itemsSelected = [],
+  initialExpandedKeys = [],
+  onSelectionChange,
+  ...tableProps
+}) {
+  const [expandedItemsKeys, setExpandedItemsKeys] = useState(initialExpandedKeys);
+  const selection = sanitizeSelection(itemsSelected, isMultiple);
+  const isItemSelected = (item) => selection.includes(item);
+  const isItemExpanded = (key) => expandedItemsKeys.includes(key);
+  const toggleExpanded = (key) => {
+    if (isItemExpanded(key)) {
+      setExpandedItemsKeys(expandedItemsKeys.filter(k => k !== key));
+    } else {
+      setExpandedItemsKeys([...expandedItemsKeys, key]);
+    }
+  };
+
+  const updateSelection = (item) => {
+    if (!isMultiple) {
+      onSelectionChange([item]);
+      return;
+    }
+
+    if (isItemSelected(item)) {
+      onSelectionChange(selection.filter(i => i !== item));
+    } else {
+      onSelectionChange([...selection, item]);
+    }
+  };
+
+  /**
+   * Render method for building the markup for an item child
+   *
+   * @param {object} item - The child to be rendered
+   * @param {boolean} isExpanded - Whether the child should be shown or not
+   * @param {SharedData} sharedData - An object holding shared data
+   */
+  const renderItemChild = (item, isExpanded, sharedData) => {
+    const rowIndex = sharedData.rowIndex++;
+
+    const selectProps = {
+      rowIndex,
+      onSelect: () => updateSelection(item),
+      isSelected: isItemSelected(item),
+      variant: isMultiple ? RowSelectVariant.checkbox : RowSelectVariant.radio
+    };
+
+    return (
+      <Tr key={rowIndex} isExpanded={isExpanded} className={itemClassNames(item)}>
+        <Td />
+        <Td select={itemSelectable(item) ? selectProps : undefined} />
+        { columns?.map((column, index) => (
+          <Td key={index} dataLabel={column.name} className={column.classNames}>
+            <ExpandableRowContent>{column.value(item)}</ExpandableRowContent>
+          </Td>
+        ))}
+      </Tr>
+    );
+  };
+
+  /**
+   * Render method for building the markup for item
+   *
+   * @param {object} item - The item to be rendered
+   * @param {SharedData} sharedData - An object holding shared data
+   */
+  const renderItem = (item, sharedData) => {
+    const itemKey = item[itemIdKey];
+    const rowIndex = sharedData.rowIndex++;
+    const children = itemChildren(item);
+    const validChildren = Array.isArray(children) && children.length > 0;
+    const expandProps = validChildren && {
+      rowIndex,
+      isExpanded: isItemExpanded(itemKey),
+      onToggle: () => toggleExpanded(itemKey),
+    };
+
+    const selectProps = {
+      rowIndex,
+      onSelect: () => updateSelection(item),
+      isSelected: isItemSelected(item),
+      variant: isMultiple ? RowSelectVariant.checkbox : RowSelectVariant.radio
+    };
+
+    const renderChildren = () => {
+      if (!validChildren) return;
+
+      return children.map(item => renderItemChild(item, isItemExpanded(itemKey), sharedData));
+    };
+
+    // TODO: Add label to Tbody?
+    return (
+      <Tbody key={rowIndex} isExpanded={isItemExpanded(itemKey)}>
+        <Tr className={itemClassNames(item)}>
+          <Td expand={expandProps} />
+          <Td select={itemSelectable(item) ? selectProps : undefined} />
+          { columns?.map((column, index) => (
+            <Td key={index} dataLabel={column.name} className={column.classNames}>
+              {column.value(item)}
+            </Td>
+          ))}
+        </Tr>
+        { renderChildren() }
+      </Tbody>
+    );
+  };
+
+  // @see SharedData
+  const sharedData = { rowIndex: 0 };
+
+  const TableBody = () => items?.map(item => renderItem(item, sharedData));
+
+  return (
+    <Table data-type="agama/expandable-selector" {...tableProps}>
+      <TableHeader columns={columns} />
+      <TableBody />
+    </Table>
+  );
+}
diff --git a/web/src/components/core/ExpandableSelector.test.jsx b/web/src/components/core/ExpandableSelector.test.jsx
new file mode 100644
index 0000000000..bcfaf8887a
--- /dev/null
+++ b/web/src/components/core/ExpandableSelector.test.jsx
@@ -0,0 +1,449 @@
+/*
+ * Copyright (c) [2024] SUSE LLC
+ *
+ * All Rights Reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of version 2 of the GNU General Public License as published
+ * by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, contact SUSE LLC.
+ *
+ * To contact SUSE LLC about this file by physical or electronic mail, you may
+ * find current contact information at www.suse.com.
+ */
+
+import React from "react";
+import { screen, within } from "@testing-library/react";
+import { plainRender } from "~/test-utils";
+import { ExpandableSelector } from "~/components/core";
+
+const sda = {
+  sid: "59",
+  isDrive: true,
+  type: "disk",
+  vendor: "Micron",
+  model: "Micron 1100 SATA",
+  driver: ["ahci", "mmcblk"],
+  bus: "IDE",
+  busId: "",
+  transport: "usb",
+  dellBOSS: false,
+  sdCard: true,
+  active: true,
+  name: "/dev/sda",
+  size: 1024,
+  recoverableSize: 0,
+  systems : [],
+  udevIds: ["ata-Micron_1100_SATA_512GB_12563", "scsi-0ATA_Micron_1100_SATA_512GB"],
+  udevPaths: ["pci-0000:00-12", "pci-0000:00-12-ata"],
+};
+
+const sda1 = {
+  sid: "60",
+  isDrive: false,
+  type: "",
+  active: true,
+  name: "/dev/sda1",
+  size: 512,
+  recoverableSize: 128,
+  systems : [],
+  udevIds: [],
+  udevPaths: []
+};
+
+const sda2 = {
+  sid: "61",
+  isDrive: false,
+  type: "",
+  active: true,
+  name: "/dev/sda2",
+  size: 512,
+  recoverableSize: 0,
+  systems : [],
+  udevIds: [],
+  udevPaths: []
+};
+
+sda.partitionTable = {
+  type: "gpt",
+  partitions: [sda1, sda2],
+  unpartitionedSize: 512
+};
+
+const sdb = {
+  sid: "62",
+  isDrive: true,
+  type: "disk",
+  vendor: "Samsung",
+  model: "Samsung Evo 8 Pro",
+  driver: ["ahci"],
+  bus: "IDE",
+  busId: "",
+  transport: "",
+  dellBOSS: false,
+  sdCard: false,
+  active: true,
+  name: "/dev/sdb",
+  size: 2048,
+  recoverableSize: 0,
+  systems : [],
+  udevIds: [],
+  udevPaths: ["pci-0000:00-19"]
+};
+
+const lv1 = {
+  sid: "163",
+  name: "/dev/system/vg/lv1",
+  content: "Personal Data"
+};
+
+const vg = {
+  sid: "162",
+  type: "vg",
+  name: "/dev/system/vg",
+  lvs: [
+    lv1
+  ]
+};
+
+const columns = [
+  { name: "Device", value: (item) => item.name },
+  {
+    name: "Content",
+    value: (item) => {
+      if (item.isDrive) return item.systems.map((s, i) => <p key={i}>{s}</p>);
+      if (item.type === "vg") return `${item.lvs.length} logical volume(s)`;
+
+      return item.content;
+    }
+  },
+  { name: "Size", value: (item) => item.size },
+];
+
+const onChangeFn = jest.fn();
+
+let props;
+const commonProps = {
+  columns,
+  items: [sda, sdb, vg],
+  itemIdKey: "sid",
+  initialExpandedKeys: [sda.sid, vg.sid],
+  itemChildren: (item) => (
+    item.isDrive ? item.partitionTable?.partitions : item.lvs
+  ),
+  onSelectionChange: onChangeFn,
+  "aria-label": "Device selector"
+};
+
+describe("ExpandableSelector", () => {
+  beforeAll(() => {
+    jest.spyOn(console, "error").mockImplementation();
+  });
+
+  afterAll(() => {
+    console.error.mockRestore();
+  });
+
+  beforeEach(() => {
+    props = { ...commonProps };
+  });
+
+  it("renders a table with given name", () => {
+    plainRender(<ExpandableSelector {...props} />);
+    screen.getByRole("grid", { name: "Device selector" });
+  });
+
+  it("renders the table headers", () => {
+    plainRender(<ExpandableSelector {...props} />);
+    const table = screen.getByRole("grid");
+    within(table).getByRole("columnheader", { name: "Device" });
+    within(table).getByRole("columnheader", { name: "Content" });
+    within(table).getByRole("columnheader", { name: "Size" });
+  });
+
+  it("renders a rowgroup per parent item", () => {
+    plainRender(<ExpandableSelector {...props} />);
+    const groups = screen.getAllByRole("rowgroup");
+    // NOTE: since <thead> has also the rowgroup role, we expect to found 4 in
+    // this example: 1 thead + 3 tbody (sda, sdb, vg)
+    expect(groups.length).toEqual(4);
+  });
+
+  it("renders a row per given item and found children", () => {
+    plainRender(<ExpandableSelector {...props} />);
+    const table = screen.getByRole("grid");
+    within(table).getByRole("row", { name: /dev\/sda 1024/ });
+    within(table).getByRole("row", { name: /dev\/sdb 2048/ });
+    within(table).getByRole("row", { name: /dev\/system\/vg 1 logical/ });
+    within(table).getByRole("row", { name: /dev\/sda1 512/ });
+    within(table).getByRole("row", { name: /dev\/sda2 512/ });
+    within(table).getByRole("row", { name: /Personal Data/ });
+  });
+
+  it("renders a expand toggler in items with children", () => {
+    plainRender(<ExpandableSelector {...props} />);
+    const table = screen.getByRole("grid");
+    const sdaRow = within(table).getByRole("row", { name: /dev\/sda 1024/ });
+    const sdbRow = within(table).getByRole("row", { name: /dev\/sdb 2048/ });
+    const lvRow = within(table).getByRole("row", { name: /dev\/system\/vg 1 logical/ });
+
+    within(sdaRow).getByRole("button", { name: "Details" });
+    within(lvRow).getByRole("button", { name: "Details" });
+    // `/dev/sdb` does not have children, toggler must not be there
+    const sdbChildrenToggler = within(sdbRow).queryByRole("button", { name: "Details" });
+    expect(sdbChildrenToggler).toBeNull();
+  });
+
+  it("renders as expanded items which value for `itemIdKey` is included in `initialExpandedKeys` prop", () => {
+    plainRender(
+      <ExpandableSelector {...props} itemIdKey="name" initialExpandedKeys={["/dev/sda"]} />
+    );
+    const table = screen.getByRole("grid");
+    within(table).getByRole("row", { name: /dev\/sda1 512/ });
+    within(table).getByRole("row", { name: /dev\/sda2 512/ });
+  });
+
+  it("keeps track of expanded items", async () => {
+    const { user } = plainRender(
+      <ExpandableSelector {...props} itemIdKey="name" initialExpandedKeys={["/dev/sda"]} />
+    );
+    const table = screen.getByRole("grid");
+    const sdaRow = within(table).getByRole("row", { name: /sda 1024/ });
+    const sdaToggler = within(sdaRow).getByRole("button", { name: "Details" });
+    const vgRow = within(table).getByRole("row", { name: /vg 1 logical/ });
+    const vgToggler = within(vgRow).getByRole("button", { name: "Details" });
+
+    within(table).getByRole("row", { name: /dev\/sda1 512/ });
+    within(table).getByRole("row", { name: /dev\/sda2 512/ });
+
+    await user.click(vgToggler);
+
+    within(table).getByRole("row", { name: /Personal Data/ });
+
+    await user.click(sdaToggler);
+    const sdaPartitionsRows = within(table).queryAllByRole("row", { name: /sda[d] 512/ });
+    expect(sdaPartitionsRows.length).toEqual(0);
+  });
+
+  it("uses 'id' as key when `itemIdKey` prop is not given", () => {
+    plainRender(
+      <ExpandableSelector {...props} itemIdKey={undefined} />
+    );
+
+    const table = screen.getByRole("grid");
+    // Since itemIdKey does not match the id used for the item, they are
+    // collapsed by default and their children are not visible
+    const sdaChild = within(table).queryByRole("row", { name: /dev\/sda1 512/ });
+    expect(sdaChild).toBeNull();
+  });
+
+  it("uses given `itemIdKey` as key", () => {
+    plainRender(
+      <ExpandableSelector {...props} itemIdKey="name" initialExpandedKeys={["/dev/sda"]} />
+    );
+
+    const table = screen.getByRole("grid");
+    // Since itemIdKey === "name", "/dev/sda" is properly mounted as expanded. Its
+    // children must be visible
+    const sdaChild = within(table).queryByRole("row", { name: /dev\/sda1 512/ });
+    expect(sdaChild).not.toBeNull();
+  });
+
+  describe("when `itemsSelected` is given", () => {
+    it("renders nothing as checked if value is an empty array", () => {
+      plainRender(<ExpandableSelector {...props} itemsSelected={[]} />);
+      const table = screen.getByRole("grid");
+      const selection = within(table).queryAllByRole("radio", { checked: true });
+      expect(selection.length).toEqual(0);
+    });
+
+    describe("but it isn't an array", () => {
+      it("outputs to console.error", () => {
+        plainRender(<ExpandableSelector {...props} itemsSelected="Whatever" />);
+        expect(console.error).toHaveBeenCalledWith(
+          expect.stringContaining("prop must be an array"),
+          "Whatever"
+        );
+      });
+
+      it("renders nothing as selected", () => {
+        plainRender(<ExpandableSelector {...props} itemsSelected="Whatever" />);
+        const table = screen.getByRole("grid");
+        const selection = within(table).queryAllByRole("radio", { checked: true });
+        expect(selection.length).toEqual(0);
+      });
+    });
+  });
+
+  describe("when mounted as single selector", () => {
+    describe.each([undefined, null, false])("because isMultiple={%s}", (isMultiple) => {
+      beforeEach(() => {
+        props = { ...props, isMultiple };
+      });
+
+      it("renders a radio per item row", () => {
+        plainRender(<ExpandableSelector {...props} />);
+        const table = screen.getByRole("grid");
+        const radios = within(table).getAllByRole("radio");
+        expect(radios.length).toEqual(6);
+      });
+
+      describe("but `itemSelectable` is given", () => {
+        it("renders a radio only for items for which it returns true", () => {
+          const itemSelectable = (item) => item.isDrive || item.type === "vg";
+          plainRender(<ExpandableSelector {...props} itemSelectable={itemSelectable} />);
+          const table = screen.getByRole("grid");
+          const radios = within(table).getAllByRole("radio");
+
+          // Expected only three radios
+          expect(radios.length).toEqual(3);
+
+          // Not in below items
+          const sda1Row = within(table).getByRole("row", { name: /dev\/sda1/ });
+          const sda2Row = within(table).getByRole("row", { name: /dev\/sda2/ });
+          const lv1Row = within(table).getByRole("row", { name: /lv1/ });
+          expect(within(sda1Row).queryAllByRole("radio")).toEqual([]);
+          expect(within(sda2Row).queryAllByRole("radio")).toEqual([]);
+          expect(within(lv1Row).queryAllByRole("radio")).toEqual([]);
+        });
+      });
+
+      describe("and `itemsSelected` is given", () => {
+        describe("and it is an array with just one item", () => {
+          it("renders it as checked", async () => {
+            plainRender(<ExpandableSelector {...props} itemsSelected={[sda1]} />);
+            const table = screen.getByRole("grid");
+            const sda1Row = within(table).getByRole("row", { name: /dev\/sda1/ });
+            const selection = screen.getAllByRole("radio", { checked: true });
+            expect(selection.length).toEqual(1);
+            within(sda1Row).getByRole("radio", { checked: true });
+          });
+        });
+
+        describe("but it is an array with more than one item", () => {
+          it("outputs to console.error", () => {
+            plainRender(<ExpandableSelector {...props} itemsSelected={[sda1, lv1]} />);
+            expect(console.error).toHaveBeenCalledWith(
+              expect.stringContaining("Using only the first element")
+            );
+          });
+
+          it("renders the first one as checked", async () => {
+            plainRender(<ExpandableSelector {...props} itemsSelected={[sda1, lv1]} />);
+            const table = screen.getByRole("grid");
+            const selection = screen.getAllByRole("radio", { checked: true });
+            const sda1Row = within(table).getByRole("row", { name: /dev\/sda1/ });
+            const lv1Row = within(table).getByRole("row", { name: /Personal Data/ });
+            const lv1Radio = within(lv1Row).getByRole("radio");
+            within(sda1Row).getByRole("radio", { checked: true });
+            expect(lv1Radio).not.toHaveAttribute("checked", true);
+            expect(selection.length).toEqual(1);
+          });
+        });
+      });
+
+      describe("and user selects an already selected item", () => {
+        it("does not trigger the `onSelectionChange` callback", async () => {
+          const { user } = plainRender(<ExpandableSelector {...props} itemsSelected={[sda1]} />);
+          const sda1row = screen.getByRole("row", { name: /dev\/sda1/ });
+          const sda1radio = within(sda1row).getByRole("radio");
+          await user.click(sda1radio);
+          expect(onChangeFn).not.toHaveBeenCalled();
+        });
+      });
+
+      describe("and user selects a not selected item", () => {
+        it("calls the `onSelectionChange` callback with a collection holding only selected item", async () => {
+          const { user } = plainRender(<ExpandableSelector {...props} itemsSelected={[sda1]} />);
+          const sda2row = screen.getByRole("row", { name: /dev\/sda2/ });
+          const sda2radio = within(sda2row).getByRole("radio");
+          await user.click(sda2radio);
+          expect(onChangeFn).toHaveBeenCalledWith([sda2]);
+        });
+      });
+    });
+  });
+
+  describe("when mounted as multiple selector", () => {
+    beforeEach(() => {
+      props = { ...props, isMultiple: true };
+    });
+
+    it("renders a checkbox per item row", () => {
+      plainRender(<ExpandableSelector {...props} />);
+      const table = screen.getByRole("grid");
+      const checkboxes = within(table).getAllByRole("checkbox");
+      expect(checkboxes.length).toEqual(6);
+    });
+
+    describe("but `itemSelectable` is given", () => {
+      it("renders a checkbox only for items for which it returns true", () => {
+        const itemSelectable = (item) => item.isDrive || item.type === "vg";
+        plainRender(<ExpandableSelector {...props} itemSelectable={itemSelectable} />);
+        const table = screen.getByRole("grid");
+        const checkboxes = within(table).getAllByRole("checkbox");
+
+        // Expected only three checkboxes
+        expect(checkboxes.length).toEqual(3);
+
+        // Not in below items
+        const sda1Row = within(table).getByRole("row", { name: /dev\/sda1/ });
+        const sda2Row = within(table).getByRole("row", { name: /dev\/sda2/ });
+        const lv1Row = within(table).getByRole("row", { name: /lv1/ });
+        expect(within(sda1Row).queryAllByRole("checkbox")).toEqual([]);
+        expect(within(sda2Row).queryAllByRole("checkbox")).toEqual([]);
+        expect(within(lv1Row).queryAllByRole("checkbox")).toEqual([]);
+      });
+    });
+
+    describe("and `itemsSelected` is given", () => {
+      it("renders given items as checked", async () => {
+        plainRender(<ExpandableSelector {...props} itemsSelected={[sda1, lv1]} />);
+        const table = screen.getByRole("grid");
+        const selection = screen.getAllByRole("checkbox", { checked: true });
+        const sda1Row = within(table).getByRole("row", { name: /dev\/sda1/ });
+        const lv1Row = within(table).getByRole("row", { name: /Personal Data/ });
+        within(sda1Row).getByRole("checkbox", { checked: true });
+        within(lv1Row).getByRole("checkbox", { checked: true });
+        expect(selection.length).toEqual(2);
+      });
+    });
+
+    it("renders initially selected items given via `itemsSelected` prop", async () => {
+      plainRender(<ExpandableSelector {...props} isMultiple itemsSelected={[sda1, lv1]} />);
+      const table = screen.getByRole("grid");
+      const sda1Row = within(table).getByRole("row", { name: /dev\/sda1/ });
+      const lv1Row = within(table).getByRole("row", { name: /Personal Data/ });
+      const selection = screen.getAllByRole("checkbox", { checked: true });
+      expect(selection.length).toEqual(2);
+      [sda1Row, lv1Row].forEach(row => within(row).getByRole("checkbox", { checked: true }));
+    });
+
+    describe("and user selects an already selected item", () => {
+      it("triggers the `onSelectionChange` callback with a collection not including the item", async () => {
+        const { user } = plainRender(<ExpandableSelector {...props} itemsSelected={[sda1, sda2]} />);
+        const sda1row = screen.getByRole("row", { name: /dev\/sda1/ });
+        const sda1radio = within(sda1row).getByRole("checkbox");
+        await user.click(sda1radio);
+        expect(onChangeFn).toHaveBeenCalledWith([sda2]);
+      });
+    });
+
+    describe("and user selects a not selected item", () => {
+      it("calls the `onSelectionChange` callback with a collection including the item", async () => {
+        const { user } = plainRender(<ExpandableSelector {...props} itemsSelected={[sda1]} />);
+        const sda2row = screen.getByRole("row", { name: /dev\/sda2/ });
+        const sda2checkbox = within(sda2row).getByRole("checkbox");
+        await user.click(sda2checkbox);
+        expect(onChangeFn).toHaveBeenCalledWith([sda1, sda2]);
+      });
+    });
+  });
+});
diff --git a/web/src/components/core/index.js b/web/src/components/core/index.js
index f6448c03d3..7e0a4837ff 100644
--- a/web/src/components/core/index.js
+++ b/web/src/components/core/index.js
@@ -56,7 +56,9 @@ export { default as NumericTextInput } from "./NumericTextInput";
 export { default as PasswordInput } from "./PasswordInput";
 export { default as DevelopmentInfo } from "./DevelopmentInfo";
 export { default as Selector } from "./Selector";
+export { default as ExpandableSelector } from "./ExpandableSelector";
 export { default as OptionsPicker } from "./OptionsPicker";
 export { default as Reminder } from "./Reminder";
 export { default as Tag } from "./Tag";
 export { default as TreeTable } from "./TreeTable";
+export { default as ControlledPanels } from "./ControlledPanels";
diff --git a/web/src/components/overview/StorageSection.jsx b/web/src/components/overview/StorageSection.jsx
index 1246183b4e..733b2cbe6c 100644
--- a/web/src/components/overview/StorageSection.jsx
+++ b/web/src/components/overview/StorageSection.jsx
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) [2022-2023] SUSE LLC
+ * Copyright (c) [2022-2024] SUSE LLC
  *
  * All Rights Reserved.
  *
@@ -27,7 +27,8 @@ import { useInstallerClient } from "~/context/installer";
 import { BUSY } from "~/client/status";
 import { deviceLabel } from "~/components/storage/utils";
 import { Em, ProgressText, Section } from "~/components/core";
-import { _ } from "~/i18n";
+import { sprintf } from "sprintf-js";
+import { _, n_ } from "~/i18n";
 
 /**
  * Text explaining the storage proposal
@@ -38,11 +39,72 @@ import { _ } from "~/i18n";
 const ProposalSummary = ({ proposal }) => {
   const { availableDevices = [], result = {} } = proposal;
 
-  const bootDevice = result.settings?.bootDevice;
-  if (!bootDevice) return <Text>{_("No device selected yet")}</Text>;
+  const label = (deviceName) => {
+    const device = availableDevices.find(d => d.name === deviceName);
+    return device ? deviceLabel(device) : deviceName;
+  };
+
+  if (result.settings?.target === "newLvmVg") {
+    // TRANSLATORS: Part of the message describing where the system will be installed.
+    // Do not translate 'abbr' and 'title', they are part of the HTML markup.
+    const vg = _("<abbr title='Logical Volume Manager'>LVM</abbr> volume group");
+    const pvDevices = result.settings?.targetPVDevices;
+    const fullMsg = (policy, num_pvs) => {
+      switch (policy) {
+        case "resize":
+          // TRANSLATORS: %1$s will be replaced by "LVM volume group" (already translated and with some markup)
+          // %2$s (if present) will be replaced by a device name and its size (eg. "/dev/sda, 20 GiB")
+          return n_(
+            "Install in a new %1$s on %2$s shrinking existing partitions as needed",
+            "Install in a new %1$s shrinking existing partitions at the underlying devices as needed",
+            num_pvs
+          );
+        case "keep":
+          // TRANSLATORS: %1$s will be replaced by "LVM volume group" (already translated and with some markup)
+          // %2$s (if present) will be replaced by a device name and its size (eg. "/dev/sda, 20 GiB")
+          return n_(
+            "Install in a new %1$s on %2$s without modifying existing partitions",
+            "Install in a new %1$s without modifying the partitions at the underlying devices",
+            num_pvs
+          );
+        case "delete":
+          // TRANSLATORS: %1$s will be replaced by "LVM volume group" (already translated and with some markup)
+          // %2$s (if present) will be replaced by a device name and its size (eg. "/dev/sda, 20 GiB")
+          return n_(
+            "Install in a new %1$s on %2$s deleting all its content",
+            "Install in a new %1$s deleting all the content of the underlying devices",
+            num_pvs
+          );
+        case "custom":
+          // TRANSLATORS: %1$s will be replaced by "LVM volume group" (already translated and with some markup)
+          // %2$s (if present) will be replaced by a device name and its size (eg. "/dev/sda, 20 GiB")
+          return n_(
+            "Install in a new %1$s on %2$s using a custom strategy to find the needed space",
+            "Install in a new %1$s using a custom strategy to find the needed space at the underlying devices",
+            num_pvs
+          );
+      }
+    };
+
+    const msg = sprintf(fullMsg(result.settings?.spacePolicy, pvDevices.length), vg, "%dev%");
+
+    if (pvDevices.length > 1) {
+      return (<span dangerouslySetInnerHTML={{ __html: msg }} />);
+    } else {
+      const [msg1, msg2] = msg.split("%dev%");
+
+      return (
+        <Text>
+          <span dangerouslySetInnerHTML={{ __html: msg1 }} />
+          <Em>{ label(pvDevices[0]) }</Em>
+          <span dangerouslySetInnerHTML={{ __html: msg2 }} />
+        </Text>
+      );
+    }
+  }
 
-  const device = availableDevices.find(d => d.name === bootDevice);
-  const label = device ? deviceLabel(device) : bootDevice;
+  const targetDevice = result.settings?.targetDevice;
+  if (!targetDevice) return <Text>{_("No device selected yet")}</Text>;
 
   const fullMsg = (policy) => {
     switch (policy) {
@@ -60,17 +122,16 @@ const ProposalSummary = ({ proposal }) => {
         return _("Install using device %s and deleting all its content");
     }
 
-    console.log(`Unknown space policy: ${policy}`);
     // TRANSLATORS: %s will be replaced by the device name and its size,
     // example: "/dev/sda, 20 GiB"
-    return _("Install using device %s");
+    return _("Install using device %s with a custom strategy to find the needed space");
   };
 
   const [msg1, msg2] = fullMsg(result.settings?.spacePolicy).split("%s");
 
   return (
     <Text>
-      {msg1}<Em>{label}</Em>{msg2}
+      {msg1}<Em>{label(targetDevice)}</Em>{msg2}
     </Text>
   );
 };
diff --git a/web/src/components/overview/StorageSection.test.jsx b/web/src/components/overview/StorageSection.test.jsx
index ba08280298..251f751d93 100644
--- a/web/src/components/overview/StorageSection.test.jsx
+++ b/web/src/components/overview/StorageSection.test.jsx
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) [2022-2023] SUSE LLC
+ * Copyright (c) [2022-2024] SUSE LLC
  *
  * All Rights Reserved.
  *
@@ -39,8 +39,8 @@ const encryptionMethods = ["luks2", "tpm_fde"];
 
 const proposalResult = {
   settings: {
-    bootDevice: "/dev/sda",
-    lvm: false,
+    target: "disk",
+    targetDevice: "/dev/sda",
     spacePolicy: "delete"
   },
   actions: []
@@ -95,7 +95,7 @@ describe("when there is a proposal", () => {
 
   describe("and the space policy is set to 'resize'", () => {
     beforeEach(() => {
-      const result = { settings: { spacePolicy: "resize", bootDevice: "/dev/sda" } };
+      const result = { settings: { spacePolicy: "resize", targetDevice: "/dev/sda" } };
       storage.proposal.getResult = jest.fn().mockResolvedValue(result);
     });
 
@@ -108,7 +108,7 @@ describe("when there is a proposal", () => {
 
   describe("and the space policy is set to 'keep'", () => {
     beforeEach(() => {
-      const result = { settings: { spacePolicy: "keep", bootDevice: "/dev/sda" } };
+      const result = { settings: { spacePolicy: "keep", targetDevice: "/dev/sda" } };
       storage.proposal.getResult = jest.fn().mockResolvedValue(result);
     });
 
@@ -119,9 +119,9 @@ describe("when there is a proposal", () => {
     });
   });
 
-  describe("and there is no boot device", () => {
+  describe("and there is no target device", () => {
     beforeEach(() => {
-      const result = { settings: { bootDevice: "" } };
+      const result = { settings: { targetDevice: "" } };
       storage.proposal.getResult = jest.fn().mockResolvedValue(result);
     });
 
diff --git a/web/src/components/storage/BootSelectionDialog.jsx b/web/src/components/storage/BootSelectionDialog.jsx
new file mode 100644
index 0000000000..e33b03998f
--- /dev/null
+++ b/web/src/components/storage/BootSelectionDialog.jsx
@@ -0,0 +1,187 @@
+/*
+ * Copyright (c) [2024] SUSE LLC
+ *
+ * All Rights Reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of version 2 of the GNU General Public License as published
+ * by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, contact SUSE LLC.
+ *
+ * To contact SUSE LLC about this file by physical or electronic mail, you may
+ * find current contact information at www.suse.com.
+ */
+
+import React, { useState } from "react";
+import { Form } from "@patternfly/react-core";
+import { _ } from "~/i18n";
+import { DevicesFormSelect } from "~/components/storage";
+import { noop } from "~/utils";
+import { Popup } from "~/components/core";
+import { deviceLabel } from "~/components/storage/utils";
+import { sprintf } from "sprintf-js";
+
+/**
+ * @typedef {import ("~/client/storage").StorageDevice} StorageDevice
+ */
+
+const BOOT_AUTO_ID = "boot-auto";
+const BOOT_MANUAL_ID = "boot-manual";
+const BOOT_DISABLED_ID = "boot-disabled";
+const OPTIONS_NAME = "boot-mode";
+
+/**
+ * Internal component for building the options
+ * @component
+ *
+ * @param {React.PropsWithChildren<React.ComponentProps<"input">>} props
+ */
+const RadioOption = ({ id, onChange, defaultChecked, children }) => {
+  return (
+    <>
+      <input id={id} name={OPTIONS_NAME} type="radio" defaultChecked={defaultChecked} onChange={onChange} />
+      <label htmlFor={id}>{children}</label>
+    </>
+  );
+};
+
+/**
+ * Renders a dialog that allows the user to select the boot configuration.
+ * @component
+ *
+ * @typedef {object} Boot
+ * @property {boolean} configureBoot
+ * @property {StorageDevice|undefined} bootDevice
+ *
+ * @param {object} props
+ * @param {boolean} props.configureBoot - Whether the boot is configurable
+ * @param {StorageDevice|undefined} props.bootDevice - Currently selected booting device.
+ * @param {StorageDevice|undefined} props.defaultBootDevice - Default booting device.
+ * @param {StorageDevice[]} props.devices - Devices that user can select to boot from.
+ * @param {boolean} [props.isOpen=false] - Whether the dialog is visible or not.
+ * @param {function} [props.onCancel=noop]
+ * @param {(boot: Boot) => void} [props.onAccept=noop]
+ */
+export default function BootSelectionDialog({
+  configureBoot: configureBootProp,
+  bootDevice: bootDeviceProp,
+  defaultBootDevice,
+  devices,
+  isOpen,
+  onCancel = noop,
+  onAccept = noop,
+  ...props
+}) {
+  const [configureBoot, setConfigureBoot] = useState(configureBootProp);
+  const [bootDevice, setBootDevice] = useState(bootDeviceProp || defaultBootDevice);
+  const [isBootAuto, setIsBootAuto] = useState(configureBootProp && bootDeviceProp === undefined);
+
+  const isBootManual = configureBoot && !isBootAuto;
+
+  const selectBootAuto = () => {
+    setConfigureBoot(true);
+    setIsBootAuto(true);
+  };
+
+  const selectBootManual = () => {
+    setConfigureBoot(true);
+    setIsBootAuto(false);
+  };
+
+  const selectBootDisabled = () => {
+    setConfigureBoot(false);
+    setIsBootAuto(false);
+  };
+
+  const onSubmit = (e) => {
+    e.preventDefault();
+    const device = isBootAuto ? undefined : bootDevice;
+    onAccept({ configureBoot, bootDevice: device });
+  };
+
+  const isAcceptDisabled = () => {
+    return isBootManual && bootDevice === undefined;
+  };
+
+  const description = _(
+    "To ensure the new system is able to boot, the installer may need to create or configure some \
+partitions in the appropriate disk."
+  );
+
+  const automaticText = () => {
+    if (!defaultBootDevice) {
+      return _("Partitions to boot will be allocated at the installation disk.");
+    }
+
+    return sprintf(
+      // TRANSLATORS: %s is replaced by a device name and size (e.g., "/dev/sda, 500GiB")
+      _("Partitions to boot will be allocated at the installation disk (%s)."),
+      deviceLabel(defaultBootDevice)
+    );
+  };
+
+  return (
+    <Popup
+      title={_("Partitions for booting")}
+      description={description}
+      isOpen={isOpen}
+      {...props}
+    >
+      <Form id="boot-form" onSubmit={onSubmit}>
+        <fieldset className="stack">
+          <legend className="split">
+            <RadioOption id={BOOT_AUTO_ID} defaultChecked={isBootAuto} onChange={() => selectBootAuto()}>
+              {_("Automatic")}
+            </RadioOption>
+          </legend>
+          <div>
+            {automaticText()}
+          </div>
+        </fieldset>
+
+        <fieldset className="stack">
+          <legend className="split">
+            <RadioOption id={BOOT_MANUAL_ID} defaultChecked={isBootManual} onChange={() => selectBootManual()}>
+              {_("Select a disk")}
+            </RadioOption>
+          </legend>
+
+          <div className="stack">
+            <div>
+              {_("Partitions to boot will be allocated at the following device.")}
+            </div>
+            <DevicesFormSelect
+              aria-label={_("Choose a disk for placing the boot loader")}
+              devices={devices}
+              selectedDevice={bootDevice}
+              onChange={setBootDevice}
+              isDisabled={!isBootManual}
+            />
+          </div>
+        </fieldset>
+
+        <fieldset className="stack">
+          <legend className="split">
+            <RadioOption id={BOOT_DISABLED_ID} defaultChecked={!configureBoot} onChange={() => selectBootDisabled()}>
+              {_("Do not configure")}
+            </RadioOption>
+          </legend>
+          <div>
+            {_("No partitions will be automatically configured for booting. Use with caution.")}
+          </div>
+        </fieldset>
+      </Form>
+      <Popup.Actions>
+        <Popup.Confirm form="boot-form" type="submit" isDisabled={isAcceptDisabled()} />
+        <Popup.Cancel onClick={onCancel} />
+      </Popup.Actions>
+    </Popup>
+  );
+}
diff --git a/web/src/components/storage/BootSelectionDialog.test.jsx b/web/src/components/storage/BootSelectionDialog.test.jsx
new file mode 100644
index 0000000000..7e759a1115
--- /dev/null
+++ b/web/src/components/storage/BootSelectionDialog.test.jsx
@@ -0,0 +1,243 @@
+/*
+ * Copyright (c) [2024] SUSE LLC
+ *
+ * All Rights Reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of version 2 of the GNU General Public License as published
+ * by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, contact SUSE LLC.
+ *
+ * To contact SUSE LLC about this file by physical or electronic mail, you may
+ * find current contact information at www.suse.com.
+ */
+
+import React from "react";
+import { screen, within } from "@testing-library/react";
+import { plainRender } from "~/test-utils";
+import { BootSelectionDialog } from "~/components/storage";
+
+const sda = {
+  sid: 59,
+  isDrive: true,
+  type: "disk",
+  vendor: "Micron",
+  model: "Micron 1100 SATA",
+  driver: ["ahci", "mmcblk"],
+  bus: "IDE",
+  busId: "",
+  transport: "usb",
+  dellBOSS: false,
+  sdCard: true,
+  active: true,
+  name: "/dev/sda",
+  size: 1024,
+  recoverableSize: 0,
+  systems : [],
+  udevIds: ["ata-Micron_1100_SATA_512GB_12563", "scsi-0ATA_Micron_1100_SATA_512GB"],
+  udevPaths: ["pci-0000:00-12", "pci-0000:00-12-ata"],
+};
+
+const sdb = {
+  sid: 62,
+  isDrive: true,
+  type: "disk",
+  vendor: "Samsung",
+  model: "Samsung Evo 8 Pro",
+  driver: ["ahci"],
+  bus: "IDE",
+  busId: "",
+  transport: "",
+  dellBOSS: false,
+  sdCard: false,
+  active: true,
+  name: "/dev/sdb",
+  size: 2048,
+  recoverableSize: 0,
+  systems : [],
+  udevIds: [],
+  udevPaths: ["pci-0000:00-19"]
+};
+
+const sdc = {
+  sid: 63,
+  isDrive: true,
+  type: "disk",
+  vendor: "Samsung",
+  model: "Samsung Evo 8 Pro",
+  driver: ["ahci"],
+  bus: "IDE",
+  busId: "",
+  transport: "",
+  dellBOSS: false,
+  sdCard: false,
+  active: true,
+  name: "/dev/sdc",
+  size: 2048,
+  recoverableSize: 0,
+  systems : [],
+  udevIds: [],
+  udevPaths: ["pci-0000:00-19"]
+};
+
+let props;
+
+describe("BootSelectionDialog", () => {
+  beforeEach(() => {
+    props = {
+      isOpen: true,
+      configureBoot: false,
+      devices: [sda, sdb, sdc],
+      onCancel: jest.fn(),
+      onAccept: jest.fn()
+    };
+  });
+
+  const automaticOption = () => screen.queryByRole("radio", { name: "Automatic" });
+  const selectDiskOption = () => screen.queryByRole("radio", { name: "Select a disk" });
+  const notConfigureOption = () => screen.queryByRole("radio", { name: "Do not configure" });
+  const diskSelector = () => screen.queryByRole("combobox", { name: /choose a disk/i });
+
+  it("offers an option to configure boot in the installation disk", () => {
+    plainRender(<BootSelectionDialog {...props} />);
+    expect(automaticOption()).toBeInTheDocument();
+  });
+
+  it("offers an option to configure boot in a selected disk", () => {
+    plainRender(<BootSelectionDialog {...props} />);
+    expect(selectDiskOption()).toBeInTheDocument();
+    expect(diskSelector()).toBeInTheDocument();
+  });
+
+  it("offers an option to not configure boot", () => {
+    plainRender(<BootSelectionDialog {...props} />);
+    expect(notConfigureOption()).toBeInTheDocument();
+  });
+
+  describe("if the current value is set to boot from the installation disk", () => {
+    beforeEach(() => {
+      props.configureBoot = true;
+      props.bootDevice = undefined;
+    });
+
+    it("selects 'Automatic' option by default", () => {
+      plainRender(<BootSelectionDialog {...props} />);
+      expect(automaticOption()).toBeChecked();
+      expect(selectDiskOption()).not.toBeChecked();
+      expect(diskSelector()).toBeDisabled();
+      expect(notConfigureOption()).not.toBeChecked();
+    });
+  });
+
+  describe("if the current value is set to boot from a selected disk", () => {
+    beforeEach(() => {
+      props.configureBoot = true;
+      props.bootDevice = sdb;
+    });
+
+    it("selects 'Select a disk' option by default", () => {
+      plainRender(<BootSelectionDialog {...props} />);
+      expect(automaticOption()).not.toBeChecked();
+      expect(selectDiskOption()).toBeChecked();
+      expect(diskSelector()).toBeEnabled();
+      expect(notConfigureOption()).not.toBeChecked();
+    });
+  });
+
+  describe("if the current value is set to not configure boot", () => {
+    beforeEach(() => {
+      props.configureBoot = false;
+      props.bootDevice = sdb;
+    });
+
+    it("selects 'Do not configure' option by default", () => {
+      plainRender(<BootSelectionDialog {...props} />);
+      expect(automaticOption()).not.toBeChecked();
+      expect(selectDiskOption()).not.toBeChecked();
+      expect(diskSelector()).toBeDisabled();
+      expect(notConfigureOption()).toBeChecked();
+    });
+  });
+
+  it("does not call onAccept on cancel", async () => {
+    const { user } = plainRender(<BootSelectionDialog {...props} />);
+    const cancel = screen.getByRole("button", { name: "Cancel" });
+
+    await user.click(cancel);
+
+    expect(props.onAccept).not.toHaveBeenCalled();
+  });
+
+  describe("if the 'Automatic' option is selected", () => {
+    beforeEach(() => {
+      props.configureBoot = false;
+      props.bootDevice = undefined;
+    });
+
+    it("calls onAccept with the selected options on accept", async () => {
+      const { user } = plainRender(<BootSelectionDialog {...props} />);
+
+      await user.click(automaticOption());
+
+      const accept = screen.getByRole("button", { name: "Confirm" });
+      await user.click(accept);
+
+      expect(props.onAccept).toHaveBeenCalledWith({
+        configureBoot: true,
+        bootDevice: undefined
+      });
+    });
+  });
+
+  describe("if the 'Select a disk' option is selected", () => {
+    beforeEach(() => {
+      props.configureBoot = false;
+      props.bootDevice = undefined;
+    });
+
+    it("calls onAccept with the selected options on accept", async () => {
+      const { user } = plainRender(<BootSelectionDialog {...props} />);
+
+      await user.click(selectDiskOption());
+      const selector = diskSelector();
+      const sdbOption = within(selector).getByRole("option", { name: /sdb/ });
+      await user.selectOptions(selector, sdbOption);
+
+      const accept = screen.getByRole("button", { name: "Confirm" });
+      await user.click(accept);
+
+      expect(props.onAccept).toHaveBeenCalledWith({
+        configureBoot: true,
+        bootDevice: sdb
+      });
+    });
+  });
+
+  describe("if the 'Do not configure' option is selected", () => {
+    beforeEach(() => {
+      props.configureBoot = true;
+      props.bootDevice = undefined;
+    });
+
+    it("calls onAccept with the selected options on accept", async () => {
+      const { user } = plainRender(<BootSelectionDialog {...props} />);
+
+      await user.click(notConfigureOption());
+
+      const accept = screen.getByRole("button", { name: "Confirm" });
+      await user.click(accept);
+
+      expect(props.onAccept).toHaveBeenCalledWith({
+        configureBoot: false,
+        bootDevice: undefined
+      });
+    });
+  });
+});
diff --git a/web/src/components/storage/DeviceSelectionDialog.jsx b/web/src/components/storage/DeviceSelectionDialog.jsx
new file mode 100644
index 0000000000..fd6972c0f9
--- /dev/null
+++ b/web/src/components/storage/DeviceSelectionDialog.jsx
@@ -0,0 +1,178 @@
+/*
+ * Copyright (c) [2024] SUSE LLC
+ *
+ * All Rights Reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of version 2 of the GNU General Public License as published
+ * by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, contact SUSE LLC.
+ *
+ * To contact SUSE LLC about this file by physical or electronic mail, you may
+ * find current contact information at www.suse.com.
+ */
+
+import React, { useState } from "react";
+import { Form } from "@patternfly/react-core";
+
+import { _ } from "~/i18n";
+import { deviceChildren } from "~/components/storage/utils";
+import { ControlledPanels as Panels, Popup } from "~/components/core";
+import { DeviceSelectorTable } from "~/components/storage";
+import { noop } from "~/utils";
+
+/**
+ * @typedef {import ("~/client/storage").ProposalSettings} ProposalSettings
+ * @typedef {import ("~/client/storage").StorageDevice} StorageDevice
+ */
+
+const SELECT_DISK_ID = "select-disk";
+const CREATE_LVM_ID = "create-lvm";
+const SELECT_DISK_PANEL_ID = "panel-for-disk-selection";
+const CREATE_LVM_PANEL_ID = "panel-for-lvm-creation";
+const OPTIONS_NAME = "selection-mode";
+
+const Html = ({ children, ...props }) => (
+  <div {...props} dangerouslySetInnerHTML={{ __html: children }} />
+);
+
+/**
+ * Renders a dialog that allows the user to select a target device for installation.
+ * @component
+ *
+ * @param {object} props
+ * @param {string} props.target
+ * @param {StorageDevice|undefined} props.targetDevice
+ * @param {StorageDevice[]} props.targetPVDevices
+ * @param {StorageDevice[]} props.devices - The actions to perform in the system.
+ * @param {boolean} [props.isOpen=false] - Whether the dialog is visible or not.
+ * @param {function} [props.onCancel=noop]
+ * @param {(target: Target) => void} [props.onAccept=noop]
+ *
+ * @typedef {object} Target
+ * @property {string} target
+ * @property {StorageDevice|undefined} targetDevice
+ * @property {StorageDevice[]} targetPVDevices
+
+ */
+export default function DeviceSelectionDialog({
+  target: defaultTarget,
+  targetDevice: defaultTargetDevice,
+  targetPVDevices: defaultPVDevices,
+  devices,
+  isOpen,
+  onCancel = noop,
+  onAccept = noop,
+  ...props
+}) {
+  const [target, setTarget] = useState(defaultTarget);
+  const [targetDevice, setTargetDevice] = useState(defaultTargetDevice);
+  const [targetPVDevices, setTargetPVDevices] = useState(defaultPVDevices);
+
+  const isTargetDisk = target === "disk";
+  const isTargetNewLvmVg = target === "newLvmVg";
+
+  const selectTargetDisk = () => setTarget("disk");
+  const selectTargetNewLvmVG = () => setTarget("newLvmVg");
+
+  const selectTargetDevice = (devices) => setTargetDevice(devices[0]);
+
+  const onSubmit = (e) => {
+    e.preventDefault();
+    onAccept({ target, targetDevice, targetPVDevices });
+  };
+
+  const isAcceptDisabled = () => {
+    if (isTargetDisk) return targetDevice === undefined;
+    if (isTargetNewLvmVg) return targetPVDevices.length === 0;
+
+    return true;
+  };
+
+  const isDeviceSelectable = (device) => device.isDrive || device.type === "md";
+
+  return (
+    <Popup
+      title={_("Device for installing the system")}
+      isOpen={isOpen}
+      variant="medium"
+      {...props}
+    >
+      <Form id="target-form" onSubmit={onSubmit}>
+        <Panels className="stack">
+          <Panels.Options data-variant="buttons">
+            <Panels.Option
+              id={SELECT_DISK_ID}
+              name={OPTIONS_NAME}
+              isSelected={isTargetDisk}
+              onChange={selectTargetDisk}
+              controls={SELECT_DISK_PANEL_ID}
+            >
+              {_("Select a disk")}
+            </Panels.Option>
+            <Panels.Option
+              id={CREATE_LVM_ID}
+              name={OPTIONS_NAME}
+              isSelected={isTargetNewLvmVg}
+              onChange={selectTargetNewLvmVG}
+              controls={CREATE_LVM_PANEL_ID}
+            >
+              {_("Create an LVM Volume Group")}
+            </Panels.Option>
+          </Panels.Options>
+
+          <Panels.Panel id={SELECT_DISK_PANEL_ID} isExpanded={isTargetDisk}>
+            <Html>
+              {
+                // TRANSLATORS: beware the HTML markup (<b> and </b>)
+                _("The file systems will be allocated by default as <b>new partitions in the selected device</b>.")
+              }
+            </Html>
+
+            <DeviceSelectorTable
+              aria-label={_("Device selector for target disk")}
+              devices={devices}
+              selected={[targetDevice]}
+              itemChildren={deviceChildren}
+              itemSelectable={isDeviceSelectable}
+              onSelectionChange={selectTargetDevice}
+              variant="compact"
+            />
+          </Panels.Panel>
+
+          <Panels.Panel id={CREATE_LVM_PANEL_ID} isExpanded={isTargetNewLvmVg} className="stack">
+            <Html>
+              {
+                // TRANSLATORS: beware the HTML markup (<b> and </b>)
+                _("The file systems will be allocated by default as <b>logical volumes of a new LVM Volume \
+Group</b>. The corresponding physical volumes will be created on demand as new partitions at the selected devices.")
+              }
+            </Html>
+
+            <DeviceSelectorTable
+              aria-label={_("Device selector for new LVM volume group")}
+              isMultiple
+              devices={devices}
+              selected={targetPVDevices}
+              itemChildren={deviceChildren}
+              itemSelectable={isDeviceSelectable}
+              onSelectionChange={setTargetPVDevices}
+              variant="compact"
+            />
+          </Panels.Panel>
+        </Panels>
+      </Form>
+      <Popup.Actions>
+        <Popup.Confirm form="target-form" type="submit" isDisabled={isAcceptDisabled()} />
+        <Popup.Cancel onClick={onCancel} />
+      </Popup.Actions>
+    </Popup>
+  );
+}
diff --git a/web/src/components/storage/DeviceSelectionDialog.test.jsx b/web/src/components/storage/DeviceSelectionDialog.test.jsx
new file mode 100644
index 0000000000..bb450ccf8c
--- /dev/null
+++ b/web/src/components/storage/DeviceSelectionDialog.test.jsx
@@ -0,0 +1,297 @@
+/*
+ * Copyright (c) [2024] SUSE LLC
+ *
+ * All Rights Reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of version 2 of the GNU General Public License as published
+ * by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, contact SUSE LLC.
+ *
+ * To contact SUSE LLC about this file by physical or electronic mail, you may
+ * find current contact information at www.suse.com.
+ */
+
+import React from "react";
+import { screen, within } from "@testing-library/react";
+import { plainRender } from "~/test-utils";
+import { DeviceSelectionDialog } from "~/components/storage";
+
+const sda = {
+  sid: 59,
+  isDrive: true,
+  type: "disk",
+  vendor: "Micron",
+  model: "Micron 1100 SATA",
+  driver: ["ahci", "mmcblk"],
+  bus: "IDE",
+  busId: "",
+  transport: "usb",
+  dellBOSS: false,
+  sdCard: true,
+  active: true,
+  name: "/dev/sda",
+  size: 1024,
+  recoverableSize: 0,
+  systems : [],
+  udevIds: ["ata-Micron_1100_SATA_512GB_12563", "scsi-0ATA_Micron_1100_SATA_512GB"],
+  udevPaths: ["pci-0000:00-12", "pci-0000:00-12-ata"],
+};
+
+const sdb = {
+  sid: 62,
+  isDrive: true,
+  type: "disk",
+  vendor: "Samsung",
+  model: "Samsung Evo 8 Pro",
+  driver: ["ahci"],
+  bus: "IDE",
+  busId: "",
+  transport: "",
+  dellBOSS: false,
+  sdCard: false,
+  active: true,
+  name: "/dev/sdb",
+  size: 2048,
+  recoverableSize: 0,
+  systems : [],
+  udevIds: [],
+  udevPaths: ["pci-0000:00-19"]
+};
+
+const sdc = {
+  sid: 63,
+  isDrive: true,
+  type: "disk",
+  vendor: "Samsung",
+  model: "Samsung Evo 8 Pro",
+  driver: ["ahci"],
+  bus: "IDE",
+  busId: "",
+  transport: "",
+  dellBOSS: false,
+  sdCard: false,
+  active: true,
+  name: "/dev/sdc",
+  size: 2048,
+  recoverableSize: 0,
+  systems : [],
+  udevIds: [],
+  udevPaths: ["pci-0000:00-19"]
+};
+
+let props;
+
+const expectSelector = (selector) => {
+  const option = (name) => {
+    const row = within(selector).getByRole("row", { name });
+    return within(row).queryByRole("radio") || within(row).queryByRole("checkbox");
+  };
+
+  const matchers = (modifier = (obj) => obj) => {
+    return {
+      toHaveCheckedOption: (name) => {
+        modifier(expect(option(name))).toBeChecked();
+      },
+      toBeVisible: () => {
+        // Jsdom does not report correct styles, see https://github.com/jsdom/jsdom/issues/2986.
+        // expect(selector).not.toBeVisible();
+        modifier(expect(selector.parentNode)).toHaveAttribute("aria-expanded", "true");
+      }
+    };
+  };
+
+  return { ...matchers(), not: { ...matchers((obj) => obj.not) } };
+};
+
+const clickSelectorOption = async (user, selector, name) => {
+  const row = within(selector).getByRole("row", { name });
+  const option = within(row).queryByRole("radio") || within(row).queryByRole("checkbox");
+  await user.click(option);
+};
+
+describe("DeviceSelectionDialog", () => {
+  beforeEach(() => {
+    props = {
+      isOpen: true,
+      target: "disk",
+      targetPVDevices: [],
+      devices: [sda, sdb, sdc],
+      onCancel: jest.fn(),
+      onAccept: jest.fn()
+    };
+  });
+
+  it("offers an option to select a disk as target device for installation", () => {
+    plainRender(<DeviceSelectionDialog {...props} />);
+    screen.getByRole("radio", { name: "Select a disk" });
+  });
+
+  it("offers an option to create a new LVM volume group as target device for installation", () => {
+    plainRender(<DeviceSelectionDialog {...props} />);
+    screen.getByRole("radio", { name: "Create an LVM Volume Group" });
+  });
+
+  describe("if the target is a disk", () => {
+    beforeEach(() => {
+      props.target = "disk";
+      props.targetDevice = sda;
+    });
+
+    it("selects the disk option by default", () => {
+      plainRender(<DeviceSelectionDialog {...props} />);
+      const diskOption = screen.getByRole("radio", { name: /select a disk/i });
+      expect(diskOption).toBeChecked();
+      const lvmOption = screen.getByRole("radio", { name: /create an lvm/i });
+      expect(lvmOption).not.toBeChecked();
+    });
+
+    it("shows the disk selector", async () => {
+      plainRender(<DeviceSelectionDialog {...props} />);
+      const diskSelector = screen.getByRole("grid", { name: /selector for target disk/i });
+      expect(diskSelector).toBeVisible();
+      const lvmSelector = screen.getByRole("grid", { name: /selector for new lvm/i });
+      expectSelector(lvmSelector).not.toBeVisible();
+    });
+
+    it("shows the target disk as selected", () => {
+      plainRender(<DeviceSelectionDialog {...props} />);
+      const selector = screen.getByRole("grid", { name: /selector for target disk/i });
+      expectSelector(selector).toHaveCheckedOption(/sda/);
+      expectSelector(selector).not.toHaveCheckedOption(/sdb/);
+      expectSelector(selector).not.toHaveCheckedOption(/sdc/);
+    });
+
+    it("allows to switch to new LVM", async () => {
+      const { user } = plainRender(<DeviceSelectionDialog {...props} />);
+      const lvmOption = screen.getByRole("radio", { name: /create an lvm/i });
+      expect(lvmOption).not.toBeChecked();
+
+      await user.click(lvmOption);
+
+      expect(lvmOption).toBeChecked();
+      const diskOption = screen.getByRole("radio", { name: /select a disk/i });
+      expect(diskOption).not.toBeChecked();
+      const lvmSelector = screen.getByRole("grid", { name: /selector for new lvm/i });
+      expect(lvmSelector).toBeVisible();
+      const diskSelector = screen.getByRole("grid", { name: /selector for target disk/i });
+      expectSelector(diskSelector).not.toBeVisible();
+    });
+  });
+
+  describe("if the target is a new LVM volume group", () => {
+    beforeEach(() => {
+      props.target = "newLvmVg";
+      props.targetPVDevices = [sda, sdc];
+    });
+
+    it("selects the LVM option by default", () => {
+      plainRender(<DeviceSelectionDialog {...props} />);
+      const lvmOption = screen.getByRole("radio", { name: /create an lvm/i });
+      expect(lvmOption).toBeChecked();
+      const diskOption = screen.getByRole("radio", { name: /select a disk/i });
+      expect(diskOption).not.toBeChecked();
+    });
+
+    it("shows the selector for LVM candidate devices", () => {
+      plainRender(<DeviceSelectionDialog {...props} />);
+      const lvmSelector = screen.getByRole("grid", { name: /selector for new lvm/i });
+      expect(lvmSelector).toBeVisible();
+      const diskSelector = screen.getByRole("grid", { name: /selector for target disk/i });
+      expectSelector(diskSelector).not.toBeVisible();
+    });
+
+    it("shows the current candidate devices as selected", () => {
+      plainRender(<DeviceSelectionDialog {...props} />);
+      const selector = screen.getByRole("grid", { name: /selector for new lvm/i });
+      expectSelector(selector).toHaveCheckedOption(/sda/);
+      expectSelector(selector).not.toHaveCheckedOption(/sdb/);
+      expectSelector(selector).toHaveCheckedOption(/sdc/);
+    });
+
+    it("allows to switch to disk", async () => {
+      const { user } = plainRender(<DeviceSelectionDialog {...props} />);
+      const diskOption = screen.getByRole("radio", { name: /select a disk/i });
+      expect(diskOption).not.toBeChecked();
+
+      await user.click(diskOption);
+
+      expect(diskOption).toBeChecked();
+      const diskSelector = screen.getByRole("grid", { name: /selector for target disk/i });
+      expect(diskSelector).toBeVisible();
+      const lvmOption = screen.getByRole("radio", { name: /create an lvm/i });
+      expect(lvmOption).not.toBeChecked();
+      const lvmSelector = screen.getByRole("grid", { name: /selector for new lvm/i });
+      expectSelector(lvmSelector).not.toBeVisible();
+    });
+  });
+
+  it("does not call onAccept on cancel", async () => {
+    const { user } = plainRender(<DeviceSelectionDialog {...props} />);
+    const cancel = screen.getByRole("button", { name: "Cancel" });
+
+    await user.click(cancel);
+
+    expect(props.onAccept).not.toHaveBeenCalled();
+  });
+
+  describe("if the option to select a disk as target device is selected", () => {
+    beforeEach(() => {
+      props.target = "newLvmVg";
+      props.targetDevice = sda;
+    });
+
+    it("calls onAccept with the selected target and disk on accept", async () => {
+      const { user } = plainRender(<DeviceSelectionDialog {...props} />);
+
+      const diskOption = screen.getByRole("radio", { name: /select a disk/i });
+      await user.click(diskOption);
+
+      const selector = screen.getByRole("grid", { name: /selector for target disk/i });
+      await clickSelectorOption(user, selector, /sdb/);
+
+      const accept = screen.getByRole("button", { name: "Confirm" });
+      await user.click(accept);
+
+      expect(props.onAccept).toHaveBeenCalledWith({
+        target: "disk",
+        targetDevice: sdb,
+        targetPVDevices: []
+      });
+    });
+  });
+
+  describe("if the option to create a new LVM volume group is selected", () => {
+    beforeEach(() => {
+      props.target = "disk";
+      props.targetDevice = sdb;
+    });
+
+    it("calls onAccept with the selected target and the candidate devices on accept", async () => {
+      const { user } = plainRender(<DeviceSelectionDialog {...props} />);
+
+      const lvmOption = screen.getByRole("radio", { name: /create an lvm/i });
+      await user.click(lvmOption);
+
+      const selector = screen.getByRole("grid", { name: /selector for new lvm/i });
+      await clickSelectorOption(user, selector, /sda/);
+      await clickSelectorOption(user, selector, /sdc/);
+
+      const accept = screen.getByRole("button", { name: "Confirm" });
+      await user.click(accept);
+
+      expect(props.onAccept).toHaveBeenCalledWith({
+        target: "newLvmVg",
+        targetDevice: sdb,
+        targetPVDevices: [sda, sdc]
+      });
+    });
+  });
+});
diff --git a/web/src/components/storage/DeviceSelectorTable.jsx b/web/src/components/storage/DeviceSelectorTable.jsx
new file mode 100644
index 0000000000..0653019f70
--- /dev/null
+++ b/web/src/components/storage/DeviceSelectorTable.jsx
@@ -0,0 +1,61 @@
+/*
+ * Copyright (c) [2024] SUSE LLC
+ *
+ * All Rights Reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of version 2 of the GNU General Public License as published
+ * by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, contact SUSE LLC.
+ *
+ * To contact SUSE LLC about this file by physical or electronic mail, you may
+ * find current contact information at www.suse.com.
+ */
+
+import React from "react";
+import { _ } from "~/i18n";
+import { deviceSize } from '~/components/storage/utils';
+import { DeviceExtendedInfo, DeviceContentInfo } from "~/components/storage";
+import { ExpandableSelector } from "~/components/core";
+
+/**
+ * @typedef {import ("~/client/storage").ProposalSettings} ProposalSettings
+ * @typedef {import ("~/client/storage").StorageDevice} StorageDevice
+ */
+
+const DeviceInfo = ({ device }) => {
+  if (!device.sid) return _("Unused space");
+
+  return <DeviceExtendedInfo device={device} />;
+};
+
+const deviceColumns = [
+  { name: _("Device"), value: (device) => <DeviceInfo device={device} /> },
+  { name: _("Content"), value: (device) => <DeviceContentInfo device={device} /> },
+  { name: _("Size"), value: (device) => deviceSize(device.size), classNames: "sizes-column" }
+];
+
+export default function DeviceSelectorTable({ devices, selected, ...props }) {
+  return (
+    <ExpandableSelector
+      columns={deviceColumns}
+      items={devices}
+      itemIdKey="sid"
+      itemClassNames={(device) => {
+        if (!device.sid) {
+          return "dimmed-row";
+        }
+      }}
+      itemsSelected={selected}
+      className="devices-table"
+      {...props}
+    />
+  );
+}
diff --git a/web/src/components/storage/DevicesFormSelect.jsx b/web/src/components/storage/DevicesFormSelect.jsx
new file mode 100644
index 0000000000..baf73b0098
--- /dev/null
+++ b/web/src/components/storage/DevicesFormSelect.jsx
@@ -0,0 +1,66 @@
+/*
+ * Copyright (c) [2024] SUSE LLC
+ *
+ * All Rights Reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of version 2 of the GNU General Public License as published
+ * by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, contact SUSE LLC.
+ *
+ * To contact SUSE LLC about this file by physical or electronic mail, you may
+ * find current contact information at www.suse.com.
+ */
+
+// @ts-check
+
+import React from "react";
+import { FormSelect, FormSelectOption } from '@patternfly/react-core';
+import { deviceSize } from '~/components/storage/utils';
+
+/**
+ * @typedef {import ("@patternfly/react-core").FormSelectProps} PFFormSelectProps
+ * @typedef {import ("~/client/storage").StorageDevice} StorageDevice
+ */
+
+/**
+ * A PF/Select for simple device selection
+ * @component
+ *
+ * @example <caption>Simple usage</caption>
+ *   import { devices, selected } from "somewhere";
+ *
+ *   <DevicesFormSelect devices={devices} selected={selected} />
+ *
+ * @typedef {object} DevicesFormSelectBaseProps
+ * @property {StorageDevice[]} props.devices - Devices to show in the selector.
+ * @property {StorageDevice} [props.selectedDevice] - Currently selected device. In case of
+ * @property {(StorageDevice) => void} props.onChange - Callback to be called when the selection changes
+ *
+ * @param {DevicesFormSelectBaseProps & Omit<PFFormSelectProps, "value" | "onChange" | "children">} props
+ */
+export default function DevicesFormSelect({ devices, selectedDevice, onChange, ...otherProps }) {
+  return (
+    /** @ts-expect-error: for some reason using otherProps makes TS complain */
+    <FormSelect
+      {...otherProps}
+      value={selectedDevice?.sid}
+      onChange={(_, value) => onChange(devices.find(d => d.sid === Number(value)))}
+    >
+      { devices.map(device => (
+        <FormSelectOption
+          key={device.sid}
+          value={device.sid}
+          label={`${device.name}, ${deviceSize(device.size)}`}
+        />
+      ))}
+    </FormSelect>
+  );
+}
diff --git a/web/src/components/storage/DevicesFormSelect.test.jsx b/web/src/components/storage/DevicesFormSelect.test.jsx
new file mode 100644
index 0000000000..0040f91709
--- /dev/null
+++ b/web/src/components/storage/DevicesFormSelect.test.jsx
@@ -0,0 +1,24 @@
+/*
+ * Copyright (c) [2024] SUSE LLC
+ *
+ * All Rights Reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of version 2 of the GNU General Public License as published
+ * by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, contact SUSE LLC.
+ *
+ * To contact SUSE LLC about this file by physical or electronic mail, you may
+ * find current contact information at www.suse.com.
+ */
+
+describe("DevicesFormSelect", () => {
+  it.todo("add examples for testing storage/DevicesFormSelect component");
+});
diff --git a/web/src/components/storage/ProposalDeviceSection.jsx b/web/src/components/storage/ProposalDeviceSection.jsx
index a39f4e333a..0b065a4c0f 100644
--- a/web/src/components/storage/ProposalDeviceSection.jsx
+++ b/web/src/components/storage/ProposalDeviceSection.jsx
@@ -19,66 +19,54 @@
  * find current contact information at www.suse.com.
  */
 
-import React, { useEffect, useState } from "react";
+// @ts-check
+
+import React, { useState } from "react";
 import {
   Button,
-  Form,
   Skeleton,
-  Switch,
-  ToggleGroup, ToggleGroupItem,
-  Tooltip
 } from "@patternfly/react-core";
 
 import { _ } from "~/i18n";
-import { Icon } from "~/components/layout";
-import { If, Section, Popup } from "~/components/core";
-import { DeviceList, DeviceSelector } from "~/components/storage";
+import { DeviceSelectionDialog } from "~/components/storage";
 import { deviceLabel } from '~/components/storage/utils';
-import { noop } from "~/utils";
+import { If, Section } from "~/components/core";
+import { sprintf } from "sprintf-js";
+import { compact, noop } from "~/utils";
 
 /**
- * @typedef {import ("~/client/storage").ProposalManager.ProposalSettings} ProposalSettings
- * @typedef {import ("~/client/storage").DevicesManager.StorageDevice} StorageDevice
+ * @typedef {import ("~/client/storage").ProposalSettings} ProposalSettings
+ * @typedef {import ("~/client/storage").StorageDevice} StorageDevice
  */
 
 /**
- * Form for selecting the installation device.
- * @component
+ * Renders a button that allows changing the target device for installation.
  *
  * @param {object} props
- * @param {string} props.id - Form ID.
- * @param {StorageDevice} [props.current] - Currently selected device, if any.
- * @param {StorageDevice[]} [props.devices=[]] - Available devices for the selection.
- * @param {onSubmitFn} [props.onSubmit=noop] - On submit callback.
- *
- * @callback onSubmitFn
- * @param {string} device - Name of the selected device.
+ * @param {string} props.target
+ * @param {StorageDevice|undefined} props.targetDevice
+ * @param {StorageDevice[]} props.targetPVDevices
+ * @param {import("react").MouseEventHandler<HTMLButtonElement>} [props.onClick=noop]
  */
-const InstallationDeviceForm = ({
-  id,
-  current,
-  devices = [],
-  onSubmit = noop
-}) => {
-  const [device, setDevice] = useState(current || devices[0]);
-
-  const changeSelected = (deviceId) => {
-    setDevice(devices.find(d => d.sid === deviceId));
-  };
+const TargetDeviceButton = ({ target, targetDevice, targetPVDevices, onClick = noop }) => {
+  const label = () => {
+    if (target === "disk" && targetDevice) return deviceLabel(targetDevice);
+    if (target === "newLvmVg" && targetPVDevices.length > 0) {
+      if (targetPVDevices.length > 1) return _("new LVM volume group");
+
+      if (targetPVDevices.length === 1) {
+        // TRANSLATORS: %s is the disk used for the LVM physical volumes (eg. "/dev/sda, 80 GiB)
+        return sprintf(_("new LVM volume group on %s"), deviceLabel(targetPVDevices[0]));
+      }
+    }
 
-  const submitForm = (e) => {
-    e.preventDefault();
-    if (device !== undefined) onSubmit(device);
+    return _("No device selected yet");
   };
 
   return (
-    <Form id={id} onSubmit={submitForm}>
-      <DeviceSelector
-        selected={device}
-        devices={devices}
-        onChange={changeSelected}
-      />
-    </Form>
+    <Button variant="link" isInline onClick={onClick}>
+      {label()}
+    </Button>
   );
 };
 
@@ -86,310 +74,78 @@ const InstallationDeviceForm = ({
  * Allows to select the installation device.
  * @component
  *
- * @callback onChangeFn
- * @param {string} device - Name of the selected device.
- *
  * @param {object} props
- * @param {string} [props.current] - Device name, if any.
- * @param {StorageDevice[]} [props.devices=[]] - Available devices for the selection.
- * @param {boolean} [props.isLoading=false] - Whether to show the selector as loading.
- * @param {onChangeFn} [props.onChange=noop] - On change callback.
+ * @param {string} props.target - Installation target ("disk", "newLvmVg", "reusedLvmVg").
+ * @param {StorageDevice|undefined} props.targetDevice - Target device (for target "disk").
+ * @param {StorageDevice[]} props.targetPVDevices - Target devices for the LVM volume group (target "newLvmVg").
+ * @param {StorageDevice[]} props.devices - Available devices for installation.
+ * @param {boolean} props.isLoading
+ * @param {(target: Target) => void} props.onChange
+ *
+ * @typedef {object} Target
+ * @property {string} target
+ * @property {StorageDevice|undefined} targetDevice
+ * @property {StorageDevice[]} targetPVDevices
  */
 const InstallationDeviceField = ({
-  current,
-  devices = [],
-  isLoading = false,
-  onChange = noop
+  target,
+  targetDevice,
+  targetPVDevices,
+  devices,
+  isLoading,
+  onChange
 }) => {
-  const [device, setDevice] = useState();
-  const [isFormOpen, setIsFormOpen] = useState(false);
+  const [isDialogOpen, setIsDialogOpen] = useState(false);
 
-  const openForm = () => setIsFormOpen(true);
+  const openDialog = () => setIsDialogOpen(true);
 
-  const closeForm = () => setIsFormOpen(false);
+  const closeDialog = () => setIsDialogOpen(false);
 
-  const acceptForm = (selectedDevice) => {
-    closeForm();
-    setDevice(selectedDevice);
-    onChange(selectedDevice);
-  };
-
-  useEffect(() => {
-    setDevice(devices.find(d => d.name === current));
-  }, [current, devices, setDevice]);
-
-  /**
-   * Renders a button that allows changing selected device
-   *
-   * NOTE: if a device is already selected, its name and size will be used for
-   * the button text. Otherwise, a "No device selected" text will be shown.
-   *
-   * @param {object} props
-   * @param {StorageDevice|undefined} [props.current] - Currently selected device, if any.
-   */
-  const DeviceContent = ({ device }) => {
-    return (
-      <Button variant="link" isInline onClick={openForm}>
-        {device ? deviceLabel(device) : _("No device selected yet")}
-      </Button>
-    );
+  const onAccept = ({ target, targetDevice, targetPVDevices }) => {
+    closeDialog();
+    onChange({ target, targetDevice, targetPVDevices });
   };
 
   if (isLoading) {
     return <Skeleton screenreaderText={_("Waiting for information about selected device")} width="25%" />;
   }
 
-  const description = _("Select the device for installing the system.");
-
-  return (
-    <>
-      <div className="split">
-        <span>{_("Installation device")}</span>
-        <DeviceContent device={device} />
-      </div>
-      <Popup
-        title={_("Installation device")}
-        description={description}
-        isOpen={isFormOpen}
-      >
-        <If
-          condition={devices.length === 0}
-          then={_("No devices found.")}
-          else={
-            <InstallationDeviceForm
-              id="bootDeviceForm"
-              current={device}
-              devices={devices}
-              onSubmit={acceptForm}
-            />
-          }
-        />
-        <Popup.Actions>
-          <Popup.Confirm
-            form="bootDeviceForm"
-            type="submit"
-            isDisabled={devices.length === 0}
-          >
-            {_("Accept")}
-          </Popup.Confirm>
-          <Popup.Cancel onClick={closeForm} />
-        </Popup.Actions>
-      </Popup>
-    </>
-  );
-};
-
-/**
- * Form for configuring the system volume group.
- * @component
- *
- * @param {object} props
- * @param {string} props.id - Form ID.
- * @param {ProposalSettings} props.settings - Settings used for calculating a proposal.
- * @param {StorageDevice[]} [props.devices=[]] - Available storage devices.
- * @param {onSubmitFn} [props.onSubmit=noop] - On submit callback.
- * @param {onValidateFn} [props.onValidate=noop] - On validate callback.
- *
- * @callback onSubmitFn
- * @param {string[]} devices - Name of the selected devices.
- *
- * @callback onValidateFn
- * @param {boolean} valid
- */
-const LVMSettingsForm = ({
-  id,
-  settings,
-  devices = [],
-  onSubmit: onSubmitProp = noop,
-  onValidate = noop
-}) => {
-  const [vgDevices, setVgDevices] = useState(settings.systemVGDevices);
-  const [isBootDeviceSelected, setIsBootDeviceSelected] = useState(settings.systemVGDevices.length === 0);
-  const [editedDevices, setEditedDevices] = useState(false);
-
-  const selectBootDevice = () => {
-    setIsBootDeviceSelected(true);
-    onValidate(true);
-  };
-
-  const selectCustomDevices = () => {
-    setIsBootDeviceSelected(false);
-    const { bootDevice } = settings;
-    const customDevices = (vgDevices.length === 0 && !editedDevices) ? [bootDevice] : vgDevices;
-    setVgDevices(customDevices);
-    onValidate(customDevices.length > 0);
-  };
-
-  const onChangeDevices = (selection) => {
-    const selectedDevices = devices.filter(d => selection.includes(d.sid)).map(d => d.name);
-    setVgDevices(selectedDevices);
-    setEditedDevices(true);
-    onValidate(devices.length > 0);
-  };
-
-  const onSubmit = (e) => {
-    e.preventDefault();
-    const customDevices = isBootDeviceSelected ? [] : vgDevices;
-    onSubmitProp(customDevices);
-  };
-
-  const BootDevice = () => {
-    const bootDevice = devices.find(d => d.name === settings.bootDevice);
-
-    // FIXME: In this case, should be a "readOnly" selector.
-    return <DeviceList devices={[bootDevice]} />;
-  };
-
   return (
-    <Form id={id} onSubmit={onSubmit}>
-      <div className="split">
-        <span>{_("Devices for creating the volume group")}</span>
-        <ToggleGroup isCompact>
-          <ToggleGroupItem
-            text={_("Installation device")}
-            buttonId="bootDevice"
-            isSelected={isBootDeviceSelected}
-            onClick={selectBootDevice}
-          />
-          <ToggleGroupItem
-            text={_("Custom devices")}
-            buttonId="customDevices"
-            isSelected={!isBootDeviceSelected}
-            onClick={selectCustomDevices}
-          />
-        </ToggleGroup>
-      </div>
+    <div className="split">
+      <span>{_("Installation device")}</span>
+      <TargetDeviceButton
+        target={target}
+        targetDevice={targetDevice}
+        targetPVDevices={targetPVDevices}
+        onClick={openDialog}
+      />
       <If
-        condition={isBootDeviceSelected}
-        then={<BootDevice />}
-        else={
-          <DeviceSelector
-            isMultiple
-            selected={devices.filter(d => vgDevices?.includes(d.name))}
+        condition={isDialogOpen}
+        then={
+          <DeviceSelectionDialog
+            isOpen
+            target={target}
+            targetDevice={targetDevice}
+            targetPVDevices={targetPVDevices}
             devices={devices}
-            onChange={onChangeDevices}
+            onAccept={onAccept}
+            onCancel={closeDialog}
           />
         }
       />
-    </Form>
-  );
-};
-
-/**
- * Allows to select LVM and configure the system volume group.
- * @component
- *
- * @param {object} props
- * @param {ProposalSettings} props.settings - Settings used for calculating a proposal.
- * @param {StorageDevice[]} [props.devices=[]] - Available storage devices.
- * @param {boolean} [props.isChecked=false] - Whether LVM is selected.
- * @param {boolean} [props.isLoading=false] - Whether to show the selector as loading.
- * @param {onChangeFn} [props.onChange=noop] - On change callback.
- *
- * @callback onChangeFn
- * @param {boolean} lvm
- */
-const LVMField = ({
-  settings,
-  devices = [],
-  isChecked: isCheckedProp = false,
-  isLoading = false,
-  onChange: onChangeProp = noop
-}) => {
-  const [isChecked, setIsChecked] = useState();
-  const [isFormOpen, setIsFormOpen] = useState(false);
-  const [isFormValid, setIsFormValid] = useState(true);
-
-  const onChange = (_, value) => {
-    setIsChecked(value);
-    onChangeProp({ lvm: value, vgDevices: [] });
-  };
-
-  const openForm = () => setIsFormOpen(true);
-
-  const closeForm = () => setIsFormOpen(false);
-
-  const onValidateForm = (valid) => setIsFormValid(valid);
-
-  const onSubmitForm = (vgDevices) => {
-    closeForm();
-    onChangeProp({ vgDevices });
-  };
-
-  useEffect(() => {
-    setIsChecked(isCheckedProp);
-  }, [isCheckedProp, setIsChecked]);
-
-  const description = _("Configuration of the system volume group. All the file systems will be \
-created in a logical volume of the system volume group.");
-
-  const LVMSettingsButton = () => {
-    return (
-      <Tooltip
-        content={_("Configure the LVM settings")}
-        entryDelay={400}
-        exitDelay={50}
-        position="right"
-      >
-        <button aria-label={_("LVM settings")} className="plain-control" onClick={openForm}>
-          <Icon name="tune" size="s" />
-        </button>
-      </Tooltip>
-    );
-  };
-
-  if (isLoading) return <Skeleton screenreaderText={_("Waiting for information about LVM")} width="25%" />;
-
-  return (
-    <div className="split">
-      <Switch
-        id="lvm"
-        label={_("Use logical volume management (LVM)")}
-        isReversed
-        isChecked={isChecked}
-        onChange={onChange}
-      />
-      <If condition={isChecked} then={<LVMSettingsButton />} />
-      <Popup
-        aria-label={_("LVM settings")}
-        title={_("System Volume Group")}
-        description={description}
-        isOpen={isFormOpen}
-      >
-        <LVMSettingsForm
-          id="lvmSettingsForm"
-          devices={devices}
-          settings={settings}
-          onSubmit={onSubmitForm}
-          onValidate={onValidateForm}
-        />
-        <Popup.Actions>
-          <Popup.Confirm
-            form="lvmSettingsForm"
-            type="submit"
-            isDisabled={!isFormValid}
-          >
-            {_("Accept")}
-          </Popup.Confirm>
-          <Popup.Cancel onClick={closeForm} />
-        </Popup.Actions>
-      </Popup>
     </div>
   );
 };
 
 /**
- * Section for editing the selected device
+ * Section for editing the target device for installation.
  * @component
  *
- * @callback onChangeFn
- * @param {object} settings
- *
  * @param {object} props
  * @param {ProposalSettings} props.settings
  * @param {StorageDevice[]} [props.availableDevices=[]]
- * @param {boolean} [isLoading=false]
- * @param {onChangeFn} [props.onChange=noop]
+ * @param {boolean} [props.isLoading=false]
+ * @param {(settings: object) => void} [props.onChange=noop]
  */
 export default function ProposalDeviceSection({
   settings,
@@ -397,21 +153,18 @@ export default function ProposalDeviceSection({
   isLoading = false,
   onChange = noop
 }) {
-  // FIXME: we should work with devices objects ASAP
-  const { bootDevice } = settings;
-
-  const changeBootDevice = (device) => {
-    if (device.name !== bootDevice) {
-      onChange({ bootDevice: device.name });
-    }
-  };
-
-  const changeLVM = ({ lvm, vgDevices }) => {
-    const settings = {};
-    if (lvm !== undefined) settings.lvm = lvm;
-    if (vgDevices !== undefined) settings.systemVGDevices = vgDevices;
-
-    onChange(settings);
+  const findDevice = (name) => availableDevices.find(a => a.name === name);
+
+  const target = settings.target;
+  const targetDevice = findDevice(settings.targetDevice);
+  const targetPVDevices = compact(settings.targetPVDevices?.map(findDevice) || []);
+
+  const changeTarget = ({ target, targetDevice, targetPVDevices }) => {
+    onChange({
+      target,
+      targetDevice: targetDevice?.name,
+      targetPVDevices: targetPVDevices.map(d => d.name)
+    });
   };
 
   const Description = () => (
@@ -427,22 +180,17 @@ Volume Group for installation.")
 
   return (
     <Section
-      // TRANSLATORS: The storage "Device" section's title
+      // TRANSLATORS: The storage "Device" section's title.
       title={_("Device")}
       description={<Description />}
     >
       <InstallationDeviceField
-        current={bootDevice}
-        devices={availableDevices}
-        isLoading={isLoading && bootDevice === undefined}
-        onChange={changeBootDevice}
-      />
-      <LVMField
-        settings={settings}
+        target={target}
+        targetDevice={targetDevice}
+        targetPVDevices={targetPVDevices}
         devices={availableDevices}
-        isChecked={settings.lvm === true}
-        isLoading={settings.lvm === undefined}
-        onChange={changeLVM}
+        isLoading={isLoading && target === undefined}
+        onChange={changeTarget}
       />
     </Section>
   );
diff --git a/web/src/components/storage/ProposalDeviceSection.test.jsx b/web/src/components/storage/ProposalDeviceSection.test.jsx
index 73cd460835..3a85b1224f 100644
--- a/web/src/components/storage/ProposalDeviceSection.test.jsx
+++ b/web/src/components/storage/ProposalDeviceSection.test.jsx
@@ -66,63 +66,21 @@ const sdb = {
   udevPaths: ["pci-0000:00-19"]
 };
 
-const vda = {
-  sid: "59",
-  type: "disk",
-  vendor: "Micron",
-  model: "Micron 1100 SATA",
-  driver: ["ahci", "mmcblk"],
-  bus: "IDE",
-  transport: "usb",
-  dellBOSS: false,
-  sdCard: true,
-  active: true,
-  name: "/dev/vda",
-  size: 1024,
-  systems: ["Windows", "openSUSE Leap 15.2"],
-  udevIds: ["ata-Micron_1100_SATA_512GB_12563", "scsi-0ATA_Micron_1100_SATA_512GB"],
-  udevPaths: ["pci-0000:00-12", "pci-0000:00-12-ata"],
-  partitionTable: { type: "gpt", partitions: [] }
-};
-
-const md0 = {
-  sid: "62",
-  type: "md",
-  level: "raid0",
-  uuid: "12345:abcde",
-  members: ["/dev/vdb"],
-  active: true,
-  name: "/dev/md0",
-  size: 2048,
-  systems: [],
-  udevIds: [],
-  udevPaths: []
-};
-
-const md1 = {
-  sid: "63",
-  type: "md",
-  level: "raid0",
-  uuid: "12345:abcde",
-  members: ["/dev/vdc"],
-  active: true,
-  name: "/dev/md1",
-  size: 4096,
-  systems: [],
-  udevIds: [],
-  udevPaths: []
-};
-
-const props = {
-  settings: {
-    bootDevice: "/dev/sda",
-  },
-  availableDevices: [sda, sdb],
-  isLoading: false,
-  onChange: jest.fn()
-};
+let props;
 
 describe("ProposalDeviceSection", () => {
+  beforeEach(() => {
+    props = {
+      settings: {
+        target: "disk",
+        targetDevice: "/dev/sda",
+      },
+      availableDevices: [sda, sdb],
+      isLoading: false,
+      onChange: jest.fn()
+    };
+  });
+
   describe("Installation device field", () => {
     describe("when set as loading", () => {
       beforeEach(() => {
@@ -131,7 +89,7 @@ describe("ProposalDeviceSection", () => {
 
       describe("and selected device is not defined yet", () => {
         beforeEach(() => {
-          props.settings = { bootDevice: undefined };
+          props.settings.target = undefined;
         });
 
         it("renders a loading hint", () => {
@@ -140,257 +98,134 @@ describe("ProposalDeviceSection", () => {
         });
       });
     });
-    describe("when installation device is not selected yet", () => {
-      beforeEach(() => {
-        props.settings = { bootDevice: "" };
-      });
-
-      it("uses a 'No device selected yet' text for the selection button", async () => {
-        const { user } = plainRender(<ProposalDeviceSection {...props} />);
-        const button = screen.getByRole("button", { name: "No device selected yet" });
 
-        await user.click(button);
-
-        screen.getByRole("dialog", { name: "Installation device" });
-      });
-    });
-
-    describe("when installation device is selected", () => {
+    describe("when the target is a disk", () => {
       beforeEach(() => {
-        props.settings = { bootDevice: "/dev/sda" };
+        props.settings.target = "disk";
       });
 
-      it("uses its name as part of the text for the selection button", async () => {
-        const { user } = plainRender(<ProposalDeviceSection {...props} />);
-        const button = screen.getByRole("button", { name: /\/dev\/sda/ });
-
-        await user.click(button);
-
-        screen.getByRole("dialog", { name: "Installation device" });
-      });
-    });
-
-    it("allows changing the selected device", async () => {
-      const { user } = plainRender(<ProposalDeviceSection {...props} />);
-      const button = screen.getByRole("button", { name: "/dev/sda, 1 KiB" });
-
-      await user.click(button);
-
-      const selector = await screen.findByRole("dialog", { name: "Installation device" });
-      const sdbOption = within(selector).getByRole("radio", { name: /sdb/ });
-      const accept = within(selector).getByRole("button", { name: "Accept" });
-
-      await user.click(sdbOption);
-      await user.click(accept);
-
-      expect(screen.queryByRole("dialog")).not.toBeInTheDocument();
-      expect(props.onChange).toHaveBeenCalledWith({ bootDevice: sdb.name });
-    });
-
-    it("allows canceling a device selection", async () => {
-      const { user } = plainRender(<ProposalDeviceSection {...props} />);
-      const button = screen.getByRole("button", { name: "/dev/sda, 1 KiB" });
-
-      await user.click(button);
-
-      const selector = await screen.findByRole("dialog", { name: "Installation device" });
-      const sdbOption = within(selector).getByRole("radio", { name: /sdb/ });
-      const cancel = within(selector).getByRole("button", { name: "Cancel" });
-
-      await user.click(sdbOption);
-      await user.click(cancel);
-
-      expect(screen.queryByRole("dialog")).not.toBeInTheDocument();
-      expect(props.onChange).not.toHaveBeenCalled();
-    });
-
-    it("does not trigger the onChange callback when selection actually did not change", async () => {
-      const { user } = plainRender(<ProposalDeviceSection {...props} />);
-      const button = screen.getByRole("button", { name: "/dev/sda, 1 KiB" });
-
-      await user.click(button);
-
-      const selector = await screen.findByRole("dialog", { name: "Installation device" });
-      const sdaOption = within(selector).getByRole("radio", { name: /sda/ });
-      const sdbOption = within(selector).getByRole("radio", { name: /sdb/ });
-      const accept = within(selector).getByRole("button", { name: "Accept" });
+      describe("and installation device is not selected yet", () => {
+        beforeEach(() => {
+          props.settings.targetDevice = "";
+        });
 
-      // User selects a different device
-      await user.click(sdbOption);
-      // but then goes back to the selected device
-      await user.click(sdaOption);
-      // and clicks on Accept button
-      await user.click(accept);
+        it("uses a 'No device selected yet' text for the selection button", async () => {
+          const { user } = plainRender(<ProposalDeviceSection {...props} />);
+          const button = screen.getByRole("button", { name: "No device selected yet" });
 
-      expect(screen.queryByRole("dialog")).not.toBeInTheDocument();
-      // There is no reason for triggering the onChange callback
-      expect(props.onChange).not.toHaveBeenCalled();
-    });
-  });
+          await user.click(button);
 
-  describe("LVM field", () => {
-    describe("if LVM setting is not set yet", () => {
-      beforeEach(() => {
-        props.settings = {};
+          screen.getByRole("dialog", { name: /Device for installing/i });
+        });
       });
 
-      it("does not render the LVM switch", () => {
-        plainRender(<ProposalDeviceSection {...props} />);
-
-        expect(screen.queryByLabelText(/Use logical volume/)).toBeNull();
-      });
-    });
+      describe("and an installation device is selected", () => {
+        beforeEach(() => {
+          props.settings.targetDevice = "/dev/sda";
+        });
 
-    describe("if LVM setting is set", () => {
-      beforeEach(() => {
-        props.settings = { lvm: false };
-      });
+        it("uses its name as part of the text for the selection button", async () => {
+          const { user } = plainRender(<ProposalDeviceSection {...props} />);
+          const button = screen.getByRole("button", { name: /\/dev\/sda/ });
 
-      it("renders the LVM switch", () => {
-        plainRender(<ProposalDeviceSection {...props} />);
+          await user.click(button);
 
-        screen.getByRole("checkbox", { name: /Use logical volume/ });
+          screen.getByRole("dialog", { name: /Device for installing/i });
+        });
       });
     });
 
-    describe("if LVM is set to true", () => {
+    describe("when the target is a new LVM volume group", () => {
       beforeEach(() => {
-        props.availableDevices = [vda, md0, md1];
-        props.settings = { bootDevice: "/dev/vda", lvm: true, systemVGDevices: [] };
-        props.onChange = jest.fn();
-      });
-
-      it("renders the LVM switch as selected", () => {
-        plainRender(<ProposalDeviceSection {...props} />);
-
-        const checkbox = screen.getByRole("checkbox", { name: /Use logical volume/ });
-        expect(checkbox).toBeChecked();
-      });
-
-      it("renders a button for changing the LVM settings", () => {
-        plainRender(<ProposalDeviceSection {...props} />);
-
-        screen.getByRole("button", { name: /LVM settings/ });
-      });
-
-      it("changes the selection on click", async () => {
-        const { user } = plainRender(<ProposalDeviceSection {...props} />);
-
-        const checkbox = screen.getByRole("checkbox", { name: /Use logical volume/ });
-        await user.click(checkbox);
-
-        expect(checkbox).not.toBeChecked();
-        expect(props.onChange).toHaveBeenCalled();
+        props.settings.target = "newLvmVg";
       });
 
-      describe("and user clicks on LVM settings", () => {
-        it("opens the LVM settings dialog", async () => {
-          const { user } = plainRender(<ProposalDeviceSection {...props} />);
-          const settingsButton = screen.getByRole("button", { name: /LVM settings/ });
-
-          await user.click(settingsButton);
-
-          const popup = await screen.findByRole("dialog");
-          within(popup).getByText("System Volume Group");
+      describe("and the target devices are not selected yet", () => {
+        beforeEach(() => {
+          props.settings.targetPVDevices = [];
         });
 
-        it("allows selecting either installation device or custom devices", async () => {
+        it("uses a 'No device selected yet' text for the selection button", async () => {
           const { user } = plainRender(<ProposalDeviceSection {...props} />);
-          const settingsButton = screen.getByRole("button", { name: /LVM settings/ });
+          const button = screen.getByRole("button", { name: "No device selected yet" });
 
-          await user.click(settingsButton);
+          await user.click(button);
 
-          const popup = await screen.findByRole("dialog");
-          screen.getByText("System Volume Group");
+          screen.getByRole("dialog", { name: /Device for installing/i });
+        });
+      });
 
-          within(popup).getByRole("button", { name: "Installation device" });
-          within(popup).getByRole("button", { name: "Custom devices" });
+      describe("and there is a selected device", () => {
+        beforeEach(() => {
+          props.settings.targetPVDevices = ["/dev/sda"];
         });
 
-        it("allows to set the installation device as system volume group", async () => {
+        it("uses its name as part of the text for the selection button", async () => {
           const { user } = plainRender(<ProposalDeviceSection {...props} />);
-          const settingsButton = screen.getByRole("button", { name: /LVM settings/ });
-
-          await user.click(settingsButton);
-
-          const popup = await screen.findByRole("dialog");
-          screen.getByText("System Volume Group");
+          const button = screen.getByRole("button", { name: /new LVM .* \/dev\/sda/ });
 
-          const bootDeviceButton = within(popup).getByRole("button", { name: "Installation device" });
-          const customDevicesButton = within(popup).getByRole("button", { name: "Custom devices" });
-          const acceptButton = within(popup).getByRole("button", { name: "Accept" });
+          await user.click(button);
 
-          await user.click(customDevicesButton);
-          await user.click(bootDeviceButton);
-          await user.click(acceptButton);
+          screen.getByRole("dialog", { name: /Device for installing/i });
+        });
+      });
 
-          expect(props.onChange).toHaveBeenCalledWith(
-            expect.objectContaining({ systemVGDevices: [] })
-          );
+      describe("and there are more than one selected device", () => {
+        beforeEach(() => {
+          props.settings.targetPVDevices = ["/dev/sda", "/dev/sdb"];
         });
 
-        it("allows customize the system volume group", async () => {
+        it("does not use the names as part of the text for the selection button", async () => {
           const { user } = plainRender(<ProposalDeviceSection {...props} />);
-          const settingsButton = screen.getByRole("button", { name: /LVM settings/ });
-
-          await user.click(settingsButton);
-
-          const popup = await screen.findByRole("dialog");
-          screen.getByText("System Volume Group");
-
-          const customDevicesButton = within(popup).getByRole("button", { name: "Custom devices" });
-          const acceptButton = within(popup).getByRole("button", { name: "Accept" });
+          const button = screen.getByRole("button", { name: "new LVM volume group" });
 
-          await user.click(customDevicesButton);
+          await user.click(button);
 
-          const vdaOption = within(popup).getByRole("row", { name: /vda/ });
-          const md0Option = within(popup).getByRole("row", { name: /md0/ });
-          const md1Option = within(popup).getByRole("row", { name: /md1/ });
-
-          // unselect the boot devices
-          await user.click(vdaOption);
-
-          await user.click(md0Option);
-          await user.click(md1Option);
-
-          await user.click(acceptButton);
-
-          expect(props.onChange).toHaveBeenCalledWith(
-            expect.objectContaining({ systemVGDevices: ["/dev/md0", "/dev/md1"] })
-          );
+          screen.getByRole("dialog", { name: /Device for installing/i });
         });
       });
     });
 
-    describe("if LVM is set to false", () => {
-      beforeEach(() => {
-        props.settings = { lvm: false };
-        props.onChange = jest.fn();
-      });
+    it("allows changing the selected device", async () => {
+      const { user } = plainRender(<ProposalDeviceSection {...props} />);
+      const button = screen.getByRole("button", { name: "/dev/sda, 1 KiB" });
 
-      it("renders the LVM switch as not selected", () => {
-        plainRender(<ProposalDeviceSection {...props} />);
+      await user.click(button);
 
-        const checkbox = screen.getByRole("checkbox", { name: /Use logical volume/ });
-        expect(checkbox).not.toBeChecked();
-      });
+      const selector = await screen.findByRole("dialog", { name: /Device for installing/ });
+      const diskGrid = within(selector).getByRole("grid", { name: /target disk/ });
+      const sdbRow = within(diskGrid).getByRole("row", { name: /sdb/ });
+      const sdbOption = within(sdbRow).getByRole("radio");
+      const accept = within(selector).getByRole("button", { name: "Confirm" });
 
-      it("does not render a button for changing the LVM settings", () => {
-        plainRender(<ProposalDeviceSection {...props} />);
+      await user.click(sdbOption);
+      await user.click(accept);
 
-        const button = screen.queryByRole("button", { name: /LVM settings/ });
-        expect(button).toBeNull();
+      expect(screen.queryByRole("dialog")).not.toBeInTheDocument();
+      expect(props.onChange).toHaveBeenCalledWith({
+        target: "disk",
+        targetDevice: sdb.name,
+        targetPVDevices: []
       });
+    });
+
+    it("allows canceling a device selection", async () => {
+      const { user } = plainRender(<ProposalDeviceSection {...props} />);
+      const button = screen.getByRole("button", { name: "/dev/sda, 1 KiB" });
 
-      it("changes the selection on click", async () => {
-        const { user } = plainRender(<ProposalDeviceSection {...props} />);
+      await user.click(button);
 
-        const checkbox = screen.getByRole("checkbox", { name: /Use logical volume/ });
-        await user.click(checkbox);
+      const selector = await screen.findByRole("dialog", { name: /Device for installing/ });
+      const diskGrid = within(selector).getByRole("grid", { name: /target disk/ });
+      const sdbRow = within(diskGrid).getByRole("row", { name: /sdb/ });
+      const sdbOption = within(sdbRow).getByRole("radio");
+      const cancel = within(selector).getByRole("button", { name: "Cancel" });
 
-        expect(checkbox).toBeChecked();
-        expect(props.onChange).toHaveBeenCalled();
-      });
+      await user.click(sdbOption);
+      await user.click(cancel);
+
+      expect(screen.queryByRole("dialog")).not.toBeInTheDocument();
+      expect(props.onChange).not.toHaveBeenCalled();
     });
   });
 });
diff --git a/web/src/components/storage/ProposalPage.jsx b/web/src/components/storage/ProposalPage.jsx
index c8351e7398..5099a8fca4 100644
--- a/web/src/components/storage/ProposalPage.jsx
+++ b/web/src/components/storage/ProposalPage.jsx
@@ -196,7 +196,7 @@ export default function ProposalPage() {
   }, [client, load]);
 
   useEffect(() => {
-    const proposalLoaded = () => state.settings.bootDevice !== undefined;
+    const proposalLoaded = () => state.settings.targetDevice !== undefined;
 
     const statusHandler = (serviceStatus) => {
       // Load the proposal if no proposal has been loaded yet. This can happen if the proposal
diff --git a/web/src/components/storage/ProposalPage.test.jsx b/web/src/components/storage/ProposalPage.test.jsx
index 7bd4f44a31..516fff030f 100644
--- a/web/src/components/storage/ProposalPage.test.jsx
+++ b/web/src/components/storage/ProposalPage.test.jsx
@@ -118,7 +118,7 @@ it("does not probe storage if the storage devices are not deprecated", async ()
 
 it("loads the proposal data", async () => {
   storage.proposal.getResult = jest.fn().mockResolvedValue(
-    { settings: { bootDevice: vda.name } }
+    { settings: { target: "disk", targetDevice: vda.name } }
   );
 
   installerRender(<ProposalPage />);
@@ -129,7 +129,7 @@ it("loads the proposal data", async () => {
   await screen.findByText(/\/dev\/vda/);
 });
 
-it("renders the device, settings, find space and result sections", async () => {
+it("renders the device, settings and result sections", async () => {
   installerRender(<ProposalPage />);
 
   await screen.findByText(/Device/);
@@ -152,7 +152,7 @@ describe("when the storage devices become deprecated", () => {
   });
 
   it("loads the proposal data", async () => {
-    const result = { settings: { bootDevice: vda.name } };
+    const result = { settings: { target: "disk", targetDevice: vda.name } };
     storage.proposal.getResult = jest.fn().mockResolvedValue(result);
 
     const [mockFunction, callbacks] = createCallbackMock();
@@ -162,7 +162,7 @@ describe("when the storage devices become deprecated", () => {
 
     await screen.findByText(/\/dev\/vda/);
 
-    result.settings.bootDevice = vdb.name;
+    result.settings.targetDevice = vdb.name;
 
     const [onDeprecateCb] = callbacks;
     await act(() => onDeprecateCb());
@@ -192,7 +192,7 @@ describe("when there is no proposal yet", () => {
     screen.getAllByText(/PFSkeleton/);
 
     storage.proposal.getResult = jest.fn().mockResolvedValue(
-      { settings: { bootDevice: vda.name } }
+      { settings: { target: "disk", targetDevice: vda.name } }
     );
 
     const [onStatusChangeCb] = callbacks;
@@ -204,7 +204,7 @@ describe("when there is no proposal yet", () => {
 describe("when there is a proposal", () => {
   beforeEach(() => {
     storage.proposal.getResult = jest.fn().mockResolvedValue(
-      { settings: { bootDevice: vda.name } }
+      { settings: { target: "disk", targetDevice: vda.name } }
     );
   });
 
diff --git a/web/src/components/storage/ProposalResultSection.jsx b/web/src/components/storage/ProposalResultSection.jsx
index 675bdbe48b..0f4f60249e 100644
--- a/web/src/components/storage/ProposalResultSection.jsx
+++ b/web/src/components/storage/ProposalResultSection.jsx
@@ -28,7 +28,7 @@ import { _, n_ } from "~/i18n";
 import { deviceChildren, deviceSize } from "~/components/storage/utils";
 import DevicesManager from "~/components/storage/DevicesManager";
 import { If, Section, Reminder, Tag, TreeTable } from "~/components/core";
-import { ProposalActionsDialog } from "~/components/storage";
+import { ProposalActionsDialog, FilesystemLabel } from "~/components/storage";
 
 /**
  * @typedef {import ("~/client/storage").Action} Action
@@ -139,11 +139,6 @@ const DevicesTreeTable = ({ devicesManager }) => {
     return item.description;
   };
 
-  const renderFilesystemLabel = (item) => {
-    const label = item.filesystem?.label;
-    if (label) return <Tag variant="gray-highlight"><b>{label}</b></Tag>;
-  };
-
   const renderPTableType = (item) => {
     // TODO: Create a map for partition table types and use an <abbr/> here.
     const type = item.partitionTable?.type;
@@ -154,7 +149,7 @@ const DevicesTreeTable = ({ devicesManager }) => {
     return (
       <>
         <div>{renderNewLabel(item)}</div>
-        <div>{renderContent(item)} {renderFilesystemLabel(item)} {renderPTableType(item)}</div>
+        <div>{renderContent(item)} <FilesystemLabel device={item} /> {renderPTableType(item)}</div>
       </>
     );
   };
diff --git a/web/src/components/storage/ProposalSettingsSection.jsx b/web/src/components/storage/ProposalSettingsSection.jsx
index 871024d380..f61b14f787 100644
--- a/web/src/components/storage/ProposalSettingsSection.jsx
+++ b/web/src/components/storage/ProposalSettingsSection.jsx
@@ -20,14 +20,15 @@
  */
 
 import React, { useEffect, useState } from "react";
-import { Checkbox, Form, Skeleton, Switch, Tooltip } from "@patternfly/react-core";
+import { Button, Checkbox, Form, Skeleton, Switch, Tooltip } from "@patternfly/react-core";
 
+import { sprintf } from "sprintf-js";
 import { _ } from "~/i18n";
+import { BootSelectionDialog, ProposalVolumes, ProposalSpacePolicyField } from "~/components/storage";
 import { If, PasswordAndConfirmationInput, Section, Popup } from "~/components/core";
-import { ProposalVolumes, ProposalSpacePolicyField } from "~/components/storage";
 import { Icon } from "~/components/layout";
 import { noop } from "~/utils";
-import { hasFS } from "~/components/storage/utils";
+import { hasFS, deviceLabel } from "~/components/storage/utils";
 
 /**
  * @typedef {import ("~/client/storage").ProposalManager.ProposalSettings} ProposalSettings
@@ -267,12 +268,85 @@ const EncryptionField = ({
   );
 };
 
+/**
+ * Allows to select the boot config.
+ * @component
+ *
+ * @param {object} props
+ * @param {boolean} props.configureBoot
+ * @param {StorageDevice|undefined} props.bootDevice
+ * @param {StorageDevice|undefined} props.defaultBootDevice
+ * @param {StorageDevice[]} props.devices
+ * @param {boolean} props.isLoading
+ * @param {(boot: Boot) => void} props.onChange
+ *
+ * @typedef {object} Boot
+ * @property {boolean} configureBoot
+ * @property {StorageDevice} bootDevice
+ */
+const BootConfigField = ({
+  configureBoot,
+  bootDevice,
+  defaultBootDevice,
+  devices,
+  isLoading,
+  onChange
+}) => {
+  const [isDialogOpen, setIsDialogOpen] = useState(false);
+
+  const openDialog = () => setIsDialogOpen(true);
+
+  const closeDialog = () => setIsDialogOpen(false);
+
+  const onAccept = ({ configureBoot, bootDevice }) => {
+    closeDialog();
+    onChange({ configureBoot, bootDevice });
+  };
+
+  const label = _("Automatically configure any additional partition to boot the system");
+
+  const value = () => {
+    if (!configureBoot) return _("nowhere (manual boot setup)");
+
+    if (!bootDevice) return _("at the installation device");
+
+    // TRANSLATORS: %s is the disk used to configure the boot-related partitions (eg. "/dev/sda, 80 GiB)
+    return sprintf(_("at %s"), deviceLabel(bootDevice));
+  };
+
+  if (isLoading) {
+    return <Skeleton screenreaderText={_("Waiting for information about boot config")} width="25%" />;
+  }
+
+  return (
+    <div className="split">
+      <span>{label}</span>
+      <Button variant="link" isInline onClick={openDialog}>{value()}</Button>
+      <If
+        condition={isDialogOpen}
+        then={
+          <BootSelectionDialog
+            isOpen
+            configureBoot={configureBoot}
+            bootDevice={bootDevice}
+            defaultBootDevice={defaultBootDevice}
+            devices={devices}
+            onAccept={onAccept}
+            onCancel={closeDialog}
+          />
+        }
+      />
+    </div>
+  );
+};
+
 /**
  * Section for editing the proposal settings
  * @component
  *
  * @param {object} props
  * @param {ProposalSettings} props.settings
+ * @param {StorageDevice[]} [props.availableDevices=[]]
  * @param {String[]} [props.encryptionMethods=[]]
  * @param {onChangeFn} [props.onChange=noop]
  *
@@ -281,6 +355,7 @@ const EncryptionField = ({
  */
 export default function ProposalSettingsSection({
   settings,
+  availableDevices = [],
   encryptionMethods = [],
   volumeTemplates = [],
   isLoading = false,
@@ -311,9 +386,19 @@ export default function ProposalSettingsSection({
     onChange({ spacePolicy: policy, spaceActions: actions });
   };
 
+  const changeBoot = ({ configureBoot, bootDevice }) => {
+    onChange({
+      configureBoot,
+      bootDevice: bootDevice?.name
+    });
+  };
+
   const encryption = settings.encryptionPassword !== undefined && settings.encryptionPassword.length > 0;
 
-  const { volumes = [] } = settings;
+  const { volumes = [], installationDevices = [] } = settings;
+
+  const bootDevice = availableDevices.find(d => d.name === settings.bootDevice);
+  const defaultBootDevice = availableDevices.find(d => d.name === settings.defaultBootDevice);
 
   // Templates for already existing mount points are filtered out
   const usefulTemplates = () => {
@@ -345,10 +430,18 @@ export default function ProposalSettingsSection({
           isLoading={isLoading && settings.volumes === undefined}
           onChange={changeVolumes}
         />
+        <BootConfigField
+          configureBoot={settings.configureBoot}
+          bootDevice={bootDevice}
+          defaultBootDevice={defaultBootDevice}
+          devices={availableDevices}
+          isLoading={isLoading}
+          onChange={changeBoot}
+        />
         <ProposalSpacePolicyField
           policy={settings.spacePolicy}
           actions={settings.spaceActions}
-          devices={settings.installationDevices}
+          devices={installationDevices}
           isLoading={isLoading}
           onChange={changeSpacePolicy}
         />
diff --git a/web/src/components/storage/ProposalVolumes.jsx b/web/src/components/storage/ProposalVolumes.jsx
index a3e2f873ae..49af0b70a5 100644
--- a/web/src/components/storage/ProposalVolumes.jsx
+++ b/web/src/components/storage/ProposalVolumes.jsx
@@ -409,7 +409,7 @@ export default function ProposalVolumes({
       <Toolbar>
         <ToolbarContent>
           <ToolbarItem>
-            {_("File systems to create in your system")}
+            {_("File systems to create")}
           </ToolbarItem>
           <ToolbarItem align={{ default: "alignRight" }}>
             <GeneralActions
diff --git a/web/src/components/storage/device-utils.jsx b/web/src/components/storage/device-utils.jsx
index 47e5377aa9..d2f89962f7 100644
--- a/web/src/components/storage/device-utils.jsx
+++ b/web/src/components/storage/device-utils.jsx
@@ -25,174 +25,188 @@ import { sprintf } from "sprintf-js";
 import { _ } from "~/i18n";
 import { noop } from "~/utils";
 import { Icon } from "~/components/layout";
-import { If, Selector } from "~/components/core";
+import { If, Selector, Tag } from "~/components/core";
 import { deviceSize } from "~/components/storage/utils";
 
 /**
  * @typedef {import ("~/client/storage").DeviceManager.StorageDevice} StorageDevice
  */
 
-/**
- * Content for a device item
- * @component
- *
- * @param {Object} props
- * @param {StorageDevice} props.device
- */
-const DeviceItem = ({ device }) => {
-  const BasicInfo = () => {
-    const DeviceIcon = () => {
-      const names = {
-        raid: "storage",
-        md: "storage"
-      };
+const FilesystemLabel = ({ device }) => {
+  const label = device.filesystem?.label;
+  if (label) return <Tag variant="gray-highlight"><b>{label}</b></Tag>;
+};
 
-      const name = names[device.type] || "hard_drive";
+const DeviceExtendedInfo = ({ device }) => {
+  const DeviceName = () => {
+    if (device.name === undefined) return null;
 
-      return <Icon name={name} />;
-    };
+    return <div>{device.name}</div>;
+  };
 
-    const DeviceSize = () => {
-      if (device.size === undefined) return null;
+  const DeviceType = () => {
+    let type;
 
-      return <div>{deviceSize(device.size)}</div>;
-    };
+    switch (device.type) {
+      case "multipath": {
+        // TRANSLATORS: multipath device type
+        type = _("Multipath");
+        break;
+      }
+      case "dasd": {
+        // TRANSLATORS: %s is replaced by the device bus ID
+        type = sprintf(_("DASD %s"), device.busId);
+        break;
+      }
+      case "md": {
+        // TRANSLATORS: software RAID device, %s is replaced by the RAID level, e.g. RAID-1
+        type = sprintf(_("Software %s"), device.level.toUpperCase());
+        break;
+      }
+      case "disk": {
+        if (device.sdCard) {
+          type = _("SD Card");
+        } else {
+          const technology = device.transport || device.bus;
+          type = technology
+            // TRANSLATORS: %s is substituted by the type of disk like "iSCSI" or "SATA"
+            ? sprintf(_("%s disk"), technology)
+            : _("Disk");
+        }
+      }
+    }
 
-    return (
-      <div>
-        <DeviceIcon />
-        <DeviceSize />
-      </div>
-    );
+    return <If condition={type} then={<div>{type}</div>} />;
   };
 
-  const ExtendedInfo = () => {
-    const DeviceName = () => {
-      if (device.name === undefined) return null;
-
-      return <div>{device.name}</div>;
-    };
+  const DeviceModel = () => {
+    if (!device.model || device.model === "") return null;
 
-    const DeviceType = () => {
-      let type;
+    return <div>{device.model}</div>;
+  };
 
-      switch (device.type) {
-        case "multipath": {
-          // TRANSLATORS: multipath device type
-          type = _("Multipath");
-          break;
-        }
-        case "dasd": {
-          // TRANSLATORS: %s is replaced by the device bus ID
-          type = sprintf(_("DASD %s"), device.busId);
-          break;
-        }
-        case "md": {
-          // TRANSLATORS: software RAID device, %s is replaced by the RAID level, e.g. RAID-1
-          type = sprintf(_("Software %s"), device.level.toUpperCase());
-          break;
-        }
-        case "disk": {
-          type = device.sdCard
-            ? _("SD Card")
-            // TRANSLATORS: %s is replaced by the device transport name, e.g. USB, SATA, SCSI...
-            : sprintf(_("Transport %s"), device.transport);
-        }
-      }
+  const MDInfo = () => {
+    if (device.type !== "md" || !device.members) return null;
 
-      return <If condition={type} then={<div>{type}</div>} />;
-    };
+    const members = device.members.map(m => m.split("/").at(-1));
 
-    const DeviceModel = () => {
-      if (!device.model || device.model === "") return null;
+    // TRANSLATORS: RAID details, %s is replaced by list of devices used by the array
+    return <div>{sprintf(_("Members: %s"), members.sort().join(", "))}</div>;
+  };
 
-      return <div>{device.model}</div>;
-    };
+  const RAIDInfo = () => {
+    if (device.type !== "raid") return null;
 
-    const MDInfo = () => {
-      if (device.type !== "md") return null;
+    const devices = device.devices.map(m => m.split("/").at(-1));
 
-      const members = device.members.map(m => m.split("/").at(-1));
+    // TRANSLATORS: RAID details, %s is replaced by list of devices used by the array
+    return <div>{sprintf(_("Devices: %s"), devices.sort().join(", "))}</div>;
+  };
 
-      // TRANSLATORS: RAID details, %s is replaced by list of devices used by the array
-      return <div>{sprintf(_("Members: %s"), members.sort().join(", "))}</div>;
-    };
+  const MultipathInfo = () => {
+    if (device.type !== "multipath") return null;
 
-    const RAIDInfo = () => {
-      if (device.type !== "raid") return null;
+    const wires = device.wires.map(m => m.split("/").at(-1));
 
-      const devices = device.devices.map(m => m.split("/").at(-1));
+    // TRANSLATORS: multipath details, %s is replaced by list of connections used by the device
+    return <div>{sprintf(_("Wires: %s"), wires.sort().join(", "))}</div>;
+  };
 
-      // TRANSLATORS: RAID details, %s is replaced by list of devices used by the array
-      return <div>{sprintf(_("Devices: %s"), devices.sort().join(", "))}</div>;
-    };
+  return (
+    <div>
+      <DeviceName />
+      <DeviceType />
+      <DeviceModel />
+      <MDInfo />
+      <RAIDInfo />
+      <MultipathInfo />
+    </div>
+  );
+};
 
-    const MultipathInfo = () => {
-      if (device.type !== "multipath") return null;
+const DeviceContentInfo = ({ device }) => {
+  const PTable = () => {
+    if (device.partitionTable === undefined) return null;
 
-      const wires = device.wires.map(m => m.split("/").at(-1));
+    const type = device.partitionTable.type.toUpperCase();
+    const numPartitions = device.partitionTable.partitions.length;
 
-      // TRANSLATORS: multipath details, %s is replaced by list of connections used by the device
-      return <div>{sprintf(_("Wires: %s"), wires.sort().join(", "))}</div>;
-    };
+    // TRANSLATORS: disk partition info, %s is replaced by partition table
+    // type (MS-DOS or GPT), %d is the number of the partitions
+    const text = sprintf(_("%s with %d partitions"), type, numPartitions);
 
     return (
       <div>
-        <DeviceName />
-        <DeviceType />
-        <DeviceModel />
-        <MDInfo />
-        <RAIDInfo />
-        <MultipathInfo />
+        <Icon name="folder" size="14" /> {text}
       </div>
     );
   };
 
-  const ContentInfo = () => {
-    const PTable = () => {
-      if (device.partitionTable === undefined) return null;
+  const Systems = () => {
+    if (!device.systems || device.systems.length === 0) return null;
 
-      const type = device.partitionTable.type.toUpperCase();
-      const numPartitions = device.partitionTable.partitions.length;
+    const System = ({ system }) => {
+      const logo = /windows/i.test(system) ? "windows_logo" : "linux_logo";
 
-      // TRANSLATORS: disk partition info, %s is replaced by partition table
-      // type (MS-DOS or GPT), %d is the number of the partitions
-      const text = sprintf(_("%s with %d partitions"), type, numPartitions);
-
-      return (
-        <div>
-          <Icon name="folder" size="14" /> {text}
-        </div>
-      );
+      return <div><Icon name={logo} size="14" /> {system}</div>;
     };
 
-    const Systems = () => {
-      if (device.systems.length === 0) return null;
-
-      const System = ({ system }) => {
-        const logo = /windows/i.test(system) ? "windows_logo" : "linux_logo";
-
-        return <div><Icon name={logo} size="14" /> {system}</div>;
-      };
+    return device.systems.map((s, i) => <System key={i} system={s} />);
+  };
 
-      return device.systems.map((s, i) => <System key={i} system={s} />);
-    };
+  // TODO: there is a lot of room for improvement here, but first we would need
+  // device.description (comes from YaST) to be way more granular
+  const Description = () => {
+    if (device.partitionTable) return null;
 
-    const NotFound = () => {
+    if (!device.sid || (!!device.model && device.model === device.description)) {
       // TRANSLATORS: status message, no existing content was found on the disk,
       // i.e. the disk is completely empty
       return <div><Icon name="folder_off" size="14" /> {_("No content found")}</div>;
+    }
+
+    return <div>{device.description} <FilesystemLabel device={device} /></div>;
+  };
+
+  return (
+    <div>
+      <PTable />
+      <Description />
+      <Systems />
+    </div>
+  );
+};
+
+/**
+ * Content for a device item
+ * @component
+ *
+ * @param {Object} props
+ * @param {StorageDevice} props.device
+ */
+const DeviceItem = ({ device }) => {
+  const BasicInfo = () => {
+    const DeviceIcon = () => {
+      const names = {
+        raid: "storage",
+        md: "storage"
+      };
+
+      const name = names[device.type] || "hard_drive";
+
+      return <Icon name={name} />;
     };
 
-    const hasContent = device.partitionTable || device.systems.length > 0;
+    const DeviceSize = () => {
+      if (device.size === undefined) return null;
+
+      return <div>{deviceSize(device.size)}</div>;
+    };
 
     return (
       <div>
-        <If
-          condition={hasContent}
-          then={<><PTable /><Systems /></>}
-          else={<NotFound />}
-        />
+        <DeviceIcon />
+        <DeviceSize />
       </div>
     );
   };
@@ -200,13 +214,15 @@ const DeviceItem = ({ device }) => {
   return (
     <div data-items-type="agama/storage-devices">
       <BasicInfo data-type="type-and-size" />
-      <ExtendedInfo />
-      <ContentInfo />
+      <DeviceExtendedInfo device={device} />
+      <DeviceContentInfo device={device} />
     </div>
   );
 };
 
 /**
+ * @todo This component is not used anymore. Remove it.
+ *
  * Component for listing storage devices.
  * @component
  *
@@ -232,6 +248,8 @@ const DeviceList = ({ devices, ...itemProps }) => {
 const renderDeviceOption = (device) => <DeviceItem device={device} />;
 
 /**
+ * @todo This component is not used anymore. Remove it.
+ *
  * Component for selecting storage devices.
  * @component
  *
@@ -266,4 +284,4 @@ const DeviceSelector = ({ devices, selected, isMultiple = false, onChange = noop
   );
 };
 
-export { DeviceList, DeviceSelector };
+export { DeviceList, DeviceSelector, DeviceContentInfo, DeviceExtendedInfo, FilesystemLabel };
diff --git a/web/src/components/storage/device-utils.test.jsx b/web/src/components/storage/device-utils.test.jsx
index 10e09e9058..45d5b6864d 100644
--- a/web/src/components/storage/device-utils.test.jsx
+++ b/web/src/components/storage/device-utils.test.jsx
@@ -143,6 +143,17 @@ const renderOptions = (Component) => {
       screen.getByText("Micron 1100 SATA");
     });
 
+    it("renders the partition table info", () => {
+      plainRender(<Component devices={[vda]} />);
+      screen.getByText("GPT with 2 partitions");
+    });
+
+    it("renders systems info", () => {
+      plainRender(<Component devices={[vda]} />);
+      screen.getByText("Windows 11");
+      screen.getByText("openSUSE Leap 15.2");
+    });
+
     describe("when device is a SDCard", () => {
       it("renders 'SD Card'", () => {
         const sdCard = { ...vda, sdCard: true };
@@ -151,26 +162,6 @@ const renderOptions = (Component) => {
       });
     });
 
-    describe("when content is given", () => {
-      it("renders the partition table info", () => {
-        plainRender(<Component devices={[vda]} />);
-        screen.getByText("GPT with 2 partitions");
-      });
-
-      it("renders systems info", () => {
-        plainRender(<Component devices={[vda]} />);
-        screen.getByText("Windows 11");
-        screen.getByText("openSUSE Leap 15.2");
-      });
-    });
-
-    describe("when content is not given", () => {
-      it("renders 'No content found'", () => {
-        plainRender(<Component devices={[multipath]} />);
-        screen.getByText("No content found");
-      });
-    });
-
     describe("when device is software RAID", () => {
       it("renders its level", () => {
         plainRender(<Component devices={[md0]} />);
diff --git a/web/src/components/storage/index.js b/web/src/components/storage/index.js
index 063d513dab..e16fd5df5e 100644
--- a/web/src/components/storage/index.js
+++ b/web/src/components/storage/index.js
@@ -34,5 +34,9 @@ export { default as DASDFormatProgress } from "./DASDFormatProgress";
 export { default as ZFCPPage } from "./ZFCPPage";
 export { default as ZFCPDiskForm } from "./ZFCPDiskForm";
 export { default as ISCSIPage } from "./ISCSIPage";
-export { DeviceList, DeviceSelector } from "./device-utils";
+export { DeviceList, DeviceSelector, DeviceContentInfo, DeviceExtendedInfo, FilesystemLabel } from "./device-utils";
 export { default as VolumeForm } from "./VolumeForm";
+export { default as BootSelectionDialog } from "./BootSelectionDialog";
+export { default as DeviceSelectionDialog } from "./DeviceSelectionDialog";
+export { default as DeviceSelectorTable } from "./DeviceSelectorTable";
+export { default as DevicesFormSelect } from "./DevicesFormSelect";