diff --git a/Assets/Samples/InGameHints/InGameHintsActions.cs b/Assets/Samples/InGameHints/InGameHintsActions.cs
index 43e50d0c9a..d33f1610de 100644
--- a/Assets/Samples/InGameHints/InGameHintsActions.cs
+++ b/Assets/Samples/InGameHints/InGameHintsActions.cs
@@ -1,7 +1,7 @@
 //------------------------------------------------------------------------------
 // <auto-generated>
 //     This code was auto-generated by com.unity.inputsystem:InputActionCodeGenerator
-//     version 1.11.3
+//     version 1.12.0
 //     from Assets/Samples/InGameHints/InGameHintsActions.inputactions
 //
 //     Changes to this file may cause incorrect behavior and will be lost if
diff --git a/Assets/Samples/SimpleDemo/SimpleControls.cs b/Assets/Samples/SimpleDemo/SimpleControls.cs
index 7499985262..8d761da00d 100644
--- a/Assets/Samples/SimpleDemo/SimpleControls.cs
+++ b/Assets/Samples/SimpleDemo/SimpleControls.cs
@@ -1,7 +1,7 @@
 //------------------------------------------------------------------------------
 // <auto-generated>
 //     This code was auto-generated by com.unity.inputsystem:InputActionCodeGenerator
-//     version 1.11.3
+//     version 1.12.0
 //     from Assets/Samples/SimpleDemo/SimpleControls.inputactions
 //
 //     Changes to this file may cause incorrect behavior and will be lost if
diff --git a/Assets/Samples/Visualizers/GamepadVis.prefab b/Assets/Samples/Visualizers/GamepadVis.prefab
index 5da149c674..5fe2262505 100644
--- a/Assets/Samples/Visualizers/GamepadVis.prefab
+++ b/Assets/Samples/Visualizers/GamepadVis.prefab
@@ -54,7 +54,7 @@ MonoBehaviour:
     width: 187.5
     height: 62.5
   m_Visualization: 1
-  m_ControlPath: <DualSenseGamepadHID>/touchpadButton
+  m_ControlPath: <DualShockGamepad>/touchpadButton
   m_ControlIndex: 0
 --- !u!1 &5430831073950378571
 GameObject:
diff --git a/Assets/Samples/Visualizers/GamepadVisualizer.unity b/Assets/Samples/Visualizers/GamepadVisualizer.unity
index 5db7272668..0e2a0b65ea 100644
--- a/Assets/Samples/Visualizers/GamepadVisualizer.unity
+++ b/Assets/Samples/Visualizers/GamepadVisualizer.unity
@@ -42,8 +42,7 @@ RenderSettings:
 --- !u!157 &3
 LightmapSettings:
   m_ObjectHideFlags: 0
-  serializedVersion: 13
-  m_BakeOnSceneLoad: 0
+  serializedVersion: 12
   m_GISettings:
     serializedVersion: 2
     m_BounceScale: 1
@@ -218,7 +217,7 @@ LightingSettings:
   m_PrefabInstance: {fileID: 0}
   m_PrefabAsset: {fileID: 0}
   m_Name: Settings.lighting
-  serializedVersion: 9
+  serializedVersion: 8
   m_EnableBakedLightmaps: 1
   m_EnableRealtimeLightmaps: 1
   m_RealtimeEnvironmentLighting: 1
@@ -272,6 +271,18 @@ LightingSettings:
   m_PVRFilteringAtrousPositionSigmaIndirect: 2
   m_PVRFilteringAtrousPositionSigmaAO: 1
   m_RespectSceneVisibilityWhenBakingGI: 0
+--- !u!114 &2122909276 stripped
+MonoBehaviour:
+  m_CorrespondingSourceObject: {fileID: 5802899217532024206, guid: b8429651427a640919754290f3704312,
+    type: 3}
+  m_PrefabInstance: {fileID: 5430831075364511436}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 0}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: 50c7363fac4d24ae8a679e3e8f1fa838, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
 --- !u!1001 &5430831075364511436
 PrefabInstance:
   m_ObjectHideFlags: 0
@@ -280,6 +291,86 @@ PrefabInstance:
     serializedVersion: 3
     m_TransformParent: {fileID: 0}
     m_Modifications:
+    - target: {fileID: 5430831073950378564, guid: b8429651427a640919754290f3704312,
+        type: 3}
+      propertyPath: m_UseCurrentDevice
+      value: 1
+      objectReference: {fileID: 0}
+    - target: {fileID: 5430831074071876626, guid: b8429651427a640919754290f3704312,
+        type: 3}
+      propertyPath: m_UseCurrentDevice
+      value: 1
+      objectReference: {fileID: 0}
+    - target: {fileID: 5430831074153646139, guid: b8429651427a640919754290f3704312,
+        type: 3}
+      propertyPath: m_UseCurrentDevice
+      value: 1
+      objectReference: {fileID: 0}
+    - target: {fileID: 5430831074316365814, guid: b8429651427a640919754290f3704312,
+        type: 3}
+      propertyPath: m_UseCurrentDevice
+      value: 1
+      objectReference: {fileID: 0}
+    - target: {fileID: 5430831074333637590, guid: b8429651427a640919754290f3704312,
+        type: 3}
+      propertyPath: m_UseCurrentDevice
+      value: 1
+      objectReference: {fileID: 0}
+    - target: {fileID: 5430831074406035310, guid: b8429651427a640919754290f3704312,
+        type: 3}
+      propertyPath: m_UseCurrentDevice
+      value: 1
+      objectReference: {fileID: 0}
+    - target: {fileID: 5430831074569589722, guid: b8429651427a640919754290f3704312,
+        type: 3}
+      propertyPath: m_UseCurrentDevice
+      value: 1
+      objectReference: {fileID: 0}
+    - target: {fileID: 5430831074657706043, guid: b8429651427a640919754290f3704312,
+        type: 3}
+      propertyPath: m_UseCurrentDevice
+      value: 1
+      objectReference: {fileID: 0}
+    - target: {fileID: 5430831074722065634, guid: b8429651427a640919754290f3704312,
+        type: 3}
+      propertyPath: m_UseCurrentDevice
+      value: 1
+      objectReference: {fileID: 0}
+    - target: {fileID: 5430831074890777048, guid: b8429651427a640919754290f3704312,
+        type: 3}
+      propertyPath: m_UseCurrentDevice
+      value: 1
+      objectReference: {fileID: 0}
+    - target: {fileID: 5430831074908778959, guid: b8429651427a640919754290f3704312,
+        type: 3}
+      propertyPath: m_UseCurrentDevice
+      value: 1
+      objectReference: {fileID: 0}
+    - target: {fileID: 5430831074960731594, guid: b8429651427a640919754290f3704312,
+        type: 3}
+      propertyPath: m_UseCurrentDevice
+      value: 1
+      objectReference: {fileID: 0}
+    - target: {fileID: 5430831075105443483, guid: b8429651427a640919754290f3704312,
+        type: 3}
+      propertyPath: m_UseCurrentDevice
+      value: 1
+      objectReference: {fileID: 0}
+    - target: {fileID: 5430831075159756558, guid: b8429651427a640919754290f3704312,
+        type: 3}
+      propertyPath: m_UseCurrentDevice
+      value: 1
+      objectReference: {fileID: 0}
+    - target: {fileID: 5430831075192722340, guid: b8429651427a640919754290f3704312,
+        type: 3}
+      propertyPath: m_UseCurrentDevice
+      value: 1
+      objectReference: {fileID: 0}
+    - target: {fileID: 5430831075336578713, guid: b8429651427a640919754290f3704312,
+        type: 3}
+      propertyPath: m_UseCurrentDevice
+      value: 1
+      objectReference: {fileID: 0}
     - target: {fileID: 5430831075476541849, guid: b8429651427a640919754290f3704312,
         type: 3}
       propertyPath: m_Name
@@ -335,6 +426,61 @@ PrefabInstance:
       propertyPath: m_LocalEulerAnglesHint.z
       value: 0
       objectReference: {fileID: 0}
+    - target: {fileID: 5430831075516136799, guid: b8429651427a640919754290f3704312,
+        type: 3}
+      propertyPath: m_UseCurrent
+      value: 1
+      objectReference: {fileID: 0}
+    - target: {fileID: 5430831075516136799, guid: b8429651427a640919754290f3704312,
+        type: 3}
+      propertyPath: m_UseCurrentDevice
+      value: 1
+      objectReference: {fileID: 0}
+    - target: {fileID: 5430831075516136799, guid: b8429651427a640919754290f3704312,
+        type: 3}
+      propertyPath: m_UseCurrentForControlIndex
+      value: 1
+      objectReference: {fileID: 0}
+    - target: {fileID: 5430831075640135793, guid: b8429651427a640919754290f3704312,
+        type: 3}
+      propertyPath: m_UseCurrentDevice
+      value: 1
+      objectReference: {fileID: 0}
+    - target: {fileID: 5430831075882524474, guid: b8429651427a640919754290f3704312,
+        type: 3}
+      propertyPath: m_UseCurrentDevice
+      value: 1
+      objectReference: {fileID: 0}
+    - target: {fileID: 5430831075888579014, guid: b8429651427a640919754290f3704312,
+        type: 3}
+      propertyPath: m_UseCurrentDevice
+      value: 1
+      objectReference: {fileID: 0}
+    - target: {fileID: 5430831075958221745, guid: b8429651427a640919754290f3704312,
+        type: 3}
+      propertyPath: m_UseCurrentDevice
+      value: 1
+      objectReference: {fileID: 0}
+    - target: {fileID: 5430831075990510060, guid: b8429651427a640919754290f3704312,
+        type: 3}
+      propertyPath: m_UseCurrentDevice
+      value: 1
+      objectReference: {fileID: 0}
+    - target: {fileID: 5802899217532024206, guid: b8429651427a640919754290f3704312,
+        type: 3}
+      propertyPath: m_Master
+      value: 
+      objectReference: {fileID: 2122909276}
+    - target: {fileID: 5802899217532024206, guid: b8429651427a640919754290f3704312,
+        type: 3}
+      propertyPath: m_UseCurrentDevice
+      value: 1
+      objectReference: {fileID: 0}
+    - target: {fileID: 6586345530156004295, guid: b8429651427a640919754290f3704312,
+        type: 3}
+      propertyPath: m_UseCurrentDevice
+      value: 1
+      objectReference: {fileID: 0}
     m_RemovedComponents: []
     m_RemovedGameObjects: []
     m_AddedGameObjects: []
diff --git a/Assets/Samples/Visualizers/InputControlVisualizer.cs b/Assets/Samples/Visualizers/InputControlVisualizer.cs
index 9a2950c7ab..d8be3a65d4 100644
--- a/Assets/Samples/Visualizers/InputControlVisualizer.cs
+++ b/Assets/Samples/Visualizers/InputControlVisualizer.cs
@@ -138,13 +138,30 @@ public int controlIndex
             + "which of the controls to visualize.")]
         [InputControl, SerializeField] private string m_ControlPath;
         [Tooltip("If multiple controls match 'Control Path' at runtime, this property decides "
-            + "which control to visualize from the list of candidates. It is a zero-based index.")]
+            + "which control to visualize from the list of candidates. It is a zero-based index. " +
+            "This is ignored if using current device instead.")]
         [SerializeField] private int m_ControlIndex;
 
+        [Tooltip("If set, ignores control index and maps a control of the current device (if it exist) or none.")]
+        [SerializeField] private bool m_UseCurrentDevice;
+
         [NonSerialized] private InputControl m_Control;
 
         private static List<InputControlVisualizer> s_EnabledInstances;
 
+        private static InputControl ResolveCurrentControl(InputControlList<InputControl> candidates)
+        {
+            // Only accept control that belongs to the current device of the same device type as candidate control device type.
+            foreach (var candidate in candidates)
+            {
+                var currentDevice = GetCurrentDevice(candidate.device);
+                if (candidate.device == currentDevice)
+                    return candidate;
+            }
+
+            return null;
+        }
+
         private void ResolveControl()
         {
             m_Control = null;
@@ -154,7 +171,9 @@ private void ResolveControl()
             using (var candidates = InputSystem.FindControls(m_ControlPath))
             {
                 var numCandidates = candidates.Count;
-                if (numCandidates > 1 && m_ControlIndex < numCandidates && m_ControlIndex >= 0)
+                if (m_UseCurrentDevice)
+                    m_Control = ResolveCurrentControl(candidates);
+                else if (numCandidates > 1 && m_ControlIndex < numCandidates && m_ControlIndex >= 0)
                     m_Control = candidates[m_ControlIndex];
                 else if (numCandidates > 0)
                     m_Control = candidates[0];
@@ -163,30 +182,52 @@ private void ResolveControl()
             SetupVisualizer();
         }
 
-        private void SetupVisualizer()
+        void Update()
         {
-            if (m_Control == null)
+            // There is currently no callback when current device changes so we will reattempt to resolve control
+            if (m_UseCurrentDevice)
             {
-                m_Visualizer = null;
-                return;
+                if (m_Control != null && m_Control.device != GetCurrentDevice(m_Control.device))
+                    m_Control = null;
+                if (m_Control == null)
+                    ResolveControl();
             }
+        }
 
-            switch (m_Visualization)
+        private static InputDevice GetCurrentDevice(InputDevice device)
+        {
+            if (device is Gamepad) return Gamepad.current;
+            if (device is Mouse) return Mouse.current;
+            if (device is Pen) return Pen.current;
+            if (device is Pointer) return Pointer.current; // should be last, because it's a base class for Mouse and Pen
+
+            throw new ArgumentException(
+                $"Expected device type that implements .current, but got '{device.name}' (deviceId: {device.deviceId}) instead ");
+        }
+
+        private static VisualizationHelpers.Visualizer CreateVisualizer(Mode mode, InputControl control, int historySamples)
+        {
+            switch (mode)
             {
                 case Mode.Value:
                 {
-                    var valueType = m_Control.valueType;
+                    // This visualization mode requires a control
+                    if (control == null)
+                        return null;
+
+                    VisualizationHelpers.Visualizer visualizer = null;
+                    var valueType = control.valueType;
                     if (valueType == typeof(Vector2))
-                        m_Visualizer = new VisualizationHelpers.Vector2Visualizer(m_HistorySamples);
+                        visualizer = new VisualizationHelpers.Vector2Visualizer(historySamples);
                     else if (valueType == typeof(float))
-                        m_Visualizer = new VisualizationHelpers.ScalarVisualizer<float>(m_HistorySamples)
+                        visualizer = new VisualizationHelpers.ScalarVisualizer<float>(historySamples)
                         {
                             ////TODO: pass actual min/max limits of control
                             limitMax = 1,
                             limitMin = 0
                         };
                     else if (valueType == typeof(int))
-                        m_Visualizer = new VisualizationHelpers.ScalarVisualizer<int>(m_HistorySamples)
+                        visualizer = new VisualizationHelpers.ScalarVisualizer<int>(historySamples)
                         {
                             ////TODO: pass actual min/max limits of control
                             limitMax = 1,
@@ -196,67 +237,66 @@ private void SetupVisualizer()
                     {
                         ////TODO: generic visualizer
                     }
-                    break;
+                    return visualizer;
                 }
 
                 case Mode.Events:
                 {
-                    var visualizer = new VisualizationHelpers.TimelineVisualizer(m_HistorySamples)
+                    var visualizer = new VisualizationHelpers.TimelineVisualizer(historySamples)
                     {
                         timeUnit = VisualizationHelpers.TimelineVisualizer.TimeUnit.Frames,
-                        historyDepth = m_HistorySamples,
+                        historyDepth = historySamples,
                         showLimits = true,
                         limitsY = new Vector2(0, 5) // Will expand upward automatically
                     };
-                    m_Visualizer = visualizer;
                     visualizer.AddTimeline("Events", Color.green,
                         VisualizationHelpers.TimelineVisualizer.PlotType.BarChart);
-                    break;
+                    return visualizer;
                 }
 
                 case Mode.MaximumLag:
                 {
-                    var visualizer = new VisualizationHelpers.TimelineVisualizer(m_HistorySamples)
+                    var visualizer = new VisualizationHelpers.TimelineVisualizer(historySamples)
                     {
                         timeUnit = VisualizationHelpers.TimelineVisualizer.TimeUnit.Frames,
-                        historyDepth = m_HistorySamples,
+                        historyDepth = historySamples,
                         valueUnit = new GUIContent("ms"),
                         showLimits = true,
                         limitsY = new Vector2(0, 6)
                     };
-                    m_Visualizer = visualizer;
                     visualizer.AddTimeline("MaxLag", Color.red,
                         VisualizationHelpers.TimelineVisualizer.PlotType.BarChart);
-                    break;
+                    return visualizer;
                 }
 
                 case Mode.Bytes:
                 {
-                    var visualizer = new VisualizationHelpers.TimelineVisualizer(m_HistorySamples)
+                    var visualizer = new VisualizationHelpers.TimelineVisualizer(historySamples)
                     {
                         timeUnit = VisualizationHelpers.TimelineVisualizer.TimeUnit.Frames,
                         valueUnit = new GUIContent("bytes"),
-                        historyDepth = m_HistorySamples,
+                        historyDepth = historySamples,
                         showLimits = true,
                         limitsY = new Vector2(0, 64)
                     };
-                    m_Visualizer = visualizer;
                     visualizer.AddTimeline("Bytes", Color.red,
                         VisualizationHelpers.TimelineVisualizer.PlotType.BarChart);
-                    break;
+                    return visualizer;
                 }
 
                 case Mode.DeviceCurrent:
-                {
-                    m_Visualizer = new VisualizationHelpers.CurrentDeviceVisualizer();
-                    break;
-                }
+                    return new VisualizationHelpers.CurrentDeviceVisualizer();
 
                 default:
-                    throw new NotImplementedException();
+                    throw new ArgumentOutOfRangeException(mode.ToString());
             }
         }
 
+        private void SetupVisualizer()
+        {
+            m_Visualizer = CreateVisualizer(m_Visualization, m_Control, m_HistorySamples);
+        }
+
         private static void OnDeviceChange(InputDevice device, InputDeviceChange change)
         {
             if (change != InputDeviceChange.Added && change != InputDeviceChange.Removed)
diff --git a/Assets/Tests/InputSystem.Editor/InputActionsEditorTests.cs b/Assets/Tests/InputSystem.Editor/InputActionsEditorTests.cs
index ffe160c38f..ce912230d2 100644
--- a/Assets/Tests/InputSystem.Editor/InputActionsEditorTests.cs
+++ b/Assets/Tests/InputSystem.Editor/InputActionsEditorTests.cs
@@ -58,6 +58,7 @@ IEnumerator WaitForActionMapRename(int index, bool isActive, double timeoutSecs
     #endregion
 
     [Test]
+    [Ignore("Instability, see ISXB-1284")]
     public void CanListActionMaps()
     {
         var actionMapsContainer = m_Window.rootVisualElement.Q("action-maps-container");
@@ -71,6 +72,7 @@ public void CanListActionMaps()
     }
 
     [UnityTest]
+    [Ignore("Instability, see ISXB-1284")]
     public IEnumerator CanCreateActionMap()
     {
         var button = m_Window.rootVisualElement.Q<Button>("add-new-action-map-button");
@@ -99,6 +101,7 @@ public IEnumerator CanCreateActionMap()
     }
 
     [UnityTest]
+    [Ignore("Instability, see ISXB-1284")]
     public IEnumerator CanRenameActionMap()
     {
         var actionMapsContainer = m_Window.rootVisualElement.Q("action-maps-container");
@@ -147,6 +150,7 @@ public IEnumerator CanRenameActionMap()
     }
 
     [UnityTest]
+    [Ignore("Instability, see ISXB-1284")]
     public IEnumerator CanDeleteActionMap()
     {
         var actionMapsContainer = m_Window.rootVisualElement.Q("action-maps-container");
diff --git a/Assets/Tests/InputSystem/CorePerformanceTests.cs b/Assets/Tests/InputSystem/CorePerformanceTests.cs
index 5d7d8ac230..86026ed313 100644
--- a/Assets/Tests/InputSystem/CorePerformanceTests.cs
+++ b/Assets/Tests/InputSystem/CorePerformanceTests.cs
@@ -1113,7 +1113,10 @@ public void Performance_OptimizedControls_ReadingPose4kTimes(OptimizationTestTyp
         "InputSystem.onAfterUpdate",
         "PreUpdate.NewInputUpdate",
         "PreUpdate.InputForUIUpdate",
-        "FixedUpdate.NewInputFixedUpdate"
+        "FixedUpdate.NewInputFixedUpdate",
+        "InputAction.Disable",
+        "InputAction.Enable",
+        "InputActionMap.ResolveBindings"
     };
 
     [PrebuildSetup(typeof(ProjectWideActionsBuildSetup))]
diff --git a/Assets/Tests/InputSystem/CoreTests_Actions.cs b/Assets/Tests/InputSystem/CoreTests_Actions.cs
index 0aa3d09fbe..02c7cc8fb6 100644
--- a/Assets/Tests/InputSystem/CoreTests_Actions.cs
+++ b/Assets/Tests/InputSystem/CoreTests_Actions.cs
@@ -319,22 +319,67 @@ public void Actions_WhenShortcutsEnabled_PressingShortcutSequenceInWrongOrder_Do
     [TestCase("leftShift", "leftAlt", "space", true)]
     [TestCase("leftShift", null, "space", false)]
     [TestCase("leftShift", "leftAlt", "space", false)]
-    public void Actions_PressingShortcutSequenceInWrongOrder_DoesNotTriggerShortcut_ExceptIfOverridden(string modifier1, string modifier2, string binding,
-        bool legacyComposites)
+    public void Actions_WhenShortcutsDisabled_PressingShortcutSequenceInWrongOrder_DoesNotTriggerShortcutIfOverridden(string modifier1, string modifier2, string binding, bool legacyComposites)
     {
         var keyboard = InputSystem.AddDevice<Keyboard>();
 
         var action = new InputAction();
         if (!string.IsNullOrEmpty(modifier2))
         {
-            action.AddCompositeBinding((legacyComposites ? "ButtonWithTwoModifiers" : "TwoModifiers") + "(overrideModifiersNeedToBePressedFirst)")
+            action.AddCompositeBinding((legacyComposites ? "ButtonWithTwoModifiers" : "TwoModifiers") + "(modifiersOrder=1)")
                 .With("Modifier1", "<Keyboard>/" + modifier1)
                 .With("Modifier2", "<Keyboard>/" + modifier2)
                 .With(legacyComposites ? "Button" : "Binding", "<Keyboard>/" + binding);
         }
         else
         {
-            action.AddCompositeBinding((legacyComposites ? "ButtonWithOneModifier" : "OneModifier") + "(overrideModifiersNeedToBePressedFirst)")
+            action.AddCompositeBinding((legacyComposites ? "ButtonWithOneModifier" : "OneModifier") + "(modifiersOrder=1)")
+                .With("Modifier", "<Keyboard>/" + modifier1)
+                .With(legacyComposites ? "Button" : "Binding", "<Keyboard>/" + binding);
+        }
+
+        action.Enable();
+
+        var wasPerformed = false;
+        action.performed += _ => wasPerformed = true;
+
+        // Press binding first, then modifiers.
+        Press((ButtonControl)keyboard[binding]);
+        Press((ButtonControl)keyboard[modifier1]);
+        if (!string.IsNullOrEmpty(modifier2))
+            Press((ButtonControl)keyboard[modifier2]);
+
+        Assert.That(wasPerformed, Is.False);
+    }
+
+    [Test]
+    [Category("Actions")]
+    [TestCase("leftShift", null, "space", true, true)]
+    [TestCase("leftShift", "leftAlt", "space", true, true)]
+    [TestCase("leftShift", null, "space", false, true)]
+    [TestCase("leftShift", "leftAlt", "space", false, true)]
+    [TestCase("leftShift", null, "space", true, false)]
+    [TestCase("leftShift", "leftAlt", "space", true, false)]
+    [TestCase("leftShift", null, "space", false, false)]
+    [TestCase("leftShift", "leftAlt", "space", false, false)]
+    public void Actions_WhenShortcutsAreEnabled_PressingShortcutSequenceInWrongOrder_DoesNotTriggerShortcut_ExceptIfOverridden(string modifier1, string modifier2, string binding,
+        bool legacyComposites, bool overrideModifiersNeedToBePressedFirst)
+    {
+        InputSystem.settings.shortcutKeysConsumeInput = true;
+
+        var keyboard = InputSystem.AddDevice<Keyboard>();
+
+        var action = new InputAction();
+        if (!string.IsNullOrEmpty(modifier2))
+        {
+            action.AddCompositeBinding((legacyComposites ? "ButtonWithTwoModifiers" : "TwoModifiers") + (overrideModifiersNeedToBePressedFirst ? "(overrideModifiersNeedToBePressedFirst)" : "(modifiersOrder=2)"))
+                .With("Modifier1", "<Keyboard>/" + modifier1)
+                .With("Modifier2", "<Keyboard>/" + modifier2)
+                .With(legacyComposites ? "Button" : "Binding", "<Keyboard>/" + binding);
+        }
+        else
+        {
+            action.AddCompositeBinding((legacyComposites ? "ButtonWithOneModifier" : "OneModifier") + (overrideModifiersNeedToBePressedFirst ? "(overrideModifiersNeedToBePressedFirst)" : "(modifiersOrder=2)"))
                 .With("Modifier", "<Keyboard>/" + modifier1)
                 .With(legacyComposites ? "Button" : "Binding", "<Keyboard>/" + binding);
         }
diff --git a/Assets/Tests/InputSystem/InputActionCodeGeneratorActions.cs b/Assets/Tests/InputSystem/InputActionCodeGeneratorActions.cs
index 3500da2666..45dab88203 100644
--- a/Assets/Tests/InputSystem/InputActionCodeGeneratorActions.cs
+++ b/Assets/Tests/InputSystem/InputActionCodeGeneratorActions.cs
@@ -1,7 +1,7 @@
 //------------------------------------------------------------------------------
 // <auto-generated>
 //     This code was auto-generated by com.unity.inputsystem:InputActionCodeGenerator
-//     version 1.11.3
+//     version 1.12.0
 //     from Assets/Tests/InputSystem/InputActionCodeGeneratorActions.inputactions
 //
 //     Changes to this file may cause incorrect behavior and will be lost if
diff --git a/Assets/Tests/InputSystem/Plugins/InputForUITests.cs b/Assets/Tests/InputSystem/Plugins/InputForUITests.cs
index 94662f7515..983703be7e 100644
--- a/Assets/Tests/InputSystem/Plugins/InputForUITests.cs
+++ b/Assets/Tests/InputSystem/Plugins/InputForUITests.cs
@@ -11,11 +11,9 @@
 using UnityEngine.TestTools;
 using UnityEngine.TestTools.Constraints;
 #if UNITY_EDITOR
-using UnityEditor;
 using UnityEngine.InputSystem.Editor;
 #endif
 using UnityEngine.InputSystem.Plugins.InputForUI;
-using UnityEngine.TestTools;
 using Event = UnityEngine.InputForUI.Event;
 using EventProvider = UnityEngine.InputForUI.EventProvider;
 using Is = NUnit.Framework.Is;
diff --git a/Assets/Tests/InputSystem/Plugins/PlayerInputTests.cs b/Assets/Tests/InputSystem/Plugins/PlayerInputTests.cs
index ece203817b..7bf1d5ee81 100644
--- a/Assets/Tests/InputSystem/Plugins/PlayerInputTests.cs
+++ b/Assets/Tests/InputSystem/Plugins/PlayerInputTests.cs
@@ -2405,6 +2405,39 @@ public void PlayerInput_CanDisableAfterAssigningAction_WithControlSchemesAndInte
         player.SetActive(false); // Should cause full rebinding and not assert
     }
 
+    [Test]
+    [Category("PlayerInput")]
+    public void PlayerInput_DelegatesAreUpdate_WhenActionMapAddedAfterAssignment()
+    {
+        var gamepad = InputSystem.AddDevice<Gamepad>();
+
+        var go = new GameObject();
+        var listener = go.AddComponent<MessageListener>();
+        var playerInput = go.AddComponent<PlayerInput>();
+        playerInput.defaultActionMap = "Other";
+        var actionAsset = InputActionAsset.FromJson(kActions);
+        playerInput.actions = actionAsset;
+
+        // Disable the asset while adding another action map to it as none
+        // of the actions in the asset can be enabled during modification
+        //
+        actionAsset.Disable();
+        var keyboard = InputSystem.AddDevice<Keyboard>();
+        var newActionMap = actionAsset.AddActionMap("NewMap");
+        var newAction = newActionMap.AddAction("NewAction");
+        newAction.AddBinding("<Keyboard>/k", groups: "Keyboard");
+        actionAsset.AddControlScheme("Keyboard").WithRequiredDevice<Keyboard>();
+        actionAsset.Enable();
+
+        playerInput.currentActionMap = newActionMap;
+        playerInput.ActivateInput();
+        listener.messages.Clear();
+
+        Press(keyboard.kKey);
+
+        Assert.That(listener.messages, Has.Exactly(1).With.Property("name").EqualTo("OnNewAction"));
+    }
+
     private struct Message : IEquatable<Message>
     {
         public string name { get; set; }
@@ -2477,6 +2510,11 @@ public void OnOtherAction(InputValue value)
             messages?.Add(new Message { name = "OnOtherAction", value = value.Get<float>() });
         }
 
+        public void OnNewAction(InputValue value)
+        {
+            messages?.Add(new Message { name = "OnNewAction", value = value.Get<float>() });
+        }
+
         // ReSharper disable once UnusedMember.Local
         public void OnActionWithSpaces(InputValue value)
         {
diff --git a/Assets/Tests/InputSystem/Plugins/UITests.cs b/Assets/Tests/InputSystem/Plugins/UITests.cs
index f098df98a6..1b94f75ab8 100644
--- a/Assets/Tests/InputSystem/Plugins/UITests.cs
+++ b/Assets/Tests/InputSystem/Plugins/UITests.cs
@@ -1793,6 +1793,7 @@ public IEnumerator UI_CanReleaseAndPressTouchesOnSameFrame()
                 .Matches((UICallbackReceiver.Event e) => e.pointerData.pointerType == UIPointerType.Touch).And
                 .Matches((UICallbackReceiver.Event e) => e.pointerData.position == secondPosition));
 
+#if UNITY_2021_2_OR_NEWER
         Assert.That(scene.rightChildReceiver.events,
             Has.Exactly(1).With.Property("type").EqualTo(EventType.PointerMove).And
                 .Matches((UICallbackReceiver.Event e) => e.pointerData.device == touchScreen).And
@@ -1800,6 +1801,7 @@ public IEnumerator UI_CanReleaseAndPressTouchesOnSameFrame()
                 .Matches((UICallbackReceiver.Event e) => e.pointerData.pointerId == pointerIdTouch2).And
                 .Matches((UICallbackReceiver.Event e) => e.pointerData.pointerType == UIPointerType.Touch).And
                 .Matches((UICallbackReceiver.Event e) => e.pointerData.position == secondPosition));
+#endif
 
         // Pointer 3
         Assert.That(scene.rightChildReceiver.events,
diff --git a/Packages/com.unity.inputsystem/CHANGELOG.md b/Packages/com.unity.inputsystem/CHANGELOG.md
index 07dc81f070..2a36143974 100644
--- a/Packages/com.unity.inputsystem/CHANGELOG.md
+++ b/Packages/com.unity.inputsystem/CHANGELOG.md
@@ -24,11 +24,26 @@ however, it has to be formatted properly to pass verification tests.
 - Fixed pasting bindings into empty Input Action asset. [ISXB-1180](https://issuetracker.unity3d.com/product/unity/issues/guid/ISXB-1180)
 - Fixed missing '&' symbol in Control Scheme dropdown on Windows platform. [ISXB-1109](https://issuetracker.unity3d.com/product/unity/issues/guid/ISXB-1109)
 - Fixed icon scaling in Input Actions window.
+- Fixed an issue where removing the InputSystem package could lead to invalid input handling settings.
 - Fixed `ArgumentOutOfRangeException` when adding a new Control Scheme with any Device selected. [ISXB-1129](https://issuetracker.unity3d.com/product/unity/issues/guid/ISXB-1129)
+- Fixed a CS0105 compiler warning due to duplicate using statement in test source code (ISXB-1247).
+- Fixed tooltip support in the UI Toolkit version of the Input Actions Asset editor.
+- Fixed documentation to clarify bindings with modifiers `overrideModifiersNeedToBePressedFirst` configuration [ISXB-806](https://issuetracker.unity3d.com/product/unity/issues/guid/ISXB-806).
+- Fixed an issue in `Samples/Visualizers/GamepadVisualizer.unity` sample where the visualization wouldn't handle device disconnects or current device changes properly (ISXB-1243).
+- Fixed an issue when displaying Serialized InputAction's Processor properties inside the Inspector window. [ISXB-1269](https://issuetracker.unity3d.com/product/unity/issues/guid/ISXB-1269)
+- Fixed an issue with default device selection when adding new Control Scheme.
+- Fixed an issue where action map delegates were not updated when the asset already assigned to the PlayerInput component were changed [ISXB-711](https://issuetracker.unity3d.com/product/unity/issues/guid/ISXB-711).
+- Fixed Action properties edition in the UI Toolkit version of the Input Actions Asset editor. [ISXB-1277](https://issuetracker.unity3d.com/product/unity/issues/guid/ISXB-1277)
 
 ### Changed
 - Added back the InputManager to InputSystem project-wide asset migration code with performance improvement (ISX-2086).
 - Changed `OnScreenControl` to automaticaly switch, in Single Player with autoswitch enabled, to the target device control scheme when the first component is enabled to prevent bad interactions when it start.
+- Changed paremeter `overrideModifiersNeedToBePressedFirst` to obsolete for `ButtonWithOneModifier`, `ButtonWithTwoModifiers`, `OneModifierComposite` and `TwoModifiersComposite` in favour the new `modifiersOrder` parameter which is more explicit.
+- Changed `Samples/Visualizers/GamepadVisualizer.unity` to visualize the control values of the current device instead of the first device.
+
+### Added
+- Added new API `InputSystem.settings.useIMGUIEditorForAssets` that should be used in custom `InputParameterEditor` that use both IMGUI and UI Toolkit.
+- Added ProfilerMakers to `InputAction.Enable()` and `InputActionMap.ResolveBindings()` to enable gathering of profiling data.
 
 ## [1.11.2] - 2024-10-16
 
@@ -58,6 +73,7 @@ however, it has to be formatted properly to pass verification tests.
 - Fixed potential crash on Mac when using stale references to deleted InputDevice objects [ISXB-606](https://issuetracker.unity3d.com/product/unity/issues/guid/ISXB-606).
 - Fixed conditional compilation for non-editor analytics on platforms not enabling analytics.
 - Fixed simulated touch input not working with PlayerInput component [ISXB-483](https://issuetracker.unity3d.com/product/unity/issues/guid/ISXB-483).
+- Fixed unused PenState information to determine the displayIndex on platforms providing it. (PLAT-10123)
 
 ### Changed
 - Renamed editor Resources directories to PackageResources to fix package validation warnings.
diff --git a/Packages/com.unity.inputsystem/DocCodeSamples.Tests.meta b/Packages/com.unity.inputsystem/DocCodeSamples.Tests.meta
new file mode 100644
index 0000000000..b137e3ae9b
--- /dev/null
+++ b/Packages/com.unity.inputsystem/DocCodeSamples.Tests.meta
@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: c0f26b555bfc14351a9f8ec342fd6ae8
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Packages/com.unity.inputsystem/DocCodeSamples.Tests/DocCodeSamples.asmdef b/Packages/com.unity.inputsystem/DocCodeSamples.Tests/DocCodeSamples.asmdef
new file mode 100644
index 0000000000..6e8b6248e1
--- /dev/null
+++ b/Packages/com.unity.inputsystem/DocCodeSamples.Tests/DocCodeSamples.asmdef
@@ -0,0 +1,18 @@
+{
+    "name": "Unity.InputSystem.DocCodeSamples",
+    "rootNamespace": "",
+    "references": [
+        "GUID:75469ad4d38634e559750d17036d5f7c"
+    ],
+    "includePlatforms": [
+        "Editor"
+    ],
+    "excludePlatforms": [],
+    "allowUnsafeCode": false,
+    "overrideReferences": true,
+    "precompiledReferences": [],
+    "autoReferenced": false,
+    "defineConstraints": [],
+    "versionDefines": [],
+    "noEngineReferences": false
+}
\ No newline at end of file
diff --git a/Packages/com.unity.inputsystem/DocCodeSamples.Tests/DocCodeSamples.asmdef.meta b/Packages/com.unity.inputsystem/DocCodeSamples.Tests/DocCodeSamples.asmdef.meta
new file mode 100644
index 0000000000..213c7c30d8
--- /dev/null
+++ b/Packages/com.unity.inputsystem/DocCodeSamples.Tests/DocCodeSamples.asmdef.meta
@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: 41b01d3964f844d8b43923c18b3a9a6f
+AssemblyDefinitionImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Packages/com.unity.inputsystem/DocCodeSamples.Tests/GamepadExample.cs b/Packages/com.unity.inputsystem/DocCodeSamples.Tests/GamepadExample.cs
new file mode 100644
index 0000000000..1ba384dd31
--- /dev/null
+++ b/Packages/com.unity.inputsystem/DocCodeSamples.Tests/GamepadExample.cs
@@ -0,0 +1,53 @@
+using UnityEngine;
+using UnityEngine.InputSystem;
+
+namespace DocCodeSamples.Tests
+{
+    internal class GamepadExample : MonoBehaviour
+    {
+        void Start()
+        {
+            // Print all connected gamepads
+            Debug.Log(string.Join("\n", Gamepad.all));
+        }
+
+        void Update()
+        {
+            var gamepad = Gamepad.current;
+
+            // No gamepad connected.
+            if (gamepad == null)
+            {
+                return;
+            }
+
+            // Check if "Button North" was pressed this frame
+            if (gamepad.buttonNorth.wasPressedThisFrame)
+            {
+                Debug.Log("Button North was pressed");
+            }
+
+            // Check if the button control is being continuously actuated and read its value
+            if (gamepad.rightTrigger.IsActuated())
+            {
+                Debug.Log("Right trigger value: " + gamepad.rightTrigger.ReadValue());
+            }
+
+            // Read left stick value and perform some code based on the value
+            Vector2 move = gamepad.leftStick.ReadValue();
+            {
+                // Use the Vector2 move for the game logic here
+            }
+
+            // Creating haptic feedback while "Button South" is pressed and stopping it when released.
+            if (gamepad.buttonSouth.wasPressedThisFrame)
+            {
+                gamepad.SetMotorSpeeds(0.2f, 1.0f);
+            }
+            else if (gamepad.buttonSouth.wasReleasedThisFrame)
+            {
+                gamepad.ResetHaptics();
+            }
+        }
+    }
+}
diff --git a/Packages/com.unity.inputsystem/DocCodeSamples.Tests/GamepadExample.cs.meta b/Packages/com.unity.inputsystem/DocCodeSamples.Tests/GamepadExample.cs.meta
new file mode 100644
index 0000000000..2b7c0d0a09
--- /dev/null
+++ b/Packages/com.unity.inputsystem/DocCodeSamples.Tests/GamepadExample.cs.meta
@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 898672c95e554f2fb492125d78b11af2
+timeCreated: 1733401360
\ No newline at end of file
diff --git a/Packages/com.unity.inputsystem/DocCodeSamples.Tests/GamepadHapticsExample.cs b/Packages/com.unity.inputsystem/DocCodeSamples.Tests/GamepadHapticsExample.cs
new file mode 100644
index 0000000000..b1c414641b
--- /dev/null
+++ b/Packages/com.unity.inputsystem/DocCodeSamples.Tests/GamepadHapticsExample.cs
@@ -0,0 +1,48 @@
+using UnityEngine;
+using UnityEngine.InputSystem;
+
+namespace DocCodeSamples.Tests
+{
+    internal class GamepadHapticsExample : MonoBehaviour
+    {
+        bool hapticsArePaused = false;
+
+        void Update()
+        {
+            var gamepad = Gamepad.current;
+
+            // No gamepad connected, no need to continue.
+            if (gamepad == null)
+                return;
+
+            float leftTrigger = gamepad.leftTrigger.ReadValue();
+            float rightTrigger = gamepad.rightTrigger.ReadValue();
+
+            // Only set motor speeds if haptics were not paused and if trigger is actuated.
+            // Both triggers must be actuated past 0.2f to start haptics.
+            if (!hapticsArePaused &&
+                (gamepad.leftTrigger.IsActuated() || gamepad.rightTrigger.IsActuated()))
+                gamepad.SetMotorSpeeds(
+                    leftTrigger < 0.2f ? 0.0f : leftTrigger,
+                    rightTrigger < 0.2f ? 0.0f : rightTrigger);
+
+            // Toggle haptics "playback" when "Button South" is pressed.
+            // Notice that if you release the triggers after pausing,
+            // and press the button again, haptics will resume.
+            if (gamepad.buttonSouth.wasPressedThisFrame)
+            {
+                if (hapticsArePaused)
+                    gamepad.ResumeHaptics();
+                else
+                    gamepad.PauseHaptics();
+
+                hapticsArePaused = !hapticsArePaused;
+            }
+
+            // Notice that if you release the triggers after pausing,
+            // and press the Start button, haptics will be reset.
+            if (gamepad.startButton.wasPressedThisFrame)
+                gamepad.ResetHaptics();
+        }
+    }
+}
diff --git a/Packages/com.unity.inputsystem/DocCodeSamples.Tests/GamepadHapticsExample.cs.meta b/Packages/com.unity.inputsystem/DocCodeSamples.Tests/GamepadHapticsExample.cs.meta
new file mode 100644
index 0000000000..42a614007b
--- /dev/null
+++ b/Packages/com.unity.inputsystem/DocCodeSamples.Tests/GamepadHapticsExample.cs.meta
@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 3bbc200178984676a2dcb977a2fe3bae
+timeCreated: 1733400387
\ No newline at end of file
diff --git a/Packages/com.unity.inputsystem/DocCodeSamples.Tests/InputSystemUIInputModuleAssignActionsExample.cs b/Packages/com.unity.inputsystem/DocCodeSamples.Tests/InputSystemUIInputModuleAssignActionsExample.cs
new file mode 100644
index 0000000000..886f1d61e8
--- /dev/null
+++ b/Packages/com.unity.inputsystem/DocCodeSamples.Tests/InputSystemUIInputModuleAssignActionsExample.cs
@@ -0,0 +1,42 @@
+#if UNITY_INPUT_SYSTEM_ENABLE_UI
+
+using UnityEngine;
+using UnityEngine.InputSystem.UI;
+
+namespace DocCodeSamples.Tests
+{
+    internal class InputSystemUIInputModuleAssignActionsExample : MonoBehaviour
+    {
+        // Reference to the InputSystemUIInputModule component, needs to be provided in the Inspector
+        public InputSystemUIInputModule uiModule;
+
+        void Start()
+        {
+            // Assign default actions
+            AssignActions();
+        }
+
+        void AssignActions()
+        {
+            if (uiModule != null)
+                uiModule.AssignDefaultActions();
+            else
+                Debug.LogError("InputSystemUIInputModule not found.");
+        }
+
+        void UnassignActions()
+        {
+            if (uiModule != null)
+                uiModule.UnassignActions();
+            else
+                Debug.LogError("InputSystemUIInputModule not found.");
+        }
+
+        void OnDestroy()
+        {
+            // Unassign actions when the object is destroyed
+            UnassignActions();
+        }
+    }
+}
+#endif
diff --git a/Packages/com.unity.inputsystem/DocCodeSamples.Tests/InputSystemUIInputModuleAssignActionsExample.cs.meta b/Packages/com.unity.inputsystem/DocCodeSamples.Tests/InputSystemUIInputModuleAssignActionsExample.cs.meta
new file mode 100644
index 0000000000..0dfa4a76f7
--- /dev/null
+++ b/Packages/com.unity.inputsystem/DocCodeSamples.Tests/InputSystemUIInputModuleAssignActionsExample.cs.meta
@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 026e1117180341c1bf7847a2cc61f75b
+timeCreated: 1733488542
\ No newline at end of file
diff --git a/Packages/com.unity.inputsystem/InputSystem/Actions/Composites/AxisComposite.cs b/Packages/com.unity.inputsystem/InputSystem/Actions/Composites/AxisComposite.cs
index 9c9074e406..48ae2a7c0e 100644
--- a/Packages/com.unity.inputsystem/InputSystem/Actions/Composites/AxisComposite.cs
+++ b/Packages/com.unity.inputsystem/InputSystem/Actions/Composites/AxisComposite.cs
@@ -220,7 +220,7 @@ internal class AxisCompositeEditor : InputParameterEditor<AxisComposite>
         public override void OnGUI()
         {
 #if UNITY_INPUT_SYSTEM_PROJECT_WIDE_ACTIONS
-            if (!InputSystem.settings.IsFeatureEnabled(InputFeatureNames.kUseIMGUIEditorForAssets)) return;
+            if (!InputSystem.settings.useIMGUIEditorForAssets) return;
 #endif
             target.whichSideWins = (AxisComposite.WhichSideWins)EditorGUILayout.EnumPopup(m_WhichAxisWinsLabel, target.whichSideWins);
         }
diff --git a/Packages/com.unity.inputsystem/InputSystem/Actions/Composites/ButtonWithOneModifier.cs b/Packages/com.unity.inputsystem/InputSystem/Actions/Composites/ButtonWithOneModifier.cs
index bca3936068..75d6f333a3 100644
--- a/Packages/com.unity.inputsystem/InputSystem/Actions/Composites/ButtonWithOneModifier.cs
+++ b/Packages/com.unity.inputsystem/InputSystem/Actions/Composites/ButtonWithOneModifier.cs
@@ -1,3 +1,4 @@
+using System;
 using System.ComponentModel;
 using UnityEngine.InputSystem.Layouts;
 using UnityEngine.InputSystem.Utilities;
@@ -79,16 +80,72 @@ public class ButtonWithOneModifier : InputBindingComposite<float>
         /// still trigger. Default is false.
         /// </summary>
         /// <remarks>
-        /// By default, <see cref="modifier"/> is required to be in pressed state before or at the same time that <see cref="button"/>
+        /// By default, if the setting <see cref="InputSettings.shortcutKeysConsumeInput"/> is enabled,
+        /// <see cref="modifier"/> is required to be in pressed state before or at the same time that <see cref="button"/>
         /// goes into pressed state for the composite as a whole to trigger. This means that binding to, for example, <c>Shift+B</c>,
         /// the <c>shift</c> key has to be pressed before pressing the <c>B</c> key. This is the behavior usually expected with
         /// keyboard shortcuts.
         ///
         /// This parameter can be used to bypass this behavior and allow any timing between <see cref="modifier"/> and <see cref="button"/>.
         /// The only requirement is for them both to concurrently be in pressed state.
+        ///
+        /// To don't depends on the setting please consider using <see cref="modifiersOrder"/> instead.
         /// </remarks>
+        [Tooltip("Obsolete please use modifiers Order. If enabled, this will override the Input Consumption setting, allowing the modifier keys to be pressed after the button and the composite will still trigger.")]
+        [Obsolete("Use ModifiersOrder.Unordered with 'modifiersOrder' instead")]
         public bool overrideModifiersNeedToBePressedFirst;
 
+        /// <summary>
+        /// Determines how a <c>modifiers</c> keys need to be pressed in order or not.
+        /// </summary>
+        public enum ModifiersOrder
+        {
+            /// <summary>
+            /// By default, if the setting <see cref="InputSettings.shortcutKeysConsumeInput"/> is enabled,
+            /// <see cref="modifier"/> is required to be in pressed state before or at the same time that <see cref="button"/>
+            /// goes into pressed state for the composite as a whole to trigger. This means that binding to, for example, <c>Shift+B</c>,
+            /// the <c>shift</c> key has to be pressed before pressing the <c>B</c> key. This is the behavior usually expected with
+            /// keyboard shortcuts.
+            ///
+            /// If the setting <see cref="InputSettings.shortcutKeysConsumeInput"/> is disabled,
+            /// modifiers can be pressed after the button and the composite will still trigger.
+            /// </summary>
+            Default = 0,
+
+            /// <summary>
+            /// <see cref="modifier"/> is required to be in pressed state before or at the same
+            /// time that <see cref="button"/> goes into pressed state for the composite as a whole to trigger. This means that binding to,
+            /// for example, <c>Ctrl+B</c>, the <c>ctrl</c> key have to be pressed before pressing the <c>B</c> key.
+            /// This is the behavior usually expected with keyboard shortcuts.
+            /// </summary>
+            Ordered = 1,
+
+            /// <summary>
+            /// <see cref="modifier"/> can be pressed after <see cref="button"/>
+            /// and the composite will still trigger. The only requirement is for all of them to concurrently be in pressed state.
+            /// </summary>
+            Unordered = 2
+        }
+
+        /// <summary>
+        /// If set to <c>Ordered</c> or <c>Unordered</c>, the built-in logic to determine if modifiers need to be pressed first is overridden.
+        /// </summary>
+        /// <remarks>
+        /// By default, if the setting <see cref="InputSettings.shortcutKeysConsumeInput"/> is enabled,
+        /// <see cref="modifier"/> is required to be in pressed state before or at the same time that <see cref="button"/>
+        /// goes into pressed state for the composite as a whole to trigger. This means that binding to, for example, <c>Shift+B</c>,
+        /// the <c>shift</c> key has to be pressed before pressing the <c>B</c> key. This is the behavior usually expected with
+        /// keyboard shortcuts.
+        ///
+        /// If the setting <see cref="InputSettings.shortcutKeysConsumeInput"/> is disabled,
+        /// modifiers can be pressed after the button and the composite will still trigger.
+        ///
+        /// This parameter can be used to bypass this behavior and enforce the timing order or allow any timing between <see cref="modifier"/> and <see cref="button"/>.
+        /// The only requirement is for them both to concurrently be in pressed state.
+        /// </remarks>
+        [Tooltip("By default it follows the Input Consumption setting to determine if the modifers keys need to be pressed first.")]
+        public ModifiersOrder modifiersOrder = ModifiersOrder.Default;
+
         /// <summary>
         /// Return the value of the <see cref="button"/> part if <see cref="modifier"/> is pressed. Otherwise
         /// return 0.
@@ -107,7 +164,7 @@ private bool ModifierIsPressed(ref InputBindingCompositeContext context)
         {
             var modifierDown = context.ReadValueAsButton(modifier);
 
-            if (modifierDown && !overrideModifiersNeedToBePressedFirst)
+            if (modifierDown && modifiersOrder == ModifiersOrder.Ordered)
             {
                 var timestamp = context.GetPressTime(button);
                 var timestamp1 = context.GetPressTime(modifier);
@@ -130,8 +187,17 @@ public override float EvaluateMagnitude(ref InputBindingCompositeContext context
 
         protected override void FinishSetup(ref InputBindingCompositeContext context)
         {
-            if (!overrideModifiersNeedToBePressedFirst)
-                overrideModifiersNeedToBePressedFirst = !InputSystem.settings.shortcutKeysConsumeInput;
+            if (modifiersOrder == ModifiersOrder.Default)
+            {
+                // Legacy. We need to reference the obsolete member here so temporarily
+                // turn off the warning.
+#pragma warning disable CS0618
+                if (overrideModifiersNeedToBePressedFirst)
+#pragma warning restore CS0618
+                    modifiersOrder = ModifiersOrder.Unordered;
+                else
+                    modifiersOrder = InputSystem.settings.shortcutKeysConsumeInput ? ModifiersOrder.Ordered : ModifiersOrder.Unordered;
+            }
         }
     }
 }
diff --git a/Packages/com.unity.inputsystem/InputSystem/Actions/Composites/ButtonWithTwoModifiers.cs b/Packages/com.unity.inputsystem/InputSystem/Actions/Composites/ButtonWithTwoModifiers.cs
index 3d930d07bc..fcce470071 100644
--- a/Packages/com.unity.inputsystem/InputSystem/Actions/Composites/ButtonWithTwoModifiers.cs
+++ b/Packages/com.unity.inputsystem/InputSystem/Actions/Composites/ButtonWithTwoModifiers.cs
@@ -1,3 +1,4 @@
+using System;
 using System.ComponentModel;
 using UnityEngine.InputSystem.Layouts;
 using UnityEngine.InputSystem.Utilities;
@@ -94,16 +95,71 @@ public class ButtonWithTwoModifiers : InputBindingComposite<float>
         /// and the composite will still trigger. Default is false.
         /// </summary>
         /// <remarks>
-        /// By default, <see cref="modifier1"/> and <see cref="modifier2"/> are required to be in pressed state before or at the same
+        /// By default, if the setting <see cref="InputSettings.shortcutKeysConsumeInput"/> is enabled,
+        /// <see cref="modifier1"/> and <see cref="modifier2"/> are required to be in pressed state before or at the same
         /// time that <see cref="button"/> goes into pressed state for the composite as a whole to trigger. This means that binding to,
-        /// for example, <c>Ctrl+Shift+B</c>, the <c>ctrl</c> <c>shift</c> keys have to be pressed before pressing the <c>B</c> key.
+        /// for example, <c>Ctrl+Shift+B</c>, the <c>ctrl</c> and <c>shift</c> keys have to be pressed, in any order,  before pressing the <c>B</c> key.
         /// This is the behavior usually expected with keyboard shortcuts.
         ///
         /// This parameter can be used to bypass this behavior and allow any timing between <see cref="modifier1"/>, <see cref="modifier2"/>,
         /// and <see cref="button"/>. The only requirement is for all of them to concurrently be in pressed state.
+        ///
+        /// To don't depends on the setting please consider using <see cref="modifiersOrder"/> instead.
         /// </remarks>
+        [Tooltip("Obsolete please use modifiers Order. If enabled, this will override the Input Consumption setting, allowing the modifier keys to be pressed after the button and the composite will still trigger.")]
+        [Obsolete("Use ModifiersOrder.Unordered with 'modifiersOrder' instead")]
         public bool overrideModifiersNeedToBePressedFirst;
 
+        /// <summary>
+        /// Determines how a <c>modifiers</c> keys need to be pressed in order or not.
+        /// </summary>
+        public enum ModifiersOrder
+        {
+            /// <summary>
+            /// By default, if the setting <see cref="InputSettings.shortcutKeysConsumeInput"/> is enabled,
+            /// <see cref="modifier1"/> and <see cref="modifier2"/> are required to be in pressed state before or at the same
+            /// time that <see cref="button"/> goes into pressed state for the composite as a whole to trigger. This means that binding to,
+            /// for example, <c>Ctrl+Shift+B</c>, the <c>ctrl</c> and <c>shift</c> keys have to be pressed, in any order, before pressing the <c>B</c> key.
+            /// This is the behavior usually expected with keyboard shortcuts.
+            ///
+            /// If the setting <see cref="InputSettings.shortcutKeysConsumeInput"/> is disabled,
+            /// modifiers can be pressed after the button and the composite will still trigger.
+            /// </summary>
+            Default = 0,
+
+            /// <summary>
+            /// <see cref="modifier1"/> and <see cref="modifier2"/> are required to be in pressed state before or at the same
+            /// time that <see cref="button"/> goes into pressed state for the composite as a whole to trigger. This means that binding to,
+            /// for example, <c>Ctrl+Shift+B</c>, the <c>ctrl</c> and <c>shift</c> keys have to be pressed, in any order,  before pressing the <c>B</c> key.
+            /// This is the behavior usually expected with keyboard shortcuts.
+            /// </summary>
+            Ordered = 1,
+
+            /// <summary>
+            /// <see cref="modifier1"/> and/or <see cref="modifier2"/> can be pressed after <see cref="button"/>
+            /// and the composite will still trigger. The only requirement is for all of them to concurrently be in pressed state.
+            /// </summary>
+            Unordered = 2
+        }
+
+        /// <summary>
+        /// If set to <c>Ordered</c> or <c>Unordered</c>, the built-in logic to determine if modifiers need to be pressed first is overridden.
+        /// </summary>
+        /// <remarks>
+        /// By default, if the setting <see cref="InputSettings.shortcutKeysConsumeInput"/> is enabled,
+        /// <see cref="modifier1"/> and <see cref="modifier2"/> are required to be in pressed state before or at the same
+        /// time that <see cref="button"/> goes into pressed state for the composite as a whole to trigger. This means that binding to,
+        /// for example, <c>Ctrl+Shift+B</c>, the <c>ctrl</c> and <c>shift</c> keys have to be pressed, in any order,  before pressing the <c>B</c> key.
+        /// This is the behavior usually expected with keyboard shortcuts.
+        ///
+        /// If the setting <see cref="InputSettings.shortcutKeysConsumeInput"/> is disabled,
+        /// modifiers can be pressed after the button and the composite will still trigger.
+        ///
+        /// This field allows you to explicitly override this default inference.
+        /// </remarks>
+        [Tooltip("By default it follows the Input Consumption setting to determine if the modifers keys need to be pressed first.")]
+        public ModifiersOrder modifiersOrder = ModifiersOrder.Default;
+
         /// <summary>
         /// Return the value of the <see cref="button"/> part while both <see cref="modifier1"/> and <see cref="modifier2"/>
         /// are pressed. Otherwise return 0.
@@ -122,7 +178,7 @@ private bool ModifiersArePressed(ref InputBindingCompositeContext context)
         {
             var modifiersDown = context.ReadValueAsButton(modifier1) && context.ReadValueAsButton(modifier2);
 
-            if (modifiersDown && !overrideModifiersNeedToBePressedFirst)
+            if (modifiersDown && modifiersOrder == ModifiersOrder.Ordered)
             {
                 var timestamp = context.GetPressTime(button);
                 var timestamp1 = context.GetPressTime(modifier1);
@@ -146,8 +202,17 @@ public override float EvaluateMagnitude(ref InputBindingCompositeContext context
 
         protected override void FinishSetup(ref InputBindingCompositeContext context)
         {
-            if (!overrideModifiersNeedToBePressedFirst)
-                overrideModifiersNeedToBePressedFirst = !InputSystem.settings.shortcutKeysConsumeInput;
+            if (modifiersOrder == ModifiersOrder.Default)
+            {
+                // Legacy. We need to reference the obsolete member here so temporarily
+                // turn off the warning.
+#pragma warning disable CS0618
+                if (overrideModifiersNeedToBePressedFirst)
+#pragma warning restore CS0618
+                    modifiersOrder = ModifiersOrder.Unordered;
+                else
+                    modifiersOrder = InputSystem.settings.shortcutKeysConsumeInput ? ModifiersOrder.Ordered : ModifiersOrder.Unordered;
+            }
         }
     }
 }
diff --git a/Packages/com.unity.inputsystem/InputSystem/Actions/Composites/OneModifierComposite.cs b/Packages/com.unity.inputsystem/InputSystem/Actions/Composites/OneModifierComposite.cs
index dfd7f6486b..15c720145b 100644
--- a/Packages/com.unity.inputsystem/InputSystem/Actions/Composites/OneModifierComposite.cs
+++ b/Packages/com.unity.inputsystem/InputSystem/Actions/Composites/OneModifierComposite.cs
@@ -88,7 +88,8 @@ public class OneModifierComposite : InputBindingComposite
         /// Default value is <c>false</c>.
         /// </summary>
         /// <remarks>
-        /// By default, if <see cref="binding"/> is bound to only <see cref="Controls.ButtonControl"/>s, then the composite requires
+        /// By default, if the setting <see cref="InputSettings.shortcutKeysConsumeInput"/> is enabled,
+        /// if <see cref="binding"/> is bound to only <see cref="Controls.ButtonControl"/>s, then the composite requires
         /// <see cref="modifier"/> to be pressed <em>before</em> pressing <see cref="binding"/>. This means that binding to, for example,
         /// <c>Ctrl+B</c>, the <c>ctrl</c> keys have to be pressed before pressing the <c>B</c> key. This is the behavior usually expected
         /// with keyboard shortcuts.
@@ -100,9 +101,69 @@ public class OneModifierComposite : InputBindingComposite
         /// This field allows you to explicitly override this default inference and make it so that regardless of what <see cref="binding"/>
         /// is bound to, any press sequence is acceptable. For the example binding to <c>Ctrl+B</c>, it would mean that pressing <c>B</c> and
         /// only then pressing <c>Ctrl</c> will still trigger the binding.
+        ///
+        /// To don't depends on the setting please consider using <see cref="modifiersOrder"/> instead.
         /// </remarks>
+        [Tooltip("Obsolete please use modifiers Order. If enabled, this will override the Input Consumption setting, allowing the modifier keys to be pressed after the button and the composite will still trigger.")]
+        [Obsolete("Use ModifiersOrder.Unordered with 'modifiersOrder' instead")]
         public bool overrideModifiersNeedToBePressedFirst;
 
+        /// <summary>
+        /// Determines how a <c>modifiers</c> keys need to be pressed in order or not.
+        /// </summary>
+        public enum ModifiersOrder
+        {
+            /// <summary>
+            /// By default, if the setting <see cref="InputSettings.shortcutKeysConsumeInput"/> is enabled,
+            /// if <see cref="binding"/> is bound to only <see cref="Controls.ButtonControl"/>s, then the composite requires
+            /// <see cref="modifier"/> to be pressed <em>before</em> pressing <see cref="binding"/>. This means that binding to, for example,
+            /// <c>Ctrl+B</c>, the <c>ctrl</c> keys have to be pressed before pressing the <c>B</c> key. This is the behavior usually expected
+            /// with keyboard shortcuts.
+            ///
+            /// If the setting <see cref="InputSettings.shortcutKeysConsumeInput"/> is disabled,
+            /// modifiers can be pressed after the button and the composite will still trigger.
+            /// </summary>
+            Default = 0,
+
+            /// <summary>
+            /// if <see cref="binding"/> is bound to only <see cref="Controls.ButtonControl"/>s, then the composite requires
+            /// <see cref="modifier"/> to be pressed <em>before</em> pressing <see cref="binding"/>. This means that binding to, for example,
+            /// <c>Ctrl+B</c>, the <c>ctrl</c> key have to be pressed before pressing the <c>B</c> key. This is the behavior usually expected
+            /// with keyboard shortcuts.
+            /// </summary>
+            Ordered = 1,
+
+            /// <summary>
+            /// <see cref="modifier"/> can be pressed after <see cref="binding"/>
+            /// and the composite will still trigger. The only requirement is for all of them to concurrently be in pressed state.
+            /// </summary>
+            Unordered = 2
+        }
+
+        /// <summary>
+        /// If set to <c>Ordered</c> or <c>Unordered</c>, the built-in logic to determine if modifiers need to be pressed first is overridden.
+        /// </summary>
+        /// <remarks>
+        /// By default, if the setting <see cref="InputSettings.shortcutKeysConsumeInput"/> is enabled,
+        /// if <see cref="binding"/> is bound to only <see cref="Controls.ButtonControl"/>s, then the composite requires
+        /// <see cref="modifier"/> to be pressed <em>before</em> pressing <see cref="binding"/>. This means that binding to, for example,
+        /// <c>Ctrl+B</c>, the <c>ctrl</c> keys have to be pressed before pressing the <c>B</c> key. This is the behavior usually expected
+        /// with keyboard shortcuts.
+        ///
+        /// If the setting <see cref="InputSettings.shortcutKeysConsumeInput"/> is disabled,
+        /// modifiers can be pressed after the button and the composite will still trigger.
+        ///
+        /// However, when binding, for example, <c>Ctrl+MouseDelta</c>, it should be possible to press <c>ctrl</c> at any time. The default
+        /// logic will automatically detect the difference between this binding and the button binding in the example above and behave
+        /// accordingly.
+        ///
+        /// This field allows you to explicitly override this default inference and make the order mandatory or make it so that regardless of what <see cref="binding"/>
+        /// is bound to, any press sequence is acceptable. For the example binding to <c>Ctrl+B</c>, it would mean that pressing <c>B</c> and
+        /// only then pressing <c>Ctrl</c> will still trigger the binding.
+        /// </remarks>
+        [Tooltip("By default it follows the Input Consumption setting to determine if the modifers keys need to be pressed first.")]
+        public ModifiersOrder modifiersOrder = ModifiersOrder.Default;
+
         private int m_ValueSizeInBytes;
         private Type m_ValueType;
         private bool m_BindingIsButton;
@@ -128,7 +189,7 @@ private bool ModifierIsPressed(ref InputBindingCompositeContext context)
             var modifierDown = context.ReadValueAsButton(modifier);
 
             // When the modifiers are gating a button, we require the modifiers to be pressed *first*.
-            if (modifierDown && m_BindingIsButton && !overrideModifiersNeedToBePressedFirst)
+            if (modifierDown && m_BindingIsButton && modifiersOrder == ModifiersOrder.Ordered)
             {
                 var timestamp = context.GetPressTime(binding);
                 var timestamp1 = context.GetPressTime(modifier);
@@ -144,8 +205,17 @@ protected override void FinishSetup(ref InputBindingCompositeContext context)
         {
             DetermineValueTypeAndSize(ref context, binding, out m_ValueType, out m_ValueSizeInBytes, out m_BindingIsButton);
 
-            if (!overrideModifiersNeedToBePressedFirst)
-                overrideModifiersNeedToBePressedFirst = !InputSystem.settings.shortcutKeysConsumeInput;
+            if (modifiersOrder == ModifiersOrder.Default)
+            {
+                // Legacy. We need to reference the obsolete member here so temporarily
+                // turn off the warning.
+#pragma warning disable CS0618
+                if (overrideModifiersNeedToBePressedFirst)
+#pragma warning restore CS0618
+                    modifiersOrder = ModifiersOrder.Unordered;
+                else
+                    modifiersOrder = InputSystem.settings.shortcutKeysConsumeInput ? ModifiersOrder.Ordered : ModifiersOrder.Unordered;
+            }
         }
 
         public override object ReadValueAsObject(ref InputBindingCompositeContext context)
diff --git a/Packages/com.unity.inputsystem/InputSystem/Actions/Composites/TwoModifiersComposite.cs b/Packages/com.unity.inputsystem/InputSystem/Actions/Composites/TwoModifiersComposite.cs
index b4f8d928d9..8044a628e4 100644
--- a/Packages/com.unity.inputsystem/InputSystem/Actions/Composites/TwoModifiersComposite.cs
+++ b/Packages/com.unity.inputsystem/InputSystem/Actions/Composites/TwoModifiersComposite.cs
@@ -90,9 +90,10 @@ public class TwoModifiersComposite : InputBindingComposite
         /// Default value is <c>false</c>.
         /// </summary>
         /// <remarks>
-        /// By default, if <see cref="binding"/> is bound to only <see cref="Controls.ButtonControl"/>s, then the composite requires
+        /// By default, if the setting <see cref="InputSettings.shortcutKeysConsumeInput"/> is enabled,
+        /// if <see cref="binding"/> is bound to only <see cref="Controls.ButtonControl"/>s, then the composite requires
         /// both <see cref="modifier1"/> and <see cref="modifier2"/> to be pressed <em>before</em> pressing <see cref="binding"/>.
-        /// This means that binding to, for example, <c>Ctrl+Shift+B</c>, the <c>ctrl</c> and <c>shift</c> keys have to be pressed
+        /// This means that binding to, for example, <c>Ctrl+Shift+B</c>, the <c>ctrl</c> and <c>shift</c> keys have to be pressed, in any order,
         /// before pressing the <c>B</c> key. This is the behavior usually expected with keyboard shortcuts.
         ///
         /// However, when binding, for example, <c>Ctrl+Shift+MouseDelta</c>, it should be possible to press <c>ctrl</c> and <c>shift</c>
@@ -102,9 +103,66 @@ public class TwoModifiersComposite : InputBindingComposite
         /// This field allows you to explicitly override this default inference and make it so that regardless of what <see cref="binding"/>
         /// is bound to, any press sequence is acceptable. For the example binding to <c>Ctrl+Shift+B</c>, it would mean that pressing
         /// <c>B</c> and only then pressing <c>Ctrl</c> and <c>Shift</c> will still trigger the binding.
+        ///
+        /// To don't depends on the setting please consider using <see cref="modifiersOrder"/> instead.
         /// </remarks>
+        [Tooltip("Obsolete please use modifiers Order. If enabled, this will override the Input Consumption setting, allowing the modifier keys to be pressed after the button and the composite will still trigger.")]
+        [Obsolete("Use ModifiersOrder.Unordered with 'modifiersOrder' instead")]
         public bool overrideModifiersNeedToBePressedFirst;
 
+        /// <summary>
+        /// Determines how a <c>modifiers</c> keys need to be pressed in order or not.
+        /// </summary>
+        public enum ModifiersOrder
+        {
+            /// <summary>
+            /// By default, if the setting <see cref="InputSettings.shortcutKeysConsumeInput"/> is enabled,
+            /// if <see cref="binding"/> is bound to only <see cref="Controls.ButtonControl"/>s, then the composite requires
+            /// both <see cref="modifier1"/> and <see cref="modifier2"/> to be pressed <em>before</em> pressing <see cref="binding"/>.
+            /// This means that binding to, for example, <c>Ctrl+Shift+B</c>, the <c>ctrl</c> and <c>shift</c> keys have to be pressed, in any order,
+            /// before pressing the <c>B</c> key. This is the behavior usually expected with keyboard shortcuts.
+            ///
+            /// If the setting <see cref="InputSettings.shortcutKeysConsumeInput"/> is disabled,
+            /// modifiers can be pressed after the button and the composite will still trigger.
+            /// </summary>
+            Default = 0,
+
+            /// <summary>
+            /// if <see cref = "binding" /> is bound to only <see cref = "Controls.ButtonControl" /> s, then the composite requires
+            /// both <see cref="modifier1"/> and <see cref="modifier2"/> to be pressed <em>before</em> pressing <see cref="binding"/>.
+            /// This means that binding to, for example, <c>Ctrl+Shift+B</c>, the <c>ctrl</c> and <c>shift</c> keys have to be pressed, in any order,
+            /// before pressing the <c>B</c> key. This is the behavior usually expected with keyboard shortcuts.
+            /// </summary>
+            Ordered = 1,
+
+            /// <summary>
+            /// <see cref="modifier1"/> and/or <see cref="modifier2"/> can be pressed after <see cref="binding"/>
+            /// and the composite will still trigger. The only requirement is for all of them to concurrently be in pressed state.
+            /// </summary>
+            Unordered = 2
+        }
+
+        /// <summary>
+        /// If set to <c>Ordered</c> or <c>Unordered</c>, the built-in logic to determine if modifiers need to be pressed first is overridden.
+        /// </summary>
+        /// <remarks>
+        /// By default, if the setting <see cref="InputSettings.shortcutKeysConsumeInput"/> is enabled,
+        /// if <see cref="binding"/> is bound to only <see cref="Controls.ButtonControl"/>s, then the composite requires
+        /// both <see cref="modifier1"/> and <see cref="modifier2"/> to be pressed <em>before</em> pressing <see cref="binding"/>.
+        /// This means that binding to, for example, <c>Ctrl+Shift+B</c>, the <c>ctrl</c> and <c>shift</c> keys have to be pressed, in any order,
+        /// before pressing the <c>B</c> key. This is the behavior usually expected with keyboard shortcuts.
+        ///
+        /// If the setting <see cref="InputSettings.shortcutKeysConsumeInput"/> is disabled,
+        /// modifiers can be pressed after the button and the composite will still trigger.
+        ///
+        /// This field allows you to explicitly override this default inference and make the order mandatory or make it so that regardless of what <see cref="binding"/>
+        /// is bound to, any press sequence is acceptable. For the example binding to <c>Ctrl+Shift+B</c>, it would mean that pressing
+        /// <c>B</c> and only then pressing <c>Ctrl</c> and <c>Shift</c> will still trigger the binding.
+        ///
+        /// </remarks>
+        [Tooltip("By default it follows the Input Consumption setting to determine if the modifers keys need to be pressed first.")]
+        public ModifiersOrder modifiersOrder = ModifiersOrder.Default;
+
         /// <summary>
         /// Type of values read from controls bound to <see cref="binding"/>.
         /// </summary>
@@ -140,7 +198,7 @@ private bool ModifiersArePressed(ref InputBindingCompositeContext context)
             var modifiersDown = context.ReadValueAsButton(modifier1) && context.ReadValueAsButton(modifier2);
 
             // When the modifiers are gating a button, we require the modifiers to be pressed *first*.
-            if (modifiersDown && m_BindingIsButton && !overrideModifiersNeedToBePressedFirst)
+            if (modifiersDown && m_BindingIsButton && modifiersOrder == ModifiersOrder.Ordered)
             {
                 var timestamp = context.GetPressTime(binding);
                 var timestamp1 = context.GetPressTime(modifier1);
@@ -157,8 +215,17 @@ protected override void FinishSetup(ref InputBindingCompositeContext context)
         {
             OneModifierComposite.DetermineValueTypeAndSize(ref context, binding, out m_ValueType, out m_ValueSizeInBytes, out m_BindingIsButton);
 
-            if (!overrideModifiersNeedToBePressedFirst)
-                overrideModifiersNeedToBePressedFirst = !InputSystem.settings.shortcutKeysConsumeInput;
+            if (modifiersOrder == ModifiersOrder.Default)
+            {
+                // Legacy. We need to reference the obsolete member here so temporarily
+                // turn off the warning.
+#pragma warning disable CS0618
+                if (overrideModifiersNeedToBePressedFirst)
+#pragma warning restore CS0618
+                    modifiersOrder = ModifiersOrder.Unordered;
+                else
+                    modifiersOrder = InputSystem.settings.shortcutKeysConsumeInput ? ModifiersOrder.Ordered : ModifiersOrder.Unordered;
+            }
         }
 
         public override object ReadValueAsObject(ref InputBindingCompositeContext context)
diff --git a/Packages/com.unity.inputsystem/InputSystem/Actions/Composites/Vector2Composite.cs b/Packages/com.unity.inputsystem/InputSystem/Actions/Composites/Vector2Composite.cs
index dd7a462628..2f970dda8b 100644
--- a/Packages/com.unity.inputsystem/InputSystem/Actions/Composites/Vector2Composite.cs
+++ b/Packages/com.unity.inputsystem/InputSystem/Actions/Composites/Vector2Composite.cs
@@ -145,7 +145,7 @@ public override Vector2 ReadValue(ref InputBindingCompositeContext context)
             var rightIsPressed = context.ReadValueAsButton(right);
 
             // Legacy. We need to reference the obsolete member here so temporarily
-            // turn of the warning.
+            // turn off the warning.
             #pragma warning disable CS0618
             if (!normalize) // Was on by default.
                 mode = Mode.Digital;
@@ -200,7 +200,7 @@ internal class Vector2CompositeEditor : InputParameterEditor<Vector2Composite>
         public override void OnGUI()
         {
 #if UNITY_INPUT_SYSTEM_PROJECT_WIDE_ACTIONS
-            if (!InputSystem.settings.IsFeatureEnabled(InputFeatureNames.kUseIMGUIEditorForAssets)) return;
+            if (!InputSystem.settings.useIMGUIEditorForAssets) return;
 #endif
             target.mode = (Vector2Composite.Mode)EditorGUILayout.EnumPopup(m_ModeLabel, target.mode);
         }
diff --git a/Packages/com.unity.inputsystem/InputSystem/Actions/Composites/Vector3Composite.cs b/Packages/com.unity.inputsystem/InputSystem/Actions/Composites/Vector3Composite.cs
index 0e2626e4b1..d9a0e510c4 100644
--- a/Packages/com.unity.inputsystem/InputSystem/Actions/Composites/Vector3Composite.cs
+++ b/Packages/com.unity.inputsystem/InputSystem/Actions/Composites/Vector3Composite.cs
@@ -180,7 +180,7 @@ internal class Vector3CompositeEditor : InputParameterEditor<Vector3Composite>
         public override void OnGUI()
         {
 #if UNITY_INPUT_SYSTEM_PROJECT_WIDE_ACTIONS
-            if (!InputSystem.settings.IsFeatureEnabled(InputFeatureNames.kUseIMGUIEditorForAssets)) return;
+            if (!InputSystem.settings.useIMGUIEditorForAssets) return;
 #endif
             target.mode = (Vector3Composite.Mode)EditorGUILayout.EnumPopup(m_ModeLabel, target.mode);
         }
diff --git a/Packages/com.unity.inputsystem/InputSystem/Actions/InputAction.cs b/Packages/com.unity.inputsystem/InputSystem/Actions/InputAction.cs
index 4b025827ef..d4c1dd41d5 100644
--- a/Packages/com.unity.inputsystem/InputSystem/Actions/InputAction.cs
+++ b/Packages/com.unity.inputsystem/InputSystem/Actions/InputAction.cs
@@ -1,5 +1,6 @@
 using System;
 using Unity.Collections.LowLevel.Unsafe;
+using Unity.Profiling;
 using UnityEngine.InputSystem.Controls;
 using UnityEngine.InputSystem.LowLevel;
 using UnityEngine.InputSystem.Utilities;
@@ -681,6 +682,12 @@ public bool wantsInitialStateCheck
             }
         }
 
+        /// <summary>
+        /// ProfilerMarker for measuring the enabling/disabling of InputActions.
+        /// </summary>
+        static readonly ProfilerMarker k_InputActionEnableProfilerMarker = new ProfilerMarker("InputAction.Enable");
+        static readonly ProfilerMarker k_InputActionDisableProfilerMarker = new ProfilerMarker("InputAction.Disable");
+
         /// <summary>
         /// Construct an unnamed, free-standing action that is not part of any map or asset
         /// and has no bindings. Bindings can be added with <see
@@ -899,18 +906,21 @@ public override string ToString()
         /// <seealso cref="enabled"/>
         public void Enable()
         {
-            if (enabled)
-                return;
+            using (k_InputActionEnableProfilerMarker.Auto())
+            {
+                if (enabled)
+                    return;
 
-            // For singleton actions, we create an internal-only InputActionMap
-            // private to the action.
-            var map = GetOrCreateActionMap();
+                // For singleton actions, we create an internal-only InputActionMap
+                // private to the action.
+                var map = GetOrCreateActionMap();
 
-            // First time we're enabled, find all controls.
-            map.ResolveBindingsIfNecessary();
+                // First time we're enabled, find all controls.
+                map.ResolveBindingsIfNecessary();
 
-            // Go live.
-            map.m_State.EnableSingleAction(this);
+                // Go live.
+                map.m_State.EnableSingleAction(this);
+            }
         }
 
         /// <summary>
@@ -928,10 +938,13 @@ public void Enable()
         /// <seealso cref="Enable"/>
         public void Disable()
         {
-            if (!enabled)
-                return;
+            using (k_InputActionDisableProfilerMarker.Auto())
+            {
+                if (!enabled)
+                    return;
 
-            m_ActionMap.m_State.DisableSingleAction(this);
+                m_ActionMap.m_State.DisableSingleAction(this);
+            }
         }
 
         ////REVIEW: is *not* cloning IDs here really the right thing to do?
@@ -1075,19 +1088,22 @@ public unsafe object ReadValueAsObject()
         /// <returns>Returns the current level of control actuation (usually [0..1]) or -1 if
         /// the control is actuated but does not support computing magnitudes.</returns>
         /// <remarks>
+        /// <para>
         /// Magnitudes do not make sense for all types of controls. Controls that have no meaningful magnitude
         /// will return -1 when calling this method. Any negative magnitude value should be considered an invalid value.
-        /// <br />
+        /// </para>
+        /// <para>
         /// The magnitude returned by an action is usually determined by the
         /// <see cref="InputControl"/> that triggered the action, i.e. by the
-        /// control referenced from <see cref="activeControl"/>.
-        /// <br />
+        /// control referenced from <see cref="activeControl"/>. See <see cref="InputControl.EvaluateMagnitude()"/> and
+        /// <see cref="InputBindingComposite.EvaluateMagnitude"/> for additional information.
+        /// </para>
+        /// <para>
         /// However, if the binding that triggered is a composite, then the composite
         /// will determine the magnitude and not the individual control that triggered.
         /// Instead, the value of the control that triggered the action will be fed into the composite magnitude calculation.
+        /// </para>
         /// </remarks>
-        /// <seealso cref="InputControl.EvaluateMagnitude()"/>
-        /// <seealso cref="InputBindingComposite.EvaluateMagnitude"/>
         public unsafe float GetControlMagnitude()
         {
             var state = GetOrCreateActionMap().m_State;
@@ -1366,13 +1382,16 @@ public unsafe bool WasPerformedThisFrame()
         /// </summary>
         /// <returns>True if the action completed this frame.</returns>
         /// <remarks>
+        /// <para>
         /// Although <see cref="InputActionPhase.Disabled"/> is technically a phase, this method does not consider disabling
         /// the action while the action is in <see cref="InputActionPhase.Performed"/> to be "completed".
-        ///
+        /// </para>
+        /// <para>
         /// This method is different from <see cref="WasReleasedThisFrame"/> in that it depends directly on the
         /// interaction(s) driving the action (including the default interaction if no specific interaction
         /// has been added to the action or binding).
-        ///
+        /// </para>
+        /// <para>
         /// For example, let's say the action is bound to the space bar and that the binding has a
         /// <see cref="Interactions.HoldInteraction"/> assigned to it. In the frame where the space bar
         /// is pressed, <see cref="WasPressedThisFrame"/> will be true (because the button/key is now pressed)
@@ -1383,7 +1402,8 @@ public unsafe bool WasPerformedThisFrame()
         /// the phase will change to and stay <see cref="InputActionPhase.Performed"/> and <see cref="WasPerformedThisFrame"/>
         /// will be true for one frame as it meets the duration threshold. Once released, <c>WasCompletedThisFrame</c> will be true
         /// (because the action is no longer performed) and only in the frame where the hold transitioned away from Performed.
-        ///
+        /// </para>
+        /// <para>
         /// For another example where the action could be considered pressed but also completed, let's say the action
         /// is bound to the thumbstick and that the binding has a Sector interaction from the XR Interaction Toolkit assigned
         /// to it such that it only performs in the forward sector area past a button press threshold. In the frame where the
@@ -1395,11 +1415,21 @@ public unsafe bool WasPerformedThisFrame()
         /// the thumbstick was no longer within the forward sector. For more details about the Sector interaction, see
         /// <a href="https://docs.unity3d.com/Packages/com.unity.xr.interaction.toolkit@2.5/api/UnityEngine.XR.Interaction.Toolkit.Inputs.Interactions.SectorInteraction.html"><c>SectorInteraction</c></a>
         /// in the XR Interaction Toolkit Scripting API documentation.
-        /// <br />
+        /// </para>
+        /// <para>
         /// Unlike <see cref="ReadValue{TValue}"/>, which will reset when the action goes back to waiting
         /// state, this property will stay true for the duration of the current frame (that is, until the next
         /// <see cref="InputSystem.Update"/> runs) as long as the action was completed at least once.
-        ///
+        /// </para>
+        /// <para>
+        /// This method will disregard whether the action is currently enabled or disabled. It will keep returning
+        /// true for the duration of the frame even if the action was subsequently disabled in the frame.
+        /// </para>
+        /// <para>
+        /// The meaning of "frame" is either the current "dynamic" update (<c>MonoBehaviour.Update</c>) or the current
+        /// fixed update (<c>MonoBehaviour.FixedUpdate</c>) depending on the value of the <see cref="InputSettings.updateMode"/> setting.
+        /// </para>
+        /// </remarks>
         /// <example>
         /// <code>
         /// var teleport = playerInput.actions["Teleport"];
@@ -1409,13 +1439,6 @@ public unsafe bool WasPerformedThisFrame()
         ///     StopTeleport();
         /// </code>
         /// </example>
-        ///
-        /// This method will disregard whether the action is currently enabled or disabled. It will keep returning
-        /// true for the duration of the frame even if the action was subsequently disabled in the frame.
-        ///
-        /// The meaning of "frame" is either the current "dynamic" update (<c>MonoBehaviour.Update</c>) or the current
-        /// fixed update (<c>MonoBehaviour.FixedUpdate</c>) depending on the value of the <see cref="InputSettings.updateMode"/> setting.
-        /// </remarks>
         /// <seealso cref="WasPerformedThisFrame"/>
         /// <seealso cref="WasReleasedThisFrame"/>
         /// <seealso cref="phase"/>
@@ -1791,8 +1814,88 @@ internal int BindingIndexOnMapToBindingIndexOnAction(int indexOfBindingOnMap)
         /// Information provided to action callbacks about what triggered an action.
         /// </summary>
         /// <remarks>
-        /// This struct should not be held on to past the duration of the callback.
+        /// <para>
+        /// The callback context represents the current state of an <see cref="action"/> associated with the callback
+        /// and provides information associated with the bound <see cref="control"/>, its value, and its
+        /// <see cref="phase"/>.
+        /// </para>
+        /// <para>
+        /// The callback context provides you with a way to consume events (push-based input) as part of an update when using
+        /// input action callback notifications. For example, <see cref="InputAction.started"/>,
+        /// <see cref="InputAction.performed"/>, <see cref="InputAction.canceled"/> rather than relying on
+        /// pull-based reading. Also see <a href="https://docs.unity3d.com/Packages/com.unity.inputsystem@1.11/manual/RespondingToActions.html">
+        /// Responding To Actions</a> for additional information on differences between callbacks and polling.
+        /// </para>
+        /// <para>
+        /// Use this struct to read the current input value through any of the read-method overloads:
+        /// <see cref="ReadValue{T}()"/>, <see cref="ReadValueAsButton"/>,
+        /// <see cref="ReadValueAsObject()"/> or <see cref="ReadValue"/> (unsafe). If you don't know the expected value type,
+        /// you might need to check <see cref="valueType"/> before reading the value.
+        /// </para>
+        /// <para>
+        /// Use the <see cref="phase"/> property to get the current phase of the associated action or
+        /// evaluate it directly using any of the convenience methods <see cref="started"/>, <see cref="performed"/>,
+        /// <see cref="canceled"/>.
+        /// </para>
+        /// <para>
+        /// To obtain information about the current timestamp of the associated event, or to check when the event
+        /// started, use <see cref="time"/> or <see cref="startTime"/> respectively.
+        /// </para>
+        /// <para>
+        /// You should not use or keep this struct outside of the callback.
+        /// </para>
         /// </remarks>
+        /// <example>
+        /// <code>
+        /// using UnityEngine;
+        /// using UnityEngine.InputSystem;
+        /// using UnityEngine.InputSystem.Interactions;
+        ///
+        /// public class MyController : MonoBehaviour
+        ///  {
+        ///      [SerializeField] InputActionReference move;
+        ///      [SerializeField] InputActionReference fire;
+        ///
+        ///      void Awake()
+        ///      {
+        ///          /// Receive notifications when move or fire actions are performed
+        ///          move.action.performed += MovePerformed;
+        ///          fire.action.performed += FirePerformed;
+        ///      }
+        ///
+        ///      void OnEnable()
+        ///      {
+        ///          /// Enable actions as part of enabling this behavior.
+        ///          move.action.Enable();
+        ///          fire.action.Enable();
+        ///      }
+        ///
+        ///      void OnDisable()
+        ///      {
+        ///          /// Disable actions as part of disabling this behavior.
+        ///          move.action.Disable();
+        ///          fire.action.Disable();
+        ///      }
+        ///
+        ///      void MovePerformed(InputAction.CallbackContext context)
+        ///      {
+        ///          /// Read the current 2D vector value reported by the associated input action.
+        ///          var direction = context.ReadValue&lt;Vector2&gt;();
+        ///          Debug.Log("Move: " + direction * Time.deltaTime);
+        ///      }
+        ///
+        ///      void FirePerformed(InputAction.CallbackContext context)
+        ///      {
+        ///          /// If underlying interaction is a slow-tap fire charged projectile, otherwise fire regular
+        ///          /// projectile.
+        ///          if (context.interaction is SlowTapInteraction)
+        ///              Debug.Log("Fire charged projectile");
+        ///          else
+        ///              Debug.Log("Fire projectile");
+        ///      }
+        ///  }
+        /// </code>
+        /// </example>
         /// <seealso cref="performed"/>
         /// <seealso cref="started"/>
         /// <seealso cref="canceled"/>
@@ -1832,34 +1935,32 @@ public unsafe InputActionPhase phase
             /// <summary>
             /// Whether the <see cref="action"/> has just been started.
             /// </summary>
-            /// <value>If true, the action was just started.</value>
+            /// <remarks>If true, the action was just started.</remarks>
             /// <seealso cref="InputAction.started"/>
             public bool started => phase == InputActionPhase.Started;
 
             /// <summary>
             /// Whether the <see cref="action"/> has just been performed.
             /// </summary>
-            /// <value>If true, the action was just performed.</value>
+            /// <remarks>If true, the action was just performed.</remarks>
             /// <seealso cref="InputAction.performed"/>
             public bool performed => phase == InputActionPhase.Performed;
 
             /// <summary>
             /// Whether the <see cref="action"/> has just been canceled.
             /// </summary>
-            /// <value>If true, the action was just canceled.</value>
+            /// <remarks>If true, the action was just canceled.</remarks>
             /// <seealso cref="InputAction.canceled"/>
             public bool canceled => phase == InputActionPhase.Canceled;
 
             /// <summary>
-            /// The action that got triggered.
+            /// The associated action that triggered the callback.
             /// </summary>
-            /// <value>Action that got triggered.</value>
             public InputAction action => m_State?.GetActionOrNull(bindingIndex);
 
             /// <summary>
             /// The control that triggered the action.
             /// </summary>
-            /// <value>Control that triggered the action.</value>
             /// <remarks>
             /// In case of a composite binding, this is the control of the composite that activated the
             /// composite as a whole. For example, in case of a WASD-style binding, it could be the W key.
@@ -1877,18 +1978,34 @@ public unsafe InputActionPhase phase
             /// The interaction that triggered the action or <c>null</c> if the binding that triggered does not
             /// have any particular interaction set on it.
             /// </summary>
-            /// <value>Interaction that triggered the callback.</value>
             /// <remarks>
             /// <example>
             /// <code>
-            /// void FirePerformed(InputAction.CallbackContext context)
+            /// using UnityEngine;
+            /// using UnityEngine.InputSystem;
+            /// using UnityEngine.InputSystem.Interactions;
+            ///
+            /// class Example : MonoBehaviour
             /// {
-            ///     // If SlowTap interaction was performed, perform a charged
-            ///     // firing. Otherwise, fire normally.
-            ///     if (context.interaction is SlowTapInteraction)
-            ///         FireChargedProjectile();
-            ///     else
-            ///         FireNormalProjectile();
+            ///     public InputActionReference fire;
+            ///
+            ///     public void Awake()
+            ///     {
+            ///         fire.action.performed += FirePerformed;
+            ///     }
+            ///
+            ///     void OnEnable() => fire.action.Enable();
+            ///     void OnDisable() => fire.action.Disable();
+            ///
+            ///     void FirePerformed(InputAction.CallbackContext context)
+            ///     {
+            ///          /// If SlowTap interaction was performed, perform a charged
+            ///          /// firing. Otherwise, fire normally.
+            ///          if (context.interaction is SlowTapInteraction)
+            ///              Debug.Log("Fire charged projectile");
+            ///          else
+            ///              Debug.Log("Fire projectile");
+            ///     }
             /// }
             /// </code>
             /// </example>
@@ -1911,9 +2028,10 @@ public IInputInteraction interaction
             /// <summary>
             /// The time at which the action got triggered.
             /// </summary>
-            /// <value>Time relative to <c>Time.realtimeSinceStartup</c> at which
-            /// the action got triggered.</value>
             /// <remarks>
+            /// Time is relative to <see cref="UnityEngine.Time.realtimeSinceStartup"/> at which the action got
+            /// triggered.
+            ///
             /// This is usually determined by the timestamp of the input event that activated a control
             /// bound to the action. What this means is that this is normally <em>not</em> the
             /// value of <c>Time.realtimeSinceStartup</c> when the input system calls the
@@ -1932,10 +2050,8 @@ public unsafe double time
             }
 
             /// <summary>
-            /// Time at which the action was started.
+            /// Time at which the action was <see cref="started"/> with relation to <c>Time.realtimeSinceStartup</c>.
             /// </summary>
-            /// <value>Value relative to <c>Time.realtimeSinceStartup</c> when the action
-            /// changed to <see cref="started"/>.</value>
             /// <remarks>
             /// This is only relevant for actions that go through distinct a <see cref="InputActionPhase.Started"/>
             /// cycle as driven by <see cref="IInputInteraction">interactions</see>.
@@ -1957,11 +2073,10 @@ public unsafe double startTime
             /// <summary>
             /// Time difference between <see cref="time"/> and <see cref="startTime"/>.
             /// </summary>
-            /// <value>Difference between <see cref="time"/> and <see cref="startTime"/>.</value>
             /// <remarks>
             /// This property can be used, for example, to determine how long a button
             /// was held down.
-            ///
+            /// </remarks>
             /// <example>
             /// <code>
             /// // Let's create a button action bound to the A button
@@ -1986,22 +2101,18 @@ public unsafe double startTime
             ///     };
             /// </code>
             /// </example>
-            /// </remarks>
             public double duration => time - startTime;
 
             /// <summary>
             /// Type of value returned by <see cref="ReadValueAsObject"/> and expected
             /// by <see cref="ReadValue{TValue}"/>.
             /// </summary>
-            /// <value>Type of object returned when reading a value.</value>
             /// <remarks>
             /// The type of value returned by an action is usually determined by the
             /// <see cref="InputControl"/> that triggered the action, i.e. by the
-            /// control referenced from <see cref="control"/>.
-            ///
-            /// However, if the binding that triggered is a composite, then the composite
-            /// will determine values and not the individual control that triggered (that
-            /// one just feeds values into the composite).
+            /// control referenced from <see cref="control"/>. However, if the binding that
+            /// triggered is a composite, then the composite will determine values and
+            /// not the individual control that triggered (that one just feeds values into the composite).
             /// </remarks>
             /// <seealso cref="InputControl.valueType"/>
             /// <seealso cref="InputBindingComposite.valueType"/>
@@ -2009,21 +2120,24 @@ public unsafe double startTime
             public Type valueType => m_State?.GetValueType(bindingIndex, controlIndex);
 
             /// <summary>
-            /// Size of values returned by <see cref="ReadValue(void*,int)"/>.
+            /// Size of values returned by <see cref="ReadValue(void*,int)"/> in bytes.
             /// </summary>
-            /// <value>Size of value returned when reading.</value>
             /// <remarks>
+            /// <para>
             /// All input values passed around by the system are required to be "blittable",
             /// i.e. they cannot contain references, cannot be heap objects themselves, and
             /// must be trivially mem-copyable. This means that any value can be read out
             /// and retained in a raw byte buffer.
-            ///
+            /// </para>
+            /// <para>
             /// The value of this property determines how many bytes will be written
             /// by <see cref="ReadValue(void*,int)"/>.
+            /// </para>
+            /// <para>
+            /// This property indirectly maps to the value of <see cref="InputControl.valueSizeInBytes"/> or
+            /// <see cref="InputBindingComposite{TValue}.valueSizeInBytes"/>.
+            /// </para>
             /// </remarks>
-            /// <seealso cref="InputControl.valueSizeInBytes"/>
-            /// <seealso cref="InputBindingComposite.valueSizeInBytes"/>
-            /// <seealso cref="ReadValue(void*,int)"/>
             public int valueSizeInBytes
             {
                 get
@@ -2036,16 +2150,15 @@ public int valueSizeInBytes
             }
 
             /// <summary>
-            /// Read the value of the action as a raw byte buffer. This allows reading
-            /// values without having to know value types but also, unlike <see cref="ReadValueAsObject"/>,
-            /// without allocating GC heap memory.
+            /// Read the value of the action as a raw byte buffer.
             /// </summary>
             /// <param name="buffer">Memory buffer to read the value into.</param>
             /// <param name="bufferSize">Size of buffer allocated at <paramref name="buffer"/>. Must be
             /// at least <see cref="valueSizeInBytes"/>.</param>
-            /// <exception cref="ArgumentNullException"><paramref name="buffer"/> is <c>null</c>.</exception>
-            /// <exception cref="ArgumentException"><paramref name="bufferSize"/> is too small.</exception>
             /// <remarks>
+            /// This allows reading values without having to know value types but also,
+            /// unlike <see cref="ReadValueAsObject"/>, without allocating GC heap memory.
+            /// </remarks>
             /// <example>
             /// <code>
             /// // Read a Vector2 using the raw memory ReadValue API.
@@ -2061,7 +2174,8 @@ public int valueSizeInBytes
             /// }
             /// </code>
             /// </example>
-            /// </remarks>
+            /// <exception cref="ArgumentNullException"><paramref name="buffer"/> is <c>null</c>.</exception>
+            /// <exception cref="ArgumentException"><paramref name="bufferSize"/> is too small.</exception>
             /// <seealso cref="InputControlExtensions.ReadValueIntoBuffer"/>
             /// <seealso cref="InputAction.ReadValue{TValue}"/>
             /// <seealso cref="ReadValue{TValue}"/>
@@ -2085,17 +2199,53 @@ public unsafe void ReadValue(void* buffer, int bufferSize)
             }
 
             /// <summary>
-            /// Read the value of the action.
+            /// Read the current value of the associated action.
             /// </summary>
             /// <typeparam name="TValue">Type of value to read. This must correspond to the
             /// expected by either <see cref="control"/> or, if it is a composite, by the
             /// <see cref="InputBindingComposite"/> in use.</typeparam>
-            /// <returns>The value read from the action.</returns>
+            /// <returns>The current value of type <typeparamref name="TValue"/> associated with the action.</returns>
             /// <exception cref="InvalidOperationException">The given type <typeparamref name="TValue"/>
             /// does not match the value type expected by the control or binding composite.</exception>
             /// <seealso cref="InputAction.ReadValue{TValue}"/>
-            /// <seealso cref="ReadValue(void*,int)"/>
+            /// <seealso cref="ReadValue"/>
             /// <seealso cref="ReadValueAsObject"/>
+            /// <remarks>
+            /// The following example shows how to read the current value of a specific type:
+            /// </remarks>
+            /// <example>
+            /// <code>
+            /// using UnityEngine;
+            /// using UnityEngine.InputSystem;
+            ///
+            /// public class Example : MonoBehaviour
+            /// {
+            ///     public InputActionReference move;
+            ///
+            ///     void Awake()
+            ///     {
+            ///         if (move.action != null)
+            ///         {
+            ///             move.action.performed += context =>
+            ///             {
+            ///                 // Note: Assumes the underlying value type is Vector2.
+            ///                 Debug.Log($"Value is: {context.ReadValue&lt;Vector2&gt;()}");
+            ///             };
+            ///         }
+            ///     }
+            ///
+            ///     void OnEnable()
+            ///     {
+            ///         move.action.Enable();
+            ///     }
+            ///
+            ///     void OnDisable()
+            ///     {
+            ///         move.action.Disable();
+            ///     }
+            /// }
+            /// </code>
+            /// </example>
             public TValue ReadValue<TValue>()
                 where TValue : struct
             {
@@ -2120,6 +2270,39 @@ public TValue ReadValue<TValue>()
             /// of the button will be taken into account (if set). If there is no custom button press point, the
             /// global <see cref="InputSettings.defaultButtonPressPoint"/> will be used.
             /// </remarks>
+            /// <example>
+            /// <code>
+            /// using UnityEngine;
+            /// using UnityEngine.InputSystem;
+            ///
+            /// public class Example : MonoBehaviour
+            /// {
+            ///     public InputActionReference fire;
+            ///
+            ///     void Awake()
+            ///     {
+            ///         if (fire.action != null)
+            ///         {
+            ///             fire.action.performed += context =>
+            ///             {
+            ///                 // ReadValueAsButton attempts to interpret the value as a button.
+            ///                 Debug.Log($"Is firing: {context.ReadValueAsButton()}");
+            ///             };
+            ///         }
+            ///     }
+            ///
+            ///     void OnEnable()
+            ///     {
+            ///         fire.action.Enable();
+            ///     }
+            ///
+            ///     void OnDisable()
+            ///     {
+            ///         fire.action.Disable();
+            ///     }
+            /// }
+            /// </code>
+            /// </example>
             /// <seealso cref="InputSettings.defaultButtonPressPoint"/>
             /// <seealso cref="ButtonControl.pressPoint"/>
             public bool ReadValueAsButton()
@@ -2131,15 +2314,52 @@ public bool ReadValueAsButton()
             }
 
             /// <summary>
-            /// Same as <see cref="ReadValue{TValue}"/> except that it is not necessary to
-            /// know the type of value at compile time.
+            /// Same as <see cref="ReadValue{TValue}"/> except that it is not necessary to know the type of the value
+            /// at compile time.
             /// </summary>
             /// <returns>The current value from the binding that triggered the action or <c>null</c> if the action
             /// is not currently in progress.</returns>
             /// <remarks>
-            /// This method allocates GC heap memory. Using it during normal gameplay will lead
+            /// This method allocates GC heap memory due to boxing. Using it during normal gameplay will lead
             /// to frame-rate instabilities.
             /// </remarks>
+            /// <example>
+            /// <code>
+            /// using UnityEngine;
+            /// using UnityEngine.InputSystem;
+            ///
+            /// public class Example : MonoBehaviour
+            /// {
+            ///     public InputActionReference move;
+            ///
+            ///     void Awake()
+            ///     {
+            ///         if (move.action != null)
+            ///         {
+            ///             move.action.performed += context =>
+            ///             {
+            ///                 // ReadValueAsObject allows reading the associated value as a boxed reference type.
+            ///                 object obj = context.ReadValueAsObject();
+            ///                 if (obj is Vector2)
+            ///                     Debug.Log($"Current value is Vector2 type: {obj}");
+            ///                 else
+            ///                     Debug.Log($"Current value is of another type: {context.valueType}");
+            ///             };
+            ///         }
+            ///     }
+            ///
+            ///     void OnEnable()
+            ///     {
+            ///         move.action.Enable();
+            ///     }
+            ///
+            ///     void OnDisable()
+            ///     {
+            ///         move.action.Disable();
+            ///     }
+            /// }
+            /// </code>
+            /// </example>
             /// <seealso cref="ReadValue{TValue}"/>
             /// <seealso cref="InputAction.ReadValueAsObject"/>
             public object ReadValueAsObject()
@@ -2153,6 +2373,37 @@ public object ReadValueAsObject()
             /// Return a string representation of the context useful for debugging.
             /// </summary>
             /// <returns>String representation of the context.</returns>
+            /// <remarks>
+            /// The following example illustrates how to log callback context to console when a callback is received
+            /// for debugging purposes:
+            /// </remarks>
+            /// <example>
+            /// <code>
+            /// using UnityEngine;
+            /// using UnityEngine.InputSystem;
+            ///
+            /// public class Example : MonoBehaviour
+            /// {
+            ///     public InputActionReference move;
+            ///
+            ///     void Awake()
+            ///     {
+            ///         if (move.action != null)
+            ///         {
+            ///             move.action.performed += context =>
+            ///             {
+            ///                 // Outputs the associated callback context in its textual representation which may
+            ///                 // be useful for debugging purposes.
+            ///                 Debug.Log(context.ToString());
+            ///             };
+            ///         }
+            ///     }
+            ///
+            ///     void OnEnable() => move.action.Enable();
+            ///     void OnDisable() => move.action.Disable();
+            /// }
+            /// </code>
+            /// </example>
             public override string ToString()
             {
                 return $"{{ action={action} phase={phase} time={time} control={control} value={ReadValueAsObject()} interaction={interaction} }}";
diff --git a/Packages/com.unity.inputsystem/InputSystem/Actions/InputActionMap.cs b/Packages/com.unity.inputsystem/InputSystem/Actions/InputActionMap.cs
index 8918757d89..e5b5f2cb2f 100644
--- a/Packages/com.unity.inputsystem/InputSystem/Actions/InputActionMap.cs
+++ b/Packages/com.unity.inputsystem/InputSystem/Actions/InputActionMap.cs
@@ -3,6 +3,7 @@
 using System.Collections.Generic;
 using System.Linq;
 using Unity.Collections;
+using Unity.Profiling;
 using UnityEngine.InputSystem.Utilities;
 
 ////REVIEW: given we have the global ActionPerformed callback, do we really need the per-map callback?
@@ -313,6 +314,11 @@ public event Action<InputAction.CallbackContext> actionTriggered
             remove => m_ActionCallbacks.RemoveCallback(value);
         }
 
+        /// <summary>
+        /// ProfilerMarker to measure how long it takes to resolve bindings.
+        /// </summary>
+        static readonly ProfilerMarker k_ResolveBindingsProfilerMarker = new ProfilerMarker("InputActionMap.ResolveBindings");
+
         /// <summary>
         /// Construct an action map with default values.
         /// </summary>
@@ -1299,100 +1305,104 @@ internal bool ResolveBindingsIfNecessary()
         /// </remarks>
         internal void ResolveBindings()
         {
-            // Make sure that if we trigger callbacks as part of disabling and re-enabling actions,
-            // we don't trigger a re-resolve while we're already resolving bindings.
-            using (InputActionRebindingExtensions.DeferBindingResolution())
+            using (k_ResolveBindingsProfilerMarker.Auto())
             {
-                // In case we have actions that are currently enabled, we temporarily retain the
-                // UnmanagedMemory of our InputActionState so that we can sync action states after
-                // we have re-resolved bindings.
-                var oldMemory = new InputActionState.UnmanagedMemory();
-                try
+                // Make sure that if we trigger callbacks as part of disabling and re-enabling actions,
+                // we don't trigger a re-resolve while we're already resolving bindings.
+                using (InputActionRebindingExtensions.DeferBindingResolution())
                 {
-                    OneOrMore<InputActionMap, ReadOnlyArray<InputActionMap>> actionMaps;
+                    // In case we have actions that are currently enabled, we temporarily retain the
+                    // UnmanagedMemory of our InputActionState so that we can sync action states after
+                    // we have re-resolved bindings.
+                    var oldMemory = new InputActionState.UnmanagedMemory();
+                    try
+                    {
+                        OneOrMore<InputActionMap, ReadOnlyArray<InputActionMap>> actionMaps;
 
-                    // Start resolving.
-                    var resolver = new InputBindingResolver();
+                        // Start resolving.
+                        var resolver = new InputBindingResolver();
 
-                    // If we're part of an asset, we share state and thus binding resolution with
-                    // all maps in the asset.
-                    var needFullResolve = m_State == null;
-                    if (m_Asset != null)
-                    {
-                        actionMaps = m_Asset.actionMaps;
-                        Debug.Assert(actionMaps.Count > 0, "Asset referred to by action map does not have action maps");
+                        // If we're part of an asset, we share state and thus binding resolution with
+                        // all maps in the asset.
+                        var needFullResolve = m_State == null;
+                        if (m_Asset != null)
+                        {
+                            actionMaps = m_Asset.actionMaps;
+                            Debug.Assert(actionMaps.Count > 0, "Asset referred to by action map does not have action maps");
 
-                        // If there's a binding mask set on the asset, apply it.
-                        resolver.bindingMask = m_Asset.m_BindingMask;
+                            // If there's a binding mask set on the asset, apply it.
+                            resolver.bindingMask = m_Asset.m_BindingMask;
 
-                        foreach (var map in actionMaps)
+                            foreach (var map in actionMaps)
+                            {
+                                needFullResolve |= map.bindingResolutionNeedsFullReResolve;
+                                map.needToResolveBindings = false;
+                                map.bindingResolutionNeedsFullReResolve = false;
+                                map.controlsForEachActionInitialized = false;
+                            }
+                        }
+                        else
                         {
-                            needFullResolve |= map.bindingResolutionNeedsFullReResolve;
-                            map.needToResolveBindings = false;
-                            map.bindingResolutionNeedsFullReResolve = false;
-                            map.controlsForEachActionInitialized = false;
+                            // Standalone action map (possibly a hidden one created for a singleton action).
+                            // Gets its own private state.
+
+                            actionMaps = this;
+                            needFullResolve |= bindingResolutionNeedsFullReResolve;
+                            needToResolveBindings = false;
+                            bindingResolutionNeedsFullReResolve = false;
+                            controlsForEachActionInitialized = false;
                         }
-                    }
-                    else
-                    {
-                        // Standalone action map (possibly a hidden one created for a singleton action).
-                        // Gets its own private state.
-
-                        actionMaps = this;
-                        needFullResolve |= bindingResolutionNeedsFullReResolve;
-                        needToResolveBindings = false;
-                        bindingResolutionNeedsFullReResolve = false;
-                        controlsForEachActionInitialized = false;
-                    }
 
-                    // If we already have a state, re-use the arrays we have already allocated.
-                    // NOTE: We will install the arrays on the very same InputActionState instance below. In the
-                    //       case where we didn't have to grow the arrays, we should end up with zero GC allocations
-                    //       here.
-                    var hasEnabledActions = false;
-                    InputControlList<InputControl> activeControls = default;
-                    if (m_State != null)
-                    {
-                        // Grab a clone of the current memory. We clone because disabling all the actions
-                        // in the map will alter the memory state and we want the state before we start
-                        // touching it.
-                        oldMemory = m_State.memory.Clone();
+                        // If we already have a state, re-use the arrays we have already allocated.
+                        // NOTE: We will install the arrays on the very same InputActionState instance below. In the
+                        //       case where we didn't have to grow the arrays, we should end up with zero GC allocations
+                        //       here.
+                        var hasEnabledActions = false;
+                        InputControlList<InputControl> activeControls = default;
+                        if (m_State != null)
+                        {
+                            // Grab a clone of the current memory. We clone because disabling all the actions
+                            // in the map will alter the memory state and we want the state before we start
+                            // touching it.
+                            oldMemory = m_State.memory.Clone();
 
-                        m_State.PrepareForBindingReResolution(needFullResolve, ref activeControls, ref hasEnabledActions);
+                            m_State.PrepareForBindingReResolution(needFullResolve, ref activeControls, ref hasEnabledActions);
 
-                        // Reuse the arrays we have so that we can avoid managed memory allocations, if possible.
-                        resolver.StartWithPreviousResolve(m_State, isFullResolve: needFullResolve);
+                            // Reuse the arrays we have so that we can avoid managed memory allocations, if possible.
+                            resolver.StartWithPreviousResolve(m_State, isFullResolve: needFullResolve);
 
-                        // Throw away old memory.
-                        m_State.memory.Dispose();
-                    }
+                            // Throw away old memory.
+                            m_State.memory.Dispose();
+                        }
 
-                    // Resolve all maps in the asset.
-                    foreach (var map in actionMaps)
-                        resolver.AddActionMap(map);
+                        // Resolve all maps in the asset.
+                        foreach (var map in actionMaps)
+                            resolver.AddActionMap(map);
 
-                    // Install state.
-                    if (m_State == null)
-                    {
-                        m_State = new InputActionState();
-                        m_State.Initialize(resolver);
-                    }
-                    else
-                    {
-                        m_State.ClaimDataFrom(resolver);
+                        // Install state.
+                        if (m_State == null)
+                        {
+                            m_State = new InputActionState();
+                            m_State.Initialize(resolver);
+                        }
+                        else
+                        {
+                            m_State.ClaimDataFrom(resolver);
+                        }
+
+                        if (m_Asset != null)
+                        {
+                            foreach (var map in actionMaps)
+                                map.m_State = m_State;
+                            m_Asset.m_SharedStateForAllMaps = m_State;
+                        }
+
+                        m_State.FinishBindingResolution(hasEnabledActions, oldMemory, activeControls, isFullResolve: needFullResolve);
                     }
-                    if (m_Asset != null)
+                    finally
                     {
-                        foreach (var map in actionMaps)
-                            map.m_State = m_State;
-                        m_Asset.m_SharedStateForAllMaps = m_State;
+                        oldMemory.Dispose();
                     }
-
-                    m_State.FinishBindingResolution(hasEnabledActions, oldMemory, activeControls, isFullResolve: needFullResolve);
-                }
-                finally
-                {
-                    oldMemory.Dispose();
                 }
             }
         }
diff --git a/Packages/com.unity.inputsystem/InputSystem/Actions/Interactions/HoldInteraction.cs b/Packages/com.unity.inputsystem/InputSystem/Actions/Interactions/HoldInteraction.cs
index d05942b07c..79e057da25 100644
--- a/Packages/com.unity.inputsystem/InputSystem/Actions/Interactions/HoldInteraction.cs
+++ b/Packages/com.unity.inputsystem/InputSystem/Actions/Interactions/HoldInteraction.cs
@@ -125,7 +125,7 @@ protected override void OnEnable()
         public override void OnGUI()
         {
 #if UNITY_INPUT_SYSTEM_PROJECT_WIDE_ACTIONS
-            if (!InputSystem.settings.IsFeatureEnabled(InputFeatureNames.kUseIMGUIEditorForAssets)) return;
+            if (!InputSystem.settings.useIMGUIEditorForAssets) return;
 #endif
             m_PressPointSetting.OnGUI();
             m_DurationSetting.OnGUI();
diff --git a/Packages/com.unity.inputsystem/InputSystem/Actions/Interactions/MultiTapInteraction.cs b/Packages/com.unity.inputsystem/InputSystem/Actions/Interactions/MultiTapInteraction.cs
index 8e5c3f142b..35768ca1b5 100644
--- a/Packages/com.unity.inputsystem/InputSystem/Actions/Interactions/MultiTapInteraction.cs
+++ b/Packages/com.unity.inputsystem/InputSystem/Actions/Interactions/MultiTapInteraction.cs
@@ -197,7 +197,7 @@ protected override void OnEnable()
         public override void OnGUI()
         {
 #if UNITY_INPUT_SYSTEM_PROJECT_WIDE_ACTIONS
-            if (!InputSystem.settings.IsFeatureEnabled(InputFeatureNames.kUseIMGUIEditorForAssets)) return;
+            if (!InputSystem.settings.useIMGUIEditorForAssets) return;
 #endif
             target.tapCount = EditorGUILayout.IntField(m_TapCountLabel, target.tapCount);
             m_TapDelaySetting.OnGUI();
diff --git a/Packages/com.unity.inputsystem/InputSystem/Actions/Interactions/PressInteraction.cs b/Packages/com.unity.inputsystem/InputSystem/Actions/Interactions/PressInteraction.cs
index 136e6e5165..33cdb0bc79 100644
--- a/Packages/com.unity.inputsystem/InputSystem/Actions/Interactions/PressInteraction.cs
+++ b/Packages/com.unity.inputsystem/InputSystem/Actions/Interactions/PressInteraction.cs
@@ -214,7 +214,7 @@ protected override void OnEnable()
         public override void OnGUI()
         {
 #if UNITY_INPUT_SYSTEM_PROJECT_WIDE_ACTIONS
-            if (!InputSystem.settings.IsFeatureEnabled(InputFeatureNames.kUseIMGUIEditorForAssets)) return;
+            if (!InputSystem.settings.useIMGUIEditorForAssets) return;
 #endif
             EditorGUILayout.HelpBox(s_HelpBoxText);
             target.behavior = (PressBehavior)EditorGUILayout.EnumPopup(s_PressBehaviorLabel, target.behavior);
diff --git a/Packages/com.unity.inputsystem/InputSystem/Actions/Interactions/SlowTapInteraction.cs b/Packages/com.unity.inputsystem/InputSystem/Actions/Interactions/SlowTapInteraction.cs
index a4c41fe22e..5309ab7a5d 100644
--- a/Packages/com.unity.inputsystem/InputSystem/Actions/Interactions/SlowTapInteraction.cs
+++ b/Packages/com.unity.inputsystem/InputSystem/Actions/Interactions/SlowTapInteraction.cs
@@ -89,7 +89,7 @@ protected override void OnEnable()
         public override void OnGUI()
         {
 #if UNITY_INPUT_SYSTEM_PROJECT_WIDE_ACTIONS
-            if (!InputSystem.settings.IsFeatureEnabled(InputFeatureNames.kUseIMGUIEditorForAssets)) return;
+            if (!InputSystem.settings.useIMGUIEditorForAssets) return;
 #endif
             m_DurationSetting.OnGUI();
             m_PressPointSetting.OnGUI();
diff --git a/Packages/com.unity.inputsystem/InputSystem/Actions/Interactions/TapInteraction.cs b/Packages/com.unity.inputsystem/InputSystem/Actions/Interactions/TapInteraction.cs
index b5079ca044..b76a78073f 100644
--- a/Packages/com.unity.inputsystem/InputSystem/Actions/Interactions/TapInteraction.cs
+++ b/Packages/com.unity.inputsystem/InputSystem/Actions/Interactions/TapInteraction.cs
@@ -103,7 +103,7 @@ protected override void OnEnable()
         public override void OnGUI()
         {
 #if UNITY_INPUT_SYSTEM_PROJECT_WIDE_ACTIONS
-            if (!InputSystem.settings.IsFeatureEnabled(InputFeatureNames.kUseIMGUIEditorForAssets)) return;
+            if (!InputSystem.settings.useIMGUIEditorForAssets) return;
 #endif
             m_DurationSetting.OnGUI();
             m_PressPointSetting.OnGUI();
diff --git a/Packages/com.unity.inputsystem/InputSystem/AssemblyInfo.cs b/Packages/com.unity.inputsystem/InputSystem/AssemblyInfo.cs
index 764e03333b..b15c0de969 100644
--- a/Packages/com.unity.inputsystem/InputSystem/AssemblyInfo.cs
+++ b/Packages/com.unity.inputsystem/InputSystem/AssemblyInfo.cs
@@ -16,7 +16,7 @@ public static partial class InputSystem
         // Keep this in sync with "Packages/com.unity.inputsystem/package.json".
         // NOTE: Unfortunately, System.Version doesn't use semantic versioning so we can't include
         //       "-preview" suffixes here.
-        internal const string kAssemblyVersion = "1.11.3";
-        internal const string kDocUrl = "https://docs.unity3d.com/Packages/com.unity.inputsystem@1.11";
+        internal const string kAssemblyVersion = "1.12.0";
+        internal const string kDocUrl = "https://docs.unity3d.com/Packages/com.unity.inputsystem@1.12";
     }
 }
diff --git a/Packages/com.unity.inputsystem/InputSystem/Controls/ButtonControl.cs b/Packages/com.unity.inputsystem/InputSystem/Controls/ButtonControl.cs
index fe28ffe352..e04f4ebf8a 100644
--- a/Packages/com.unity.inputsystem/InputSystem/Controls/ButtonControl.cs
+++ b/Packages/com.unity.inputsystem/InputSystem/Controls/ButtonControl.cs
@@ -10,7 +10,7 @@ namespace UnityEngine.InputSystem.Controls
     /// An axis that has a trigger point beyond which it is considered to be pressed.
     /// </summary>
     /// <remarks>
-    /// By default stored as a single bit. In that format, buttons will only yield 0
+    /// By default, stored as a single bit. In that format, buttons will only yield 0
     /// and 1 as values. However, buttons return are <see cref="AxisControl"/>s and
     /// yield full floating-point values and may thus have a range of values. See
     /// <see cref="pressPoint"/> for how button presses on such buttons are handled.
@@ -34,7 +34,6 @@ public class ButtonControl : AxisControl
         /// <summary>
         /// The minimum value the button has to reach for it to be considered pressed.
         /// </summary>
-        /// <value>Button press threshold.</value>
         /// <remarks>
         /// The button is considered pressed, if it has a value equal to or greater than
         /// this value.
@@ -46,6 +45,9 @@ public class ButtonControl : AxisControl
         ///
         /// <example>
         /// <code>
+        /// using UnityEngine;
+        /// using UnityEngine.InputSystem.Controls;
+        ///
         /// public class MyDevice : InputDevice
         /// {
         ///     [InputControl(parameters = "pressPoint=0.234")]
@@ -56,25 +58,37 @@ public class ButtonControl : AxisControl
         /// </code>
         /// </example>
         /// </remarks>
-        /// <seealso cref="InputSettings.defaultButtonPressPoint"/>
-        /// <seealso cref="pressPointOrDefault"/>
-        /// <seealso cref="isPressed"/>
         public float pressPoint = -1;
 
         /// <summary>
         /// Return <see cref="pressPoint"/> if set, otherwise return <see cref="InputSettings.defaultButtonPressPoint"/>.
         /// </summary>
-        /// <value>Effective value to use for press point thresholds.</value>
-        /// <seealso cref="InputSettings.defaultButtonPressPoint"/>
         public float pressPointOrDefault => pressPoint > 0 ? pressPoint : s_GlobalDefaultButtonPressPoint;
 
         /// <summary>
-        /// Default-initialize the control.
+        /// Default-initialize the button control.
         /// </summary>
         /// <remarks>
-        /// The default format for the control is <see cref="InputStateBlock.FormatBit"/>.
-        /// The control's minimum value is set to 0 and the maximum value to 1.
+        /// The default format for the button control is <see cref="InputStateBlock.FormatBit"/>.
+        /// The button control's minimum value is set to 0 and the maximum value to 1.
         /// </remarks>
+        /// <example>
+        /// <code>
+        /// using UnityEngine;
+        /// using UnityEngine.InputSystem.Controls;
+        ///
+        /// public class ButtonControlExample : MonoBehaviour
+        /// {
+        ///     void Start()
+        ///     {
+        ///         var myButton = new ButtonControl();
+        ///     }
+        ///
+        ///     //...
+        /// }
+        /// </code>
+        /// </example>
+        /// <seealso cref="AxisControl"/>
         public ButtonControl()
         {
             m_StateBlock.format = InputStateBlock.FormatBit;
@@ -85,10 +99,39 @@ public ButtonControl()
         /// <summary>
         /// Whether the given value would be considered pressed for this button.
         /// </summary>
-        /// <param name="value">Value for the button.</param>
+        /// <param name="value">Value to check for if the button would be considered pressed or not.</param>
         /// <returns>True if <paramref name="value"/> crosses the threshold to be considered pressed.</returns>
-        /// <seealso cref="pressPoint"/>
-        /// <seealso cref="InputSettings.defaultButtonPressPoint"/>
+        /// <remarks>
+        /// The default format for the control is <see cref="InputStateBlock.FormatBit"/>.
+        /// The control's minimum value is set to 0 and the maximum value to 1.
+        /// See <see cref="InputSettings.defaultButtonPressPoint"/> and <see cref="pressPoint"/>for the (default) press point.
+        /// </remarks>
+        /// <example>
+        /// <code>
+        /// using UnityEngine;
+        /// using UnityEngine.InputSystem.Controls;
+        ///
+        /// public class IsValueConsideredPressedExample : MonoBehaviour
+        /// {
+        ///     void Start()
+        ///     {
+        ///         var myButton = new ButtonControl();
+        ///         var valueToTest = 0.5f;
+        ///
+        ///         if (myButton.IsValueConsideredPressed(valueToTest))
+        ///         {
+        ///             Debug.Log("myButton is considered pressed at: " + valueToTest.ToString());
+        ///         }
+        ///         else
+        ///         {
+        ///             Debug.Log("myButton is not considered pressed at: " + valueToTest.ToString());
+        ///         }
+        ///     }
+        ///
+        ///     //...
+        /// }
+        /// </code>
+        /// </example>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public new bool IsValueConsideredPressed(float value)
         {
@@ -98,10 +141,9 @@ public ButtonControl()
         /// <summary>
         /// Whether the button is currently pressed.
         /// </summary>
-        /// <value>True if button is currently pressed.</value>
         /// <remarks>
         /// A button is considered pressed if its value is equal to or greater
-        /// than its button press threshold (<see cref="pressPointOrDefault"/>).
+        /// than its button press threshold (<see cref="pressPointOrDefault"/>, <see cref="pressPoint"/>).
         /// </remarks>
         /// <example>
         /// <para>You can use this to read whether specific keys are currently pressed by using isPressed on keys, as shown in the following examples:</para>
@@ -149,9 +191,6 @@ public ButtonControl()
         /// ]]>
         /// </code>
         /// </example>
-        /// <seealso cref="InputSettings.defaultButtonPressPoint"/>
-        /// <seealso cref="pressPoint"/>
-        /// <seealso cref="InputSystem.onAnyButtonPress"/>
         public bool isPressed
         {
             get
@@ -200,7 +239,6 @@ private void BeginTestingForFramePresses(bool currentlyPressed, bool pressedLast
         /// <summary>
         /// Whether the press started this frame.
         /// </summary>
-        /// <value>True if the current press of the button started this frame.</value>
         /// <remarks>
         /// The first time this function - or wasReleasedThisFrame - are called, it's possible that extremely fast
         /// inputs (or very slow frame update times) will result in presses/releases being missed.
@@ -262,12 +300,12 @@ public bool wasPressedThisFrame
         /// <summary>
         /// Whether the press ended this frame.
         /// </summary>
-        /// <value>True if the current press of the button ended this frame.</value>
         /// <remarks>
         /// _Note_: The Input System identifies keys by physical layout, not according to the current language mapping of the keyboard. To query the name of the key according to the language mapping, use <see cref="InputControl.displayName"/>.
         /// </remarks>
         /// <example>
         /// <para>An example showing the use of this property on a gamepad button and a keyboard key:</para>
+        ///
         /// <code>
         /// using UnityEngine;
         /// using UnityEngine.InputSystem;
@@ -276,8 +314,8 @@ public bool wasPressedThisFrame
         /// {
         ///     void Update()
         ///     {
-        ///         bool buttonPressed = Gamepad.current.aButton.wasReleasedThisFrame;
-        ///         bool spaceKeyPressed = Keyboard.current.spaceKey.wasReleasedThisFrame;
+        ///         bool buttonReleased = Gamepad.current.aButton.wasReleasedThisFrame;
+        ///         bool spaceKeyReleased = Keyboard.current.spaceKey.wasReleasedThisFrame;
         ///     }
         /// }
         /// </code>
diff --git a/Packages/com.unity.inputsystem/InputSystem/Controls/InputControl.cs b/Packages/com.unity.inputsystem/InputSystem/Controls/InputControl.cs
index 1f5ec6adec..4634d67af7 100644
--- a/Packages/com.unity.inputsystem/InputSystem/Controls/InputControl.cs
+++ b/Packages/com.unity.inputsystem/InputSystem/Controls/InputControl.cs
@@ -77,7 +77,7 @@ namespace UnityEngine.InputSystem
     /// which has APIs specific to the type of value of the control (e.g. <see cref="InputControl{TValue}.ReadValue()"/>.
     ///
     /// The following example demonstrates various common operations performed on input controls:
-    ///
+    /// </remarks>
     /// <example>
     /// <code>
     /// // Look up dpad/up control on current gamepad.
@@ -99,10 +99,7 @@ namespace UnityEngine.InputSystem
     /// leftStickHistory.Enable();
     /// </code>
     /// </example>
-    /// <example>
-    /// </example>
-    /// </remarks>
-    /// <see cref="InputControl{TValue}"/>
+    /// <seealso cref="InputControl{TValue}"/>
     /// <seealso cref="InputDevice"/>
     /// <seealso cref="InputControlPath"/>
     /// <seealso cref="InputStateBlock"/>
@@ -122,11 +119,8 @@ public abstract class InputControl
         /// Lookup of names is case-insensitive.
         ///
         /// This is set from the name of the control in the layout.
+        /// See <see cref="path"/>, <see cref="aliases"/>, <see cref="InputControlAttribute.name"/> and <see cref="InputControlLayout.ControlItem.name"/>.
         /// </remarks>
-        /// <seealso cref="path"/>
-        /// <seealso cref="aliases"/>
-        /// <seealso cref="InputControlAttribute.name"/>
-        /// <seealso cref="InputControlLayout.ControlItem.name"/>
         public string name => m_Name;
 
         ////TODO: protect against empty strings
@@ -146,8 +140,9 @@ public abstract class InputControl
         /// For nested controls, the display name will include the display names of all parent controls,
         /// i.e. the display name will fully identify the control on the device. For example, the display
         /// name for the left D-Pad button on a gamepad is "D-Pad Left" and not just "Left".
+        ///
+        /// There is a short name version, see <see cref="shortDisplayName"/>.
         /// </remarks>
-        /// <seealso cref="shortDisplayName"/>
         public string displayName
         {
             get
@@ -176,9 +171,8 @@ public string displayName
         /// For nested controls, the short display name will include the short display names of all parent controls,
         /// that is, the display name will fully identify the control on the device. For example, the display
         /// name for the left D-Pad button on a gamepad is "D-Pad \u2190" and not just "\u2190". Note that if a parent
-        /// control has no short name, its long name will be used instead.
+        /// control has no short name, its long name will be used instead. See <see cref="displayName"/>.
         /// </remarks>
-        /// <seealso cref="displayName"/>
         public string shortDisplayName
         {
             get
@@ -205,11 +199,11 @@ public string shortDisplayName
         ///
         /// Allocates on first hit. Paths are not created until someone asks for them.
         ///
+        /// For more details on the path see <see cref="InputControlPath"/>.
+        /// </remarks>
         /// <example>
         /// Example: "/gamepad/leftStick/x"
         /// </example>
-        /// </remarks>
-        /// <seealso cref="InputControlPath"/>
         public string path
         {
             get
@@ -221,7 +215,7 @@ public string path
         }
 
         /// <summary>
-        /// Layout the control is based on.
+        /// Layout name for the control it is based on.
         /// </summary>
         /// <remarks>
         /// This is the layout name rather than a reference to an <see cref="InputControlLayout"/> as
@@ -243,25 +237,27 @@ public string path
         /// </summary>
         /// <remarks>
         /// This is the root of the control hierarchy. For the device at the root, this
-        /// will point to itself.
+        /// will point to itself (See <see cref="InputDevice.allControls"/>).
         /// </remarks>
-        /// <seealso cref="InputDevice.allControls"/>
         public InputDevice device => m_Device;
 
         /// <summary>
-        /// The immediate parent of the control or null if the control has no parent
-        /// (which, once fully constructed) will only be the case for InputDevices).
+        /// The immediate parent of the control.
         /// </summary>
-        /// <seealso cref="children"/>
+        /// <value>
+        /// The immediate parent of the control or null if the control has no parent
+        /// (which, once fully constructed, will only be the case for InputDevices).
+        /// See the related <see cref="children"/> field.
+        /// </value>
         public InputControl parent => m_Parent;
 
         /// <summary>
-        /// List of immediate children.
+        /// List of immediate child controls below this.
         /// </summary>
         /// <remarks>
         /// Does not allocate.
+        /// See the related <see cref="parent"/> field.
         /// </remarks>
-        /// <seealso cref="parent"/>
         public ReadOnlyArray<InputControl> children =>
             new ReadOnlyArray<InputControl>(m_Device.m_ChildrenForEachControl, m_ChildStartIndex, m_ChildCount);
 
@@ -281,34 +277,38 @@ public string path
         /// control to use for certain standardized situation without having to know the particulars of
         /// the device or platform.
         ///
-        /// <example>
-        /// <code>
-        /// // Bind to any control which is tagged with the "Back" usage on any device.
-        /// var backAction = new InputAction(binding: "*/{Back}");
-        /// </code>
-        /// </example>
-        ///
         /// Note that usages on devices work slightly differently than usages of controls on devices.
         /// They are also queried through this property but unlike the usages of controls, the set of
         /// usages of a device can be changed dynamically as the role of the device changes. For details,
         /// see <see cref="InputSystem.SetDeviceUsage(InputDevice,string)"/>. Controls, on the other hand,
         /// can currently only be assigned usages through layouts (<see cref="InputControlAttribute.usage"/>
         /// or <see cref="InputControlAttribute.usages"/>).
+        ///
+        /// <see cref="InputSystem.AddDeviceUsage(InputDevice,string)"/> can be used to add a device.
+        /// <see cref="InputSystem.RemoveDeviceUsage(InputDevice,string)"/> can be used to remove a device.
         /// </remarks>
-        /// <seealso cref="InputControlAttribute.usage"/>
-        /// <seealso cref="InputControlAttribute.usages"/>
-        /// <seealso cref="InputSystem.SetDeviceUsage(InputDevice,string)"/>
-        /// <seealso cref="InputSystem.AddDeviceUsage(InputDevice,string)"/>
-        /// <seealso cref="InputSystem.RemoveDeviceUsage(InputDevice,string)"/>
-        /// <seealso cref="CommonUsages"/>
+        /// <example>
+        /// <code>
+        /// // Bind to any control which is tagged with the "Back" usage on any device.
+        /// var backAction = new InputAction(binding: "*/{Back}");
+        /// </code>
+        /// </example>
         public ReadOnlyArray<InternedString> usages =>
             new ReadOnlyArray<InternedString>(m_Device.m_UsagesForEachControl, m_UsageStartIndex, m_UsageCount);
 
-        // List of alternate names for the control.
+        /// <summary>
+        /// List of alternate names for the control.
+        /// </summary>
+        /// <value>
+        /// List of aliased alternate names for the control.
+        /// An example of an alias would be '<c>North</c>' for the '<c>Triangle</c>' button on a Playstation pad (or '<c>Y</c>' button on Xbox pad).
+        /// </value>
         public ReadOnlyArray<InternedString> aliases =>
             new ReadOnlyArray<InternedString>(m_Device.m_AliasesForEachControl, m_AliasStartIndex, m_AliasCount);
 
-        // Information about where the control stores its state.
+        /// <summary>
+        /// Information about where the control stores its state, such as format, offset and size.
+        /// </summary>
         public InputStateBlock stateBlock => m_StateBlock;
 
         /// <summary>
@@ -380,9 +380,10 @@ internal set
         /// input from an actual physical control whereas <c>"&lt;Gamepad&gt;/leftStick/left"</c>
         /// represents input from a made-up control. If, however, the "left" button is the only
         /// viable pick, it will be accepted.
+        ///
+        /// A control layout will specify if it is synthetic using <see cref="InputControlLayout.ControlItem.isSynthetic"/>.
+        /// See <see cref="InputControlAttribute.synthetic"/>.
         /// </remarks>
-        /// <seealso cref="InputControlLayout.ControlItem.isSynthetic"/>
-        /// <seealso cref="InputControlAttribute.synthetic"/>
         public bool synthetic
         {
             get => (m_ControlFlags & ControlFlags.IsSynthetic) != 0;
@@ -398,8 +399,11 @@ internal set
         /// <summary>
         /// Fetch a control from the control's hierarchy by name.
         /// </summary>
+        /// <param name="path">A control path. See <see cref="InputControlPath"/>.</param>
         /// <remarks>
-        /// Note that path matching is case-insensitive.
+        /// Note that <see cref="path"/> matching is case-insensitive.
+        /// (see <see cref="InputControlPath"/>).
+        /// An alternative method is <see cref="TryGetChildControl"/>.
         /// </remarks>
         /// <example>
         /// <code>
@@ -409,9 +413,6 @@ internal set
         /// </code>
         /// </example>
         /// <exception cref="KeyNotFoundException"><paramref name="path"/> cannot be found.</exception>
-        /// <seealso cref="InputControlPath"/>
-        /// <seealso cref="path"/>
-        /// <seealso cref="TryGetChildControl"/>
         public InputControl this[string path]
         {
             get
@@ -430,30 +431,34 @@ public InputControl this[string path]
         /// <value>Type of values produced by the control.</value>
         /// <remarks>
         /// This is the type of values that are returned when reading the current value of a control
-        /// or when reading a value of a control from an event.
+        /// or when reading a value of a control from an event with <see cref="ReadValueFromStateAsObject"/>.
+        /// The size can be determined with <see cref="valueSizeInBytes"/>.
         /// </remarks>
-        /// <seealso cref="valueSizeInBytes"/>
-        /// <seealso cref="ReadValueFromStateAsObject"/>
         public abstract Type valueType { get; }
 
         /// <summary>
         /// Size in bytes of values that the control returns.
         /// </summary>
-        /// <seealso cref="valueType"/>
+        /// <remarks>
+        /// The type can be determined with <see cref="valueType"/>.
+        /// </remarks>
         public abstract int valueSizeInBytes { get; }
 
         /// <summary>
         /// Compute an absolute, normalized magnitude value that indicates the extent to which the control
         /// is actuated. Shortcut for <see cref="EvaluateMagnitude()"/>.
         /// </summary>
-        /// <returns>Amount of actuation of the control or -1 if it cannot be determined.</returns>
-        /// <seealso cref="EvaluateMagnitude(void*)"/>
-        /// <seealso cref="EvaluateMagnitude()"/>
+        /// <value>
+        /// Amount of actuation of the control or -1 if it cannot be determined.
+        /// </value>
         public float magnitude => EvaluateMagnitude();
 
         /// <summary>
-        /// Return a string representation of the control useful for debugging.
+        /// Return a string representation of the control.
         /// </summary>
+        /// <remarks>
+        /// Return a string representation of the control. Useful for debugging.
+        /// </remarks>
         /// <returns>A string representation of the control.</returns>
         public override string ToString()
         {
@@ -503,23 +508,48 @@ public unsafe float EvaluateMagnitude()
         /// Compute an absolute, normalized magnitude value that indicates the extent to which the control
         /// is actuated in the given state.
         /// </summary>
+        /// <remarks>
+        /// Magnitudes do not make sense for all types of controls. For example, for a control that represents
+        /// an enumeration of values (such as <see cref="TouchPhaseControl"/>), there is no meaningful
+        /// linear ordering of values (one could derive a linear ordering through the actual enum values but
+        /// their assignment may be entirely arbitrary; it is unclear whether a state of <see cref="TouchPhase.Canceled"/>
+        /// has a higher or lower "magnitude" as a state of <see cref="TouchPhase.Began"/>).
+        ///
+        /// Controls that have no meaningful magnitude will return -1 when calling this method. Any negative
+        /// return value should be considered an invalid value.
+        /// </remarks>
         /// <param name="statePtr">State containing the control's <see cref="stateBlock"/>.</param>
         /// <returns>Amount of actuation of the control or -1 if it cannot be determined.</returns>
         /// <seealso cref="EvaluateMagnitude()"/>
-        /// <seealso cref="stateBlock"/>
         public virtual unsafe float EvaluateMagnitude(void* statePtr)
         {
             return -1;
         }
 
+        /// <summary>
+        /// Read the control's final, processed value from the given buffer and return the value as an object.
+        /// </summary>
+        /// <param name="buffer">Buffer to read the value from.</param>
+        /// <param name="bufferSize">Size of <paramref name="buffer"/> in bytes, which must be large enough to store the value.</param>
+        /// <returns>The control's value as stored in <paramref name="buffer"/>.</returns>
+        /// <remarks>
+        /// Read the control's final, processed value from the given buffer and return the value as an object.
+        ///
+        /// This method allocates GC memory and should not be used during normal gameplay operation.
+        /// </remarks>
+        /// <exception cref="ArgumentNullException"><paramref name="buffer"/> is null.</exception>
+        /// <exception cref="ArgumentException"><paramref name="bufferSize"/> is smaller than the size of the value to be read.</exception>
+        /// <seealso cref="ReadValueFromStateAsObject"/>
         public abstract unsafe object ReadValueFromBufferAsObject(void* buffer, int bufferSize);
 
         /// <summary>
         /// Read the control's final, processed value from the given state and return the value as an object.
         /// </summary>
-        /// <param name="statePtr"></param>
+        /// <param name="statePtr">State to read the value for the control from.</param>
         /// <returns>The control's value as stored in <paramref name="statePtr"/>.</returns>
         /// <remarks>
+        /// Read the control's final, processed value from the given state and return the value as an object.
+        ///
         /// This method allocates GC memory and should not be used during normal gameplay operation.
         /// </remarks>
         /// <exception cref="ArgumentNullException"><paramref name="statePtr"/> is null.</exception>
@@ -542,7 +572,7 @@ public virtual unsafe float EvaluateMagnitude(void* statePtr)
         /// <summary>
         /// Read a value from the given memory and store it as state.
         /// </summary>
-        /// <param name="bufferPtr">Memory containing value.</param>
+        /// <param name="bufferPtr">Memory containing value, to store into the state.</param>
         /// <param name="bufferSize">Size of <paramref name="bufferPtr"/> in bytes. Must be at least <see cref="valueSizeInBytes"/>.</param>
         /// <param name="statePtr">State containing the control's <see cref="stateBlock"/>. Will receive the state
         /// as converted from the given value.</param>
@@ -564,9 +594,9 @@ public virtual unsafe void WriteValueFromBufferIntoState(void* bufferPtr, int bu
         /// <summary>
         /// Read a value object and store it as state in the given memory.
         /// </summary>
-        /// <param name="value">Value for the control.</param>
+        /// <param name="value">Value for the control to store in the state.</param>
         /// <param name="statePtr">State containing the control's <see cref="stateBlock"/>. Will receive
-        /// the state state as converted from the given value.</param>
+        /// the state as converted from the given value.</param>
         /// <remarks>
         /// Writing values will NOT apply processors to the given value. This can mean that when reading a value
         /// from a control after it has been written to its state, the resulting value differs from what was
@@ -611,6 +641,8 @@ public virtual unsafe void WriteValueFromObjectIntoState(object value, void* sta
         /// Note that if the given path matches multiple child controls, only the first control
         /// encountered in the search will be returned.
         ///
+        /// This method is equivalent to calling <see cref="InputControlPath.TryFindChild"/>.
+        /// </remarks>
         /// <example>
         /// <code>
         /// // Returns the leftStick control of the current gamepad.
@@ -625,9 +657,6 @@ public virtual unsafe void WriteValueFromObjectIntoState(object value, void* sta
         /// Gamepad.current.TryGetChildControl("*stick");
         /// </code>
         /// </example>
-        ///
-        /// This method is equivalent to calling <see cref="InputControlPath.TryFindChild"/>.
-        /// </remarks>
         public InputControl TryGetChildControl(string path)
         {
             if (string.IsNullOrEmpty(path))
@@ -635,6 +664,19 @@ public InputControl TryGetChildControl(string path)
             return InputControlPath.TryFindChild(this, path);
         }
 
+        /// <summary>
+        /// Try to find a child control matching the given path.
+        /// </summary>
+        /// <param name="path">A control path. See <see cref="InputControlPath"/>.</param>
+        /// <typeparam name="TControl">The type of control to locate.</typeparam>
+        /// <returns>The first direct or indirect child control that matches the given <paramref name="path"/>
+        /// or null if no control was found to match.</returns>
+        /// <exception cref="ArgumentNullException"><paramref name="path"/> is <c>null</c> or empty.</exception>
+        /// <exception cref="InvalidOperationException">No control found with the specified type.</exception>
+        /// <remarks>
+        /// Note that if the given path matches multiple child controls, only the first control
+        /// encountered in the search will be returned.
+        /// </remarks>
         public TControl TryGetChildControl<TControl>(string path)
             where TControl : InputControl
         {
@@ -653,6 +695,19 @@ public TControl TryGetChildControl<TControl>(string path)
             return controlOfType;
         }
 
+        /// <summary>
+        /// Find a child control matching the given path.
+        /// </summary>
+        /// <param name="path">A control path. See <see cref="InputControlPath"/>.</param>
+        /// <returns>The first direct or indirect child control that matches the given <paramref name="path"/>
+        /// or null if no control was found to match.</returns>
+        /// <exception cref="ArgumentNullException"><paramref name="path"/> is <c>null</c> or empty.</exception>
+        /// <exception cref="InvalidOperationException">No control found with the specified type.</exception>
+        /// <exception cref="ArgumentException">The control cannot be found.</exception>
+        /// <remarks>
+        /// Note that if the given path matches multiple child controls, only the first control
+        /// encountered in the search will be returned.
+        /// </remarks>
         public InputControl GetChildControl(string path)
         {
             if (string.IsNullOrEmpty(path))
@@ -665,6 +720,20 @@ public InputControl GetChildControl(string path)
             return control;
         }
 
+        /// <summary>
+        /// Find a child control matching the given path.
+        /// </summary>
+        /// <param name="path">A control path. See <see cref="InputControlPath"/>.</param>
+        /// <typeparam name="TControl">The type of control to locate.</typeparam>
+        /// <returns>The first direct or indirect child control that matches the given <paramref name="path"/>
+        /// or null if no control was found to match.</returns>
+        /// <exception cref="ArgumentNullException"><paramref name="path"/> is <c>null</c> or empty.</exception>
+        /// <exception cref="InvalidOperationException">No control found with the specified type.</exception>
+        /// <exception cref="ArgumentException">The control cannot be found.</exception>
+        /// <remarks>
+        /// Note that if the given path matches multiple child controls, only the first control
+        /// encountered in the search will be returned.
+        /// </remarks>
         public TControl GetChildControl<TControl>(string path)
             where TControl : InputControl
         {
@@ -677,6 +746,12 @@ public TControl GetChildControl<TControl>(string path)
             return controlOfType;
         }
 
+        /// <summary>
+        /// Constructor for the InputControl
+        /// </summary>
+        /// <remarks>
+        /// Constructor for the InputControl
+        /// </remarks>
         protected InputControl()
         {
             // Set defaults for state block setup. Subclasses may override.
@@ -689,7 +764,7 @@ protected InputControl()
         /// <remarks>
         /// This method can be overridden to perform control- or device-specific setup work. The most
         /// common use case is for looking up child controls and storing them in local getters.
-        ///
+        /// </remarks>
         /// <example>
         /// <code>
         /// public class MyDevice : InputDevice
@@ -706,7 +781,6 @@ protected InputControl()
         /// }
         /// </code>
         /// </example>
-        /// </remarks>
         protected virtual void FinishSetup()
         {
         }
@@ -723,9 +797,12 @@ protected virtual void FinishSetup()
         ///
         /// This method should be called if you are accessing cached data set up by
         /// <see cref="RefreshConfiguration"/>.
-        ///
+        /// </remarks>
         /// <example>
         /// <code>
+        /// using UnityEngine.InputSystem;
+        /// using UnityEngine.InputSystem.Utilities;
+        ///
         /// // Let's say your device has an associated orientation which it can be held with
         /// // and you want to surface both as a property and as a usage on the device.
         /// // Whenever your backend code detects a change in orientation, it should send
@@ -779,7 +856,6 @@ protected virtual void FinishSetup()
         /// }
         /// </code>
         /// </example>
-        /// </remarks>
         /// <seealso cref="RefreshConfiguration"/>
         protected void RefreshConfigurationIfNeeded()
         {
@@ -790,18 +866,98 @@ protected void RefreshConfigurationIfNeeded()
             }
         }
 
+        /// <summary>
+        /// Refresh the configuration of the control. This is used to update the control's state (e.g. Keyboard Layout or display Name of Keys).
+        /// </summary>
+        /// <remarks>
+        /// The system will call this method automatically whenever a change is made to one of the control's configuration properties.
+        /// This method is only relevant if you are implementing your own devices or new
+        /// types of controls which are fetching configuration data from the devices (such
+        /// as <see cref="KeyControl"/> which is fetching display names for individual keys
+        /// from the underlying platform).
+        /// See <see cref="RefreshConfigurationIfNeeded"/>.
+        /// </remarks>
+        /// <example>
+        /// <code>
+        /// using UnityEngine.InputSystem;
+        /// using UnityEngine.InputSystem.Utilities;
+        ///
+        /// public class MyDevice : InputDevice
+        /// {
+        ///     public enum Orientation
+        ///     {
+        ///         Horizontal,
+        ///         Vertical,
+        ///     }
+        ///     private Orientation m_Orientation;
+        ///     private static InternedString s_Vertical = new InternedString("Vertical");
+        ///     private static InternedString s_Horizontal = new InternedString("Horizontal");
+        ///
+        ///     public Orientation orientation
+        ///     {
+        ///         get
+        ///         {
+        ///             // Call RefreshOrientation if the configuration of the device has been
+        ///             // invalidated since last time we initialized m_Orientation.
+        ///             // Calling RefreshConfigurationIfNeeded() is sufficient in most cases, RefreshConfiguration() forces the refresh.
+        ///             RefreshConfiguration();
+        ///             return m_Orientation;
+        ///         }
+        ///     }
+        ///     protected override void RefreshConfiguration()
+        ///     {
+        ///         // Set Orientation back to horizontal. Alternatively fetch from device.
+        ///         m_Orientation = Orientation.Horizontal;
+        ///         // Reflect the orientation on the device.
+        ///         switch (m_Orientation)
+        ///         {
+        ///             case Orientation.Vertical:
+        ///                 InputSystem.RemoveDeviceUsage(this, s_Horizontal);
+        ///                 InputSystem.AddDeviceUsage(this, s_Vertical);
+        ///                 break;
+        ///
+        ///             case Orientation.Horizontal:
+        ///                 InputSystem.RemoveDeviceUsage(this, s_Vertical);
+        ///                 InputSystem.AddDeviceUsage(this, s_Horizontal);
+        ///                 break;
+        ///         }
+        ///     }
+        /// }
+        /// </code>
+        /// </example>
         protected virtual void RefreshConfiguration()
         {
         }
 
         ////TODO: drop protected access
+        /// <summary>
+        /// Information about a memory region storing input state.
+        /// </summary>
         protected internal InputStateBlock m_StateBlock;
 
         ////REVIEW: shouldn't these sit on the device?
+        /// <summary>
+        /// The state data buffer for the device.
+        /// </summary>
+        /// <value>
+        /// The state data buffer for the device.
+        /// </value>
         protected internal unsafe void* currentStatePtr => InputStateBuffers.GetFrontBufferForDevice(GetDeviceIndex());
 
+        /// <summary>
+        /// The state data buffer for the device from the previous frame.
+        /// </summary>
+        /// <value>
+        /// The state data buffer for the device from the previous frame.
+        /// </value>
         protected internal unsafe void* previousFrameStatePtr => InputStateBuffers.GetBackBufferForDevice(GetDeviceIndex());
 
+        /// <summary>
+        /// The default state data buffer
+        /// </summary>
+        /// <value>
+        /// Buffer that has state for each device initialized with default values.
+        /// </value>
         protected internal unsafe void* defaultStatePtr => InputStateBuffers.s_DefaultStateBuffer;
 
         /// <summary>
@@ -816,8 +972,9 @@ protected virtual void RefreshConfiguration()
         /// that is noise will be masked out whereas all state that isn't will come through unmodified. In other words,
         /// any bit that is set in the noise mask indicates that the corresponding bit in the control's state memory
         /// is noise.
+        ///
+        /// A control can be marked as <see cref="noisy"/>.
         /// </remarks>
-        /// <seealso cref="noisy"/>
         protected internal unsafe void* noiseMaskPtr => InputStateBuffers.s_NoiseMaskBuffer;
 
         /// <summary>
@@ -826,7 +983,7 @@ protected virtual void RefreshConfiguration()
         /// <remarks>
         /// Once a device has been added to the system, its state block will get allocated
         /// in the global state buffers and the offset of the device's state block will
-        /// get baked into all of the controls on the device. This property always returns
+        /// get baked into all the controls on the device. This property always returns
         /// the "unbaked" offset.
         /// </remarks>
         protected internal uint stateOffsetRelativeToDeviceRoot
@@ -872,13 +1029,15 @@ protected internal uint stateOffsetRelativeToDeviceRoot
         internal FourCC m_OptimizedControlDataType;
 
         /// <summary>
+        /// The type of the state memory associated with the control.
+        /// </summary>
+        /// <remarks>
         /// For some types of control you can safely read/write state memory directly
         /// which is much faster than calling ReadUnprocessedValueFromState/WriteValueIntoState.
         /// This method returns a type that you can use for reading/writing the control directly,
-        /// or it returns InputStateBlock.kFormatInvalid if it's not possible for this type of control.
-        /// </summary>
-        /// <remarks>
-        /// For example, AxisControl might be a "float" in state memory, and if no processing is applied during reading (e.g. no invert/scale/etc),
+        /// or it returns <see cref="InputStateBlock.FormatInvalid"/> if it's not possible for this type of control.
+        ///
+        /// For example, AxisControl <see cref="valueType"/> might be a "float" in state memory, and if no processing is applied during reading (e.g. no invert/scale/etc),
         /// then you could read it as float in memory directly without calling ReadUnprocessedValueFromState, which is faster.
         /// Additionally, if you have a Vector3Control which uses 3 AxisControls as consecutive floats in memory,
         /// you can cast the Vector3Control state memory directly to Vector3 without calling ReadUnprocessedValueFromState on x/y/z axes.
@@ -890,20 +1049,33 @@ protected internal uint stateOffsetRelativeToDeviceRoot
         public FourCC optimizedControlDataType => m_OptimizedControlDataType;
 
         /// <summary>
-        /// Calculates and returns a optimized data type that can represent a control's value in memory directly.
+        /// Calculates and returns an optimized data type that can represent a control's value in memory directly.
+        /// </summary>
+        /// <remarks>
         /// The value then is cached in <see cref="InputControl.optimizedControlDataType"/>.
         /// This method is for internal use only, you should not call this from your own code.
-        /// </summary>
+        /// </remarks>
+        /// <returns>
+        /// An optimized data type that can represent a control's value in memory directly. <see cref="InputStateBlock"/>
+        /// </returns>
         protected virtual FourCC CalculateOptimizedControlDataType()
         {
             return InputStateBlock.kFormatInvalid;
         }
 
         /// <summary>
-        /// Apply built-in parameters changes (e.g. <see cref="AxisControl.invert"/>, others), recompute <see cref="InputControl.optimizedControlDataType"/> for impacted controls and clear cached value.
+        /// Apply built-in parameters changes.
         /// </summary>
         /// <remarks>
+        /// Apply built-in parameters changes (e.g. <see cref="AxisControl.invert"/>, others).
+        /// Recompute <see cref="InputControl.optimizedControlDataType"/> for impacted controls and clear cached value
         /// </remarks>
+        /// <example>
+        /// <code>
+        /// Gamepad.all[0].leftTrigger.WriteValueIntoState(0.5f, Gamepad.all[0].currentStatePtr);
+        /// Gamepad.all[0].ApplyParameterChanges();
+        /// </code>
+        /// </example>
         public void ApplyParameterChanges()
         {
             // First we go through all children of our own hierarchy
@@ -1144,14 +1316,16 @@ internal virtual IEnumerable<object> GetProcessors()
     public abstract class InputControl<TValue> : InputControl
         where TValue : struct
     {
+        /// <inheritdoc/>
         public override Type valueType => typeof(TValue);
 
+        /// <inheritdoc/>
         public override int valueSizeInBytes => UnsafeUtility.SizeOf<TValue>();
 
         /// <summary>
         /// Returns the current value of the control after processors have been applied.
         /// </summary>
-        /// <returns>The controls current value.</returns>
+        /// <value>The controls current value.</value>
         /// <remarks>
         /// This can only be called on devices that have been added to the system (<see cref="InputDevice.added"/>).
         ///
@@ -1168,7 +1342,7 @@ public abstract class InputControl<TValue> : InputControl
         ///
         /// Also note that this property returns the result as ref readonly. If custom control states are in use, i.e.
         /// any controls not shipped with the Input System package, be careful of accidental defensive copies
-        /// <see href="https://docs.microsoft.com/en-us/dotnet/csharp/write-safe-efficient-code#avoid-defensive-copies"/>.
+        /// <a href="https://docs.microsoft.com/en-us/dotnet/csharp/write-safe-efficient-code#avoid-defensive-copies">https://docs.microsoft.com/en-us/dotnet/csharp/write-safe-efficient-code#avoid-defensive-copies</a>.
         /// </remarks>
         /// <seealso cref="ReadValue"/>
         public ref readonly TValue value
@@ -1290,7 +1464,7 @@ internal unsafe ref readonly TValue unprocessedValue
         /// in the processor and set it to <see cref="InputProcessor.CachingPolicy.EvaluateOnEveryRead"/>.
         ///
         /// To improve debugging try setting "PARANOID_READ_VALUE_CACHING_CHECKS" internal feature flag to check if cache value is still consistent.
-        /// <see href="https://docs.microsoft.com/en-us/dotnet/csharp/write-safe-efficient-code#avoid-defensive-copies"/>.
+        /// <a href="https://docs.microsoft.com/en-us/dotnet/csharp/write-safe-efficient-code#avoid-defensive-copies">https://docs.microsoft.com/en-us/dotnet/csharp/write-safe-efficient-code#avoid-defensive-copies</a>.
         /// </remarks>
         /// <seealso cref="value"/>
         public TValue ReadValue()
@@ -1328,6 +1502,16 @@ public TValue ReadDefaultValue()
             }
         }
 
+        /// <summary>
+        /// Get the control's default value.
+        /// </summary>
+        /// <param name="statePtr">State containing the control's <see cref="InputControl.stateBlock"/>.</param>
+        /// <returns>The control's default value.</returns>
+        /// <remarks>
+        /// This is not necessarily equivalent to <c>default(TValue)</c>. A control's default value is determined
+        /// by reading its value from the default state (<see cref="InputControl.defaultStatePtr"/>) which in turn
+        /// is determined from settings in the control's registered layout (<see cref="InputControlLayout.ControlItem.defaultState"/>).
+        /// </remarks>
         public unsafe TValue ReadValueFromState(void* statePtr)
         {
             if (statePtr == null)
@@ -1363,11 +1547,28 @@ public unsafe TValue ReadUnprocessedValueFromStateWithCaching(void* statePtr)
             return statePtr == currentStatePtr ? unprocessedValue : ReadUnprocessedValueFromState(statePtr);
         }
 
+        /// <summary>
+        /// Read value from control
+        /// </summary>
+        /// <returns>The controls current value.</returns>
+        /// <remarks>
+        /// This is the locally cached value. Use <see cref="ReadUnprocessedValueFromStateWithCaching"/>to get the uncached version.
+        /// </remarks>
+        /// <seealso cref="value"/>
         public TValue ReadUnprocessedValue()
         {
             return unprocessedValue;
         }
 
+        /// <summary>
+        /// Read value from provided <paramref name="statePtr"/>.
+        /// </summary>
+        /// <param name="statePtr">State pointer to read from.</param>
+        /// <returns>The controls current value.</returns>
+        /// <remarks>
+        /// Read value from provided <paramref name="statePtr"/> without any caching.
+        /// </remarks>
+        /// <seealso cref="value"/>
         public abstract unsafe TValue ReadUnprocessedValueFromState(void* statePtr);
 
         /// <inheritdoc />
@@ -1395,6 +1596,7 @@ public override unsafe void ReadValueFromStateIntoBuffer(void* statePtr, void* b
             UnsafeUtility.MemCpy(bufferPtr, valuePtr, numBytes);
         }
 
+        /// <inheritdoc />
         public override unsafe void WriteValueFromBufferIntoState(void* bufferPtr, int bufferSize, void* statePtr)
         {
             if (bufferPtr == null)
@@ -1432,6 +1634,20 @@ public override unsafe void WriteValueFromObjectIntoState(object value, void* st
             WriteValueIntoState(valueOfType, statePtr);
         }
 
+        /// <summary>
+        /// Write a value into state at the given memory.
+        /// </summary>
+        /// <param name="value">Value for the control to store in the state.</param>
+        /// <param name="statePtr">State containing the control's <see cref="InputControl.stateBlock"/>. Will receive
+        /// the state as converted from the given value.</param>
+        /// <remarks>
+        /// Writing values will NOT apply processors to the given value. This can mean that when reading a value
+        /// from a control after it has been written to its state, the resulting value differs from what was
+        /// written.
+        /// </remarks>
+        /// <exception cref="NotSupportedException">The control does not support writing. This is the case, for
+        /// example, that compute values (such as the magnitude of a vector).</exception>
+        /// <seealso cref="WriteValueFromBufferIntoState"/>
         public virtual unsafe void WriteValueIntoState(TValue value, void* statePtr)
         {
             ////REVIEW: should we be able to even tell from layouts which controls support writing and which don't?
@@ -1470,6 +1686,12 @@ private static unsafe bool CompareValue(ref TValue firstValue, ref TValue second
             return UnsafeUtility.MemCmp(firstValuePtr, secondValuePtr, UnsafeUtility.SizeOf<TValue>()) != 0;
         }
 
+        /// <summary>
+        /// Compared values in state buffers.
+        /// </summary>
+        /// <param name="firstStatePtr">The first state buffer to read value from.</param>
+        /// <param name="secondStatePtr">The second state buffer to read value from.</param>
+        /// <returns>True if the buffer values match. False if they differ.</returns>
         public override unsafe bool CompareValue(void* firstStatePtr, void* secondStatePtr)
         {
             ////REVIEW: should we first compare state here? if there's no change in state, there can be no change in value and we can skip the rest
@@ -1480,6 +1702,14 @@ public override unsafe bool CompareValue(void* firstStatePtr, void* secondStateP
             return CompareValue(ref firstValue, ref secondValue);
         }
 
+        /// <summary>
+        /// Applies all control processors to the passed value.
+        /// </summary>
+        /// <param name="value">value to run processors on.</param>
+        /// <returns>The processed value.</returns>
+        /// <remarks>
+        /// Applies all control processors to the passed value.
+        /// </remarks>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public TValue ProcessValue(TValue value)
         {
@@ -1490,7 +1720,7 @@ public TValue ProcessValue(TValue value)
         /// <summary>
         /// Applies all control processors to the passed value.
         /// </summary>
-        /// <param name="value"></param>
+        /// <param name="value">value to run processors on.</param>
         /// <remarks>
         /// Use this overload when your state struct is large to avoid creating copies of the state.
         /// </remarks>
@@ -1572,6 +1802,7 @@ internal override IEnumerable<object> GetProcessors()
 
         internal bool evaluateProcessorsEveryRead = false;
 
+        /// <inheritdoc />
         protected override void FinishSetup()
         {
             foreach (var processor in m_ProcessorStack)
diff --git a/Packages/com.unity.inputsystem/InputSystem/Controls/KeyControl.cs b/Packages/com.unity.inputsystem/InputSystem/Controls/KeyControl.cs
index 6e8c5f8b84..de58183fa8 100644
--- a/Packages/com.unity.inputsystem/InputSystem/Controls/KeyControl.cs
+++ b/Packages/com.unity.inputsystem/InputSystem/Controls/KeyControl.cs
@@ -58,7 +58,7 @@ public int scanCode
                 return m_ScanCode;
             }
         }
-
+        /// <inheritdoc/>
         protected override void RefreshConfiguration()
         {
             // Wipe our last cached set of data (if any).
diff --git a/Packages/com.unity.inputsystem/InputSystem/Controls/Processors/AxisDeadzoneProcessor.cs b/Packages/com.unity.inputsystem/InputSystem/Controls/Processors/AxisDeadzoneProcessor.cs
index 88881ab698..d9c33718a4 100644
--- a/Packages/com.unity.inputsystem/InputSystem/Controls/Processors/AxisDeadzoneProcessor.cs
+++ b/Packages/com.unity.inputsystem/InputSystem/Controls/Processors/AxisDeadzoneProcessor.cs
@@ -94,7 +94,7 @@ protected override void OnEnable()
         public override void OnGUI()
         {
 #if UNITY_INPUT_SYSTEM_PROJECT_WIDE_ACTIONS
-            if (!InputSystem.settings.IsFeatureEnabled(InputFeatureNames.kUseIMGUIEditorForAssets)) return;
+            if (!InputSystem.settings.useIMGUIEditorForAssets) return;
 #endif
             m_MinSetting.OnGUI();
             m_MaxSetting.OnGUI();
diff --git a/Packages/com.unity.inputsystem/InputSystem/Controls/Processors/StickDeadzoneProcessor.cs b/Packages/com.unity.inputsystem/InputSystem/Controls/Processors/StickDeadzoneProcessor.cs
index 63bfd1873b..b0115b977b 100644
--- a/Packages/com.unity.inputsystem/InputSystem/Controls/Processors/StickDeadzoneProcessor.cs
+++ b/Packages/com.unity.inputsystem/InputSystem/Controls/Processors/StickDeadzoneProcessor.cs
@@ -83,7 +83,7 @@ protected override void OnEnable()
         public override void OnGUI()
         {
 #if UNITY_INPUT_SYSTEM_PROJECT_WIDE_ACTIONS
-            if (!InputSystem.settings.IsFeatureEnabled(InputFeatureNames.kUseIMGUIEditorForAssets)) return;
+            if (!InputSystem.settings.useIMGUIEditorForAssets) return;
 #endif
             m_MinSetting.OnGUI();
             m_MaxSetting.OnGUI();
diff --git a/Packages/com.unity.inputsystem/InputSystem/Devices/Gamepad.cs b/Packages/com.unity.inputsystem/InputSystem/Devices/Gamepad.cs
index 1a6a98c1e9..3841c4d723 100644
--- a/Packages/com.unity.inputsystem/InputSystem/Devices/Gamepad.cs
+++ b/Packages/com.unity.inputsystem/InputSystem/Devices/Gamepad.cs
@@ -102,7 +102,6 @@ public struct GamepadState : IInputStateTypeInfo
         /// <summary>
         /// Button bit mask.
         /// </summary>
-        /// <value>Button bit mask.</value>
         /// <seealso cref="GamepadButton"/>
         /// <seealso cref="Gamepad.buttonSouth"/>
         /// <seealso cref="Gamepad.buttonNorth"/>
@@ -132,20 +131,20 @@ public struct GamepadState : IInputStateTypeInfo
         public uint buttons;
 
         /// <summary>
-        /// Left stick position. Each axis goes from -1 to 1 with
-        /// 0 being center position.
+        /// A 2D vector representing the current position of the left stick on a gamepad.
         /// </summary>
-        /// <value>Left stick position.</value>
+        /// <remarks>Each axis of the 2D vector's range goes from -1 to 1. 0 represents the stick in its center position, and -1 or 1 represents the the stick pushed to its extent in each direction along the axis.</remarks>
         /// <seealso cref="Gamepad.leftStick"/>
         [InputControl(layout = "Stick", usage = "Primary2DMotion", processors = "stickDeadzone", displayName = "Left Stick", shortDisplayName = "LS")]
         [FieldOffset(4)]
         public Vector2 leftStick;
 
         /// <summary>
-        /// Right stick position. Each axis from -1 to 1 with
-        /// 0 being center position.
+        /// A 2D vector representing the current position of the right stick on a gamepad.
         /// </summary>
-        /// <value>Right stick position.</value>
+        /// <remarks>Each axis of the 2D vector's range goes from -1 to 1.
+        /// 0 represents the stick in its center position.
+        /// -1 or 1 represents the stick pushed to its extent in each direction along the axis.</remarks>
         /// <seealso cref="Gamepad.rightStick"/>
         [InputControl(layout = "Stick", usage = "Secondary2DMotion", processors = "stickDeadzone", displayName = "Right Stick", shortDisplayName = "RS")]
         [FieldOffset(12)]
@@ -154,18 +153,22 @@ public struct GamepadState : IInputStateTypeInfo
         ////REVIEW: should left and right trigger get deadzones?
 
         /// <summary>
-        /// Position of the left trigger. Goes from 0 (not pressed) to 1 (fully pressed).
+        /// The current position of the left trigger on a gamepad.
         /// </summary>
-        /// <value>Position of left trigger.</value>
+        /// <remarks>The value's range goes from 0 to 1.
+        /// 0 represents the trigger in its neutral position.
+        /// 1 represents the trigger in its fully pressed position.</remarks>
         /// <seealso cref="Gamepad.leftTrigger"/>
         [InputControl(layout = "Button", format = "FLT", usage = "SecondaryTrigger", displayName = "Left Trigger", shortDisplayName = "LT")]
         [FieldOffset(20)]
         public float leftTrigger;
 
         /// <summary>
-        /// Position of the right trigger. Goes from 0 (not pressed) to 1 (fully pressed).
+        /// The current position of the right trigger on a gamepad.
         /// </summary>
-        /// <value>Position of right trigger.</value>
+        /// <remarks>The value's range goes from 0 to 1.
+        /// 0 represents the trigger in its neutral position.
+        /// 1 represents the trigger in its fully pressed position.</remarks>
         /// <seealso cref="Gamepad.rightTrigger"/>
         [InputControl(layout = "Button", format = "FLT", usage = "SecondaryTrigger", displayName = "Right Trigger", shortDisplayName = "RT")]
         [FieldOffset(24)]
@@ -174,7 +177,7 @@ public struct GamepadState : IInputStateTypeInfo
         /// <summary>
         /// State format tag for GamepadState.
         /// </summary>
-        /// <value>Returns "GPAD".</value>
+        /// <remarks> Holds the format tag for GamepadState ("GPAD")</remarks>
         public FourCC format => Format;
 
         /// <summary>
@@ -399,109 +402,96 @@ namespace UnityEngine.InputSystem
     /// to be mapped correctly and consistently. If, based on the set of supported devices available
     /// to the input system, this cannot be guaranteed, a given device is usually represented as a
     /// generic <see cref="Joystick"/> or as just a plain <see cref="HID.HID"/> instead.
-    ///
+    /// </remarks>
     /// <example>
-    /// <code>
-    /// // Show all gamepads in the system.
-    /// Debug.Log(string.Join("\n", Gamepad.all));
-    ///
-    /// // Check whether the X button on the current gamepad is pressed.
-    /// if (Gamepad.current.xButton.wasPressedThisFrame)
-    ///     Debug.Log("Pressed");
-    ///
-    /// // Rumble the left motor on the current gamepad slightly.
-    /// Gamepad.current.SetMotorSpeeds(0.2f, 0.
-    /// </code>
+    /// <code source="../../DocCodeSamples.Tests/GamepadExample.cs" />
     /// </example>
-    /// </remarks>
+    /// <seealso cref="all"/>
+    /// <seealso cref="current"/>
+    /// <seealso cref="GamepadState"/>
+    /// <seealso cref="InputDevice"/>
+    /// <seealso cref="SetMotorSpeeds"/>
+    /// <seealso cref="ButtonControl.wasPressedThisFrame"/>
     [InputControlLayout(stateType = typeof(GamepadState), isGenericTypeOfDevice = true)]
     public class Gamepad : InputDevice, IDualMotorRumble
     {
         /// <summary>
         /// The left face button of the gamepad.
         /// </summary>
-        /// <value>Control representing the X/Square face button.</value>
         /// <remarks>
-        /// On an Xbox controller, this is the X button and on the PS4 controller, this is the
-        /// square button.
+        /// Control representing the X/Square face button.
+        /// On an Xbox controller, this is the <see cref="xButton"/> and on the PS4 controller, this is the
+        /// <see cref="squareButton"/>.
         /// </remarks>
-        /// <seealso cref="xButton"/>
-        /// <seealso cref="squareButton"/>
         public ButtonControl buttonWest { get; protected set; }
 
         /// <summary>
         /// The top face button of the gamepad.
         /// </summary>
-        /// <value>Control representing the Y/Triangle face button.</value>
         /// <remarks>
-        /// On an Xbox controller, this is the Y button and on the PS4 controller, this is the
-        /// triangle button.
+        /// Control representing the Y/Triangle face button.
+        /// On an Xbox controller, this is the <see cref="yButton"/> and on the PS4 controller, this is the
+        /// <see cref="triangleButton"/>.
         /// </remarks>
-        /// <seealso cref="yButton"/>
-        /// <seealso cref="triangleButton"/>
         public ButtonControl buttonNorth { get; protected set; }
 
         /// <summary>
         /// The bottom face button of the gamepad.
         /// </summary>
-        /// <value>Control representing the A/Cross face button.</value>
         /// <remarks>
-        /// On an Xbox controller, this is the A button and on the PS4 controller, this is the
-        /// cross button.
+        /// Control representing the A/Cross face button.
+        /// On an Xbox controller, this is the <see cref="aButton"/> and on the PS4 controller, this is the
+        /// <see cref="crossButton"/>.
         /// </remarks>
-        /// <seealso cref="aButton"/>
-        /// <seealso cref="crossButton"/>
         public ButtonControl buttonSouth { get; protected set; }
 
         /// <summary>
         /// The right face button of the gamepad.
         /// </summary>
-        /// <value>Control representing the B/Circle face button.</value>
         /// <remarks>
-        /// On an Xbox controller, this is the B button and on the PS4 controller, this is the
-        /// circle button.
+        /// Control representing the B/Circle face button.
+        /// On an Xbox controller, this is the <see cref="bButton"/> and on the PS4 controller, this is the
+        /// <see cref="circleButton"/>.
         /// </remarks>
-        /// <seealso cref="bButton"/>
-        /// <seealso cref="circleButton"/>
         public ButtonControl buttonEast { get; protected set; }
 
         /// <summary>
         /// The button that gets triggered when <see cref="leftStick"/> is pressed down.
         /// </summary>
-        /// <value>Control representing a click with the left stick.</value>
+        /// <remarks>Control representing a click with the left stick.</remarks>
         public ButtonControl leftStickButton { get; protected set; }
 
         /// <summary>
         /// The button that gets triggered when <see cref="rightStick"/> is pressed down.
         /// </summary>
-        /// <value>Control representing a click with the right stick.</value>
+        /// <remarks>Control representing a click with the right stick.</remarks>
         public ButtonControl rightStickButton { get; protected set; }
 
         /// <summary>
         /// The right button in the middle section of the gamepad (called "menu" on Xbox
         /// controllers and "options" on PS4 controllers).
         /// </summary>
-        /// <value>Control representing the right button in midsection.</value>
+        /// <remarks>Control representing the right button in midsection.</remarks>
         public ButtonControl startButton { get; protected set; }
 
         /// <summary>
         /// The left button in the middle section of the gamepad (called "view" on Xbox
         /// controllers and "share" on PS4 controllers).
         /// </summary>
-        /// <value>Control representing the left button in midsection.</value>
+        /// <remarks>Control representing the left button in midsection.</remarks>
         public ButtonControl selectButton { get; protected set; }
 
         /// <summary>
         /// The 4-way directional pad on the gamepad.
         /// </summary>
-        /// <value>Control representing the d-pad.</value>
+        /// <remarks>Control representing the d-pad.</remarks>
         public DpadControl dpad { get; protected set; }
 
         /// <summary>
         /// The left shoulder/bumper button that sits on top of <see cref="leftTrigger"/>.
         /// </summary>
-        /// <value>Control representing the left shoulder button.</value>
         /// <remarks>
+        /// Control representing the left shoulder button.
         /// On Xbox controllers, this is usually called "left bumper" whereas on PS4
         /// controllers, this button is referred to as "L1".
         /// </remarks>
@@ -510,8 +500,8 @@ public class Gamepad : InputDevice, IDualMotorRumble
         /// <summary>
         /// The right shoulder/bumper button that sits on top of <see cref="rightTrigger"/>.
         /// </summary>
-        /// <value>Control representing the right shoulder button.</value>
         /// <remarks>
+        /// Control representing the right shoulder button.
         /// On Xbox controllers, this is usually called "right bumper" whereas on PS4
         /// controllers, this button is referred to as "R1".
         /// </remarks>
@@ -520,20 +510,19 @@ public class Gamepad : InputDevice, IDualMotorRumble
         /// <summary>
         /// The left thumbstick on the gamepad.
         /// </summary>
-        /// <value>Control representing the left thumbstick.</value>
+        /// <remarks>Control representing the left thumbstick.</remarks>
         public StickControl leftStick { get; protected set; }
 
         /// <summary>
         /// The right thumbstick on the gamepad.
         /// </summary>
-        /// <value>Control representing the right thumbstick.</value>
+        /// <remarks>Control representing the right thumbstick.</remarks>
         public StickControl rightStick { get; protected set; }
 
         /// <summary>
         /// The left trigger button sitting below <see cref="leftShoulder"/>.
         /// </summary>
-        /// <value>Control representing the left trigger button.</value>
-        /// <remarks>
+        /// <remarks>Control representing the left trigger button.
         /// On PS4 controllers, this button is referred to as "L2".
         /// </remarks>
         public ButtonControl leftTrigger { get; protected set; }
@@ -541,8 +530,7 @@ public class Gamepad : InputDevice, IDualMotorRumble
         /// <summary>
         /// The right trigger button sitting below <see cref="rightShoulder"/>.
         /// </summary>
-        /// <value>Control representing the right trigger button.</value>
-        /// <remarks>
+        /// <remarks>Control representing the right trigger button.
         /// On PS4 controllers, this button is referred to as "R2".
         /// </remarks>
         public ButtonControl rightTrigger { get; protected set; }
@@ -550,49 +538,41 @@ public class Gamepad : InputDevice, IDualMotorRumble
         /// <summary>
         /// Same as <see cref="buttonSouth"/>. Xbox-style alias.
         /// </summary>
-        /// <value>Same as <see cref="buttonSouth"/>.</value>
         public ButtonControl aButton => buttonSouth;
 
         /// <summary>
         /// Same as <see cref="buttonEast"/>. Xbox-style alias.
         /// </summary>
-        /// <value>Same as <see cref="buttonEast"/>.</value>
         public ButtonControl bButton => buttonEast;
 
         /// <summary>
         /// Same as <see cref="buttonWest"/> Xbox-style alias.
         /// </summary>
-        /// <value>Same as <see cref="buttonWest"/>.</value>
         public ButtonControl xButton => buttonWest;
 
         /// <summary>
         /// Same as <see cref="buttonNorth"/>. Xbox-style alias.
         /// </summary>
-        /// <value>Same as <see cref="buttonNorth"/>.</value>
         public ButtonControl yButton => buttonNorth;
 
         /// <summary>
         /// Same as <see cref="buttonNorth"/>. PS4-style alias.
         /// </summary>
-        /// <value>Same as <see cref="buttonNorth"/>.</value>
         public ButtonControl triangleButton => buttonNorth;
 
         /// <summary>
         /// Same as <see cref="buttonWest"/>. PS4-style alias.
         /// </summary>
-        /// <value>Same as <see cref="buttonWest"/>.</value>
         public ButtonControl squareButton => buttonWest;
 
         /// <summary>
         /// Same as <see cref="buttonEast"/>. PS4-style alias.
         /// </summary>
-        /// <value>Same as <see cref="buttonEast"/>.</value>
         public ButtonControl circleButton => buttonEast;
 
         /// <summary>
         /// Same as <see cref="buttonSouth"/>. PS4-style alias.
         /// </summary>
-        /// <value>Same as <see cref="buttonSouth"/>.</value>
         public ButtonControl crossButton => buttonSouth;
 
         /// <summary>
@@ -637,28 +617,29 @@ public ButtonControl this[GamepadButton button]
         /// <remarks>
         /// When added, a device is automatically made current (see <see cref="InputDevice.MakeCurrent"/>), so
         /// when connecting a gamepad, it will also become current. After that, it will only become current again
-        /// when input change on non-noisy controls (see <see cref="InputControl.noisy"/>) is received.
+        /// when input change on non-noisy controls (see <see cref="InputControl.noisy"/>) is received. It will also
+        /// be available once <see cref="all"/> is queried.
         ///
         /// For local multiplayer scenarios (or whenever there are multiple gamepads that need to be usable
         /// in a concurrent fashion), it is not recommended to rely on this property. Instead, it is recommended
         /// to use <see cref="PlayerInput"/> or <see cref="Users.InputUser"/>.
         /// </remarks>
-        /// <seealso cref="InputDevice.MakeCurrent"/>
-        /// <seealso cref="all"/>
         public static Gamepad current { get; private set; }
 
         /// <summary>
         /// A list of gamepads currently connected to the system.
         /// </summary>
-        /// <value>All currently connected gamepads.</value>
         /// <remarks>
+        /// Returns all currently connected gamepads.
+        ///
         /// Does not cause GC allocation.
         ///
         /// Do <em>not</em> hold on to the value returned by this getter but rather query it whenever
         /// you need it. Whenever the gamepad setup changes, the value returned by this getter
         /// is invalidated.
+        ///
+        /// Alternately, for querying a single gamepad, you can use <see cref="current"/> for example.
         /// </remarks>
-        /// <seealso cref="current"/>
         public new static ReadOnlyArray<Gamepad> all => new ReadOnlyArray<Gamepad>(s_Gamepads, 0, s_GamepadCount);
 
         /// <inheritdoc />
@@ -695,24 +676,54 @@ protected override void FinishSetup()
         /// </summary>
         /// <remarks>
         /// This is called automatically by the system when there is input on a gamepad.
+        ///
+        /// More remarks are available in <see cref="InputDevice.MakeCurrent()"/> when it comes to devices with
+        /// <see cref="InputControl.noisy"/> controls.
         /// </remarks>
+        /// <example>
+        /// <code>
+        /// using System;
+        /// using UnityEngine;
+        /// using UnityEngine.InputSystem;
+        ///
+        /// public class MakeCurrentGamepadExample : MonoBehaviour
+        /// {
+        ///     void Update()
+        ///     {
+        ///         /// Make the first Gamepad always the current one
+        ///         if (Gamepad.all.Count > 0)
+        ///         {
+        ///             Gamepad.all[0].MakeCurrent();
+        ///         }
+        ///     }
+        /// }
+        /// </code>
+        /// </example>
         public override void MakeCurrent()
         {
             base.MakeCurrent();
             current = this;
         }
 
+        /// <inheritdoc cref="InputDevice.OnAdded"/>
         /// <summary>
-        /// Called when the gamepad is added to the system.
+        /// Called when a gamepad is added to the system.
         /// </summary>
+        /// <remarks>
+        /// Override this method if you want to do additional processing when a gamepad becomes connected. After this method is called, the gamepad is automatically added to the list of <see cref="all"/> gamepads.
+        /// </remarks>
         protected override void OnAdded()
         {
             ArrayHelpers.AppendWithCapacity(ref s_Gamepads, ref s_GamepadCount, this);
         }
 
+        /// <inheritdoc cref="InputDevice.OnRemoved"/>
         /// <summary>
         /// Called when the gamepad is removed from the system.
         /// </summary>
+        /// <remarks>
+        /// Override this method if you want to do additional processing when a gamepad becomes disconnected. After this method is called, the gamepad is automatically removed from the list of <see cref="all"/> gamepads.
+        /// </remarks>
         protected override void OnRemoved()
         {
             if (current == this)
@@ -730,34 +741,61 @@ protected override void OnRemoved()
         }
 
         /// <summary>
-        /// Pause rumble effects on the gamepad. Resume with <see cref="ResumeHaptics"/>.
+        /// Pause rumble effects on the gamepad.
         /// </summary>
+        /// <remarks>
+        /// It will pause rumble effects and save the current motor speeds.
+        /// Resume from those speeds with <see cref="ResumeHaptics"/>.
+        /// Some devices such as <see cref="DualShock.DualSenseGamepadHID"/> and
+        /// <see cref="DualShock.DualShock4GamepadHID"/> can also set the LED color when this method is called.
+        /// </remarks>
         /// <seealso cref="IDualMotorRumble"/>
+        /// <example>
+        /// <code source="../../DocCodeSamples.Tests/GamepadHapticsExample.cs"/>
+        /// </example>
         public virtual void PauseHaptics()
         {
             m_Rumble.PauseHaptics(this);
         }
 
         /// <summary>
-        /// Resume rumble affects on the gamepad that have been paused with <see cref="PauseHaptics"/>.
+        /// Resume rumble effects on the gamepad.
         /// </summary>
+        /// <remarks>
+        /// It will resume rumble effects from the previously set motor speeds, such as motor speeds saved when
+        /// calling <see cref="PauseHaptics"/>.
+        /// Some devices such as <see cref="DualShock.DualSenseGamepadHID"/> and
+        /// <see cref="DualShock.DualShock4GamepadHID"/> can also set the LED color when this method is called.
+        /// </remarks>
         /// <seealso cref="IDualMotorRumble"/>
+        /// <example>
+        /// <code source="../../DocCodeSamples.Tests/GamepadHapticsExample.cs"/>
+        /// </example>
         public virtual void ResumeHaptics()
         {
             m_Rumble.ResumeHaptics(this);
         }
 
         /// <summary>
-        /// Reset rumble effects on the gamepad. Puts the gamepad rumble motors back into their
-        /// default state.
+        /// Resets rumble effects on the gamepad by setting motor speeds to 0.
         /// </summary>
+        /// <remarks>
+        /// Some devices such as <see cref="DualShock.DualSenseGamepadHID"/> and
+        /// <see cref="DualShock.DualShock4GamepadHID"/> can also set the LED color when this method is called.
+        /// </remarks>
         /// <seealso cref="IDualMotorRumble"/>
+        /// <example>
+        /// <code source="../../DocCodeSamples.Tests/GamepadHapticsExample.cs"/>
+        /// </example>
         public virtual void ResetHaptics()
         {
             m_Rumble.ResetHaptics(this);
         }
 
         /// <inheritdoc />
+        /// <example>
+        /// <code source="../../DocCodeSamples.Tests/GamepadHapticsExample.cs"/>
+        /// </example>
         public virtual void SetMotorSpeeds(float lowFrequency, float highFrequency)
         {
             m_Rumble.SetMotorSpeeds(this, lowFrequency, highFrequency);
diff --git a/Packages/com.unity.inputsystem/InputSystem/Devices/Haptics/DualMotorRumble.cs b/Packages/com.unity.inputsystem/InputSystem/Devices/Haptics/DualMotorRumble.cs
index 9a4d0ddba9..c54a0f4c01 100644
--- a/Packages/com.unity.inputsystem/InputSystem/Devices/Haptics/DualMotorRumble.cs
+++ b/Packages/com.unity.inputsystem/InputSystem/Devices/Haptics/DualMotorRumble.cs
@@ -39,9 +39,13 @@ internal struct DualMotorRumble
             || !Mathf.Approximately(highFrequencyMotorSpeed, 0f);
 
         /// <summary>
-        /// Reset motor speeds to zero but retain current values for <see cref="lowFrequencyMotorSpeed"/>
-        /// and <see cref="highFrequencyMotorSpeed"/>.
+        /// Stops haptics by setting motor speeds to zero.
         /// </summary>
+        /// <remarks>
+        /// Sets both motor speeds to zero while retaining the current values for <see cref="lowFrequencyMotorSpeed"/>
+        /// and <see cref="highFrequencyMotorSpeed"/>.
+        /// It will only send the command if <see cref="isRumbling"/> is true.
+        /// </remarks>
         /// <param name="device">Device to send command to.</param>
         /// <exception cref="ArgumentNullException"><paramref name="device"/> is null.</exception>
         public void PauseHaptics(InputDevice device)
@@ -60,6 +64,9 @@ public void PauseHaptics(InputDevice device)
         /// Resume haptics by setting motor speeds to the current values of <see cref="lowFrequencyMotorSpeed"/>
         /// and <see cref="highFrequencyMotorSpeed"/>.
         /// </summary>
+        /// <remarks>
+        /// It will only set motor speeds if <see cref="isRumbling"/> is true
+        /// </remarks>
         /// <param name="device">Device to send command to.</param>
         /// <exception cref="ArgumentNullException"><paramref name="device"/> is null.</exception>
         public void ResumeHaptics(InputDevice device)
@@ -74,9 +81,12 @@ public void ResumeHaptics(InputDevice device)
         }
 
         /// <summary>
-        /// Reset haptics by setting both <see cref="lowFrequencyMotorSpeed"/> and <see cref="highFrequencyMotorSpeed"/>
-        /// to zero.
+        /// Reset haptics by setting motor speeds to zero.
         /// </summary>
+        /// <remarks>
+        /// Sets <see cref="lowFrequencyMotorSpeed"/> and <see cref="highFrequencyMotorSpeed"/> to zero.
+        /// It will only set motor speeds if <see cref="isRumbling"/> is true.
+        /// </remarks>
         /// <param name="device">Device to send command to.</param>
         /// <exception cref="ArgumentNullException"><paramref name="device"/> is null.</exception>
         public void ResetHaptics(InputDevice device)
diff --git a/Packages/com.unity.inputsystem/InputSystem/Devices/InputDevice.cs b/Packages/com.unity.inputsystem/InputSystem/Devices/InputDevice.cs
index f2b469bc73..49c78673c4 100644
--- a/Packages/com.unity.inputsystem/InputSystem/Devices/InputDevice.cs
+++ b/Packages/com.unity.inputsystem/InputSystem/Devices/InputDevice.cs
@@ -41,21 +41,31 @@ namespace UnityEngine.InputSystem
     /// runtime. However, it is possible to manually add devices using methods such as <see
     /// cref="InputSystem.AddDevice{TDevice}(string)"/>.
     ///
-    /// <example>
-    /// <code>
-    /// // Add a "synthetic" gamepad that isn't actually backed by hardware.
-    /// var gamepad = InputSystem.AddDevice&lt;Gamepad&gt;();
-    /// </code>
-    /// </example>
-    ///
     /// There are subclasses representing the most common types of devices, like <see cref="Mouse"/>,
     /// <see cref="Keyboard"/>, <see cref="Gamepad"/>, and <see cref="Touchscreen"/>.
     ///
     /// To create your own types of devices, you can derive from InputDevice and register your device
     /// as a new "layout".
     ///
+    /// Devices can have usages like any other control (<see cref="InputControl.usages"/>). However, usages of InputDevices are allowed to be changed on the fly without requiring a change to the
+    /// device layout (see <see cref="InputSystem.SetDeviceUsage(InputDevice,string)"/>).
+    ///
+    /// For a more complete example of how to implement custom input devices, check out the "Custom Device"
+    /// sample which you can install from the Unity package manager.
+    ///
+    /// You can also find more information in the <a href="../manual/Devices.html">manual</a>.
+    /// </remarks>
     /// <example>
     /// <code>
+    /// using System.Runtime.InteropServices;
+    /// using UnityEditor;
+    /// using UnityEngine;
+    /// using UnityEngine.InputSystem;
+    /// using UnityEngine.InputSystem.Controls;
+    /// using UnityEngine.InputSystem.Layouts;
+    /// using UnityEngine.InputSystem.LowLevel;
+    /// using UnityEngine.InputSystem.Utilities;
+    ///
     /// // InputControlLayoutAttribute attribute is only necessary if you want
     /// // to override default behavior that occurs when registering your device
     /// // as a layout.
@@ -70,6 +80,9 @@ namespace UnityEngine.InputSystem
     ///     public ButtonControl button { get; private set; }
     ///     public AxisControl axis { get; private set; }
     ///
+    ///     // This is an example of how to add a "synthetic" gamepad that isn't actually backed by hardware.
+    ///     Gamepad gamepad = InputSystem.AddDevice&lt;Gamepad&gt;();
+    ///
     ///     // Register the device.
     ///     static MyDevice()
     ///     {
@@ -113,7 +126,7 @@ namespace UnityEngine.InputSystem
     ///     // particular device is connected and fed into the input system.
     ///     // The format is a simple FourCC code that "tags" state memory blocks for the
     ///     // device to give a base level of safety checks on memory operations.
-    ///     public FourCC format => return new FourCC('H', 'I', 'D');
+    ///     public FourCC format => new FourCC('H', 'I', 'D');
     ///
     ///     // InputControlAttributes on fields tell the input system to create controls
     ///     // for the public fields found in the struct.
@@ -121,26 +134,16 @@ namespace UnityEngine.InputSystem
     ///     // Assume a 16bit field of buttons. Create one button that is tied to
     ///     // bit #3 (zero-based). Note that buttons do not need to be stored as bits.
     ///     // They can also be stored as floats or shorts, for example.
-    ///     [InputControl(name = "button", layout = "Button", bit = 3)]
+    ///     [InputControl(name = "button", layout = "Button", bit = 3)] [FieldOffset(0)]
     ///     public ushort buttons;
     ///
     ///     // Create a floating-point axis. The name, if not supplied, is taken from
     ///     // the field.
-    ///     [InputControl(layout = "Axis")]
+    ///     [InputControl(layout = "Axis")] [FieldOffset(0)]
     ///     public short axis;
     /// }
     /// </code>
     /// </example>
-    ///
-    /// Devices can have usages like any other control (<see cref="InputControl.usages"/>). Unlike other controls,
-    /// however, usages of InputDevices are allowed to be changed on the fly without requiring a change to the
-    /// device layout (see <see cref="InputSystem.SetDeviceUsage(InputDevice,string)"/>).
-    ///
-    /// For a more complete example of how to implement custom input devices, check out the "Custom Device"
-    /// sample which you can install from the Unity package manager.
-    ///
-    /// And, as always, you can also find more information in the <a href="../manual/Devices.html">manual</a>.
-    /// </remarks>
     /// <seealso cref="InputControl"/>
     /// <seealso cref="Mouse"/>
     /// <seealso cref="Keyboard"/>
@@ -508,10 +511,26 @@ public virtual void MakeCurrent()
         /// </summary>
         /// <remarks>
         /// This is called <em>after</em> the device has already been added.
+        /// <see cref="InputSystem.devices"/>
+        /// <see cref="InputDeviceChange.Added"/>
+        /// <see cref="OnRemoved"/>
         /// </remarks>
-        /// <seealso cref="InputSystem.devices"/>
-        /// <seealso cref="InputDeviceChange.Added"/>
-        /// <seealso cref="OnRemoved"/>
+        /// <example>
+        /// <code>
+        /// using UnityEngine.InputSystem;
+        ///
+        /// public class MyDevice : InputDevice
+        /// {
+        ///     public static MyDevice current { get; private set; }
+        ///     protected override void OnAdded()
+        ///     {
+        ///         // use this context to assign the current device for instance
+        ///         base.OnAdded();
+        ///         current = this;
+        ///     }
+        /// }
+        /// </code>
+        /// </example>
         protected virtual void OnAdded()
         {
         }
@@ -521,10 +540,27 @@ protected virtual void OnAdded()
         /// </summary>
         /// <remarks>
         /// This is called <em>after</em> the device has already been removed.
+        /// <see cref="InputSystem.devices"/>
+        /// <see cref="InputDeviceChange.Removed"/>
+        /// <see cref="OnAdded"/>
         /// </remarks>
-        /// <seealso cref="InputSystem.devices"/>
-        /// <seealso cref="InputDeviceChange.Removed"/>
-        /// <seealso cref="OnRemoved"/>
+        /// <example>
+        /// <code>
+        /// using UnityEngine.InputSystem;
+        ///
+        /// public class MyDevice : InputDevice
+        /// {
+        ///     public static MyDevice current { get; private set; }
+        ///     protected override void OnRemoved()
+        ///     {
+        ///         // use this context to unassign the current device for instance
+        ///         base.OnRemoved();
+        ///         if (current == this)
+        ///             current = null;
+        ///     }
+        /// }
+        /// </code>
+        /// </example>
         protected virtual void OnRemoved()
         {
         }
@@ -542,7 +578,7 @@ protected virtual void OnRemoved()
         /// </remarks>
         /// <seealso cref="InputManager.OnUpdate"/>
         /// <seealso cref="InputDeviceChange.ConfigurationChanged"/>
-        /// <seealso cref="OnConfigurationChanged"/>///
+        /// <seealso cref="OnConfigurationChanged"/>
         protected virtual void OnConfigurationChanged()
         {
         }
@@ -560,8 +596,8 @@ protected virtual void OnConfigurationChanged()
         /// the device API. This is most useful for devices implemented in the native Unity runtime
         /// which, through the command interface, may provide custom, device-specific functions.
         ///
-        /// This is a low-level API. It works in a similar way to <a href="https://msdn.microsoft.com/en-us/library/windows/desktop/aa363216%28v=vs.85%29.aspx?f=255&amp;MSPPError=-2147217396" target="_blank">
-        /// DeviceIoControl</a> on Windows and <a href="https://developer.apple.com/library/archive/documentation/System/Conceptual/ManPages_iPhoneOS/man2/ioctl.2.html#//apple_ref/doc/man/2/ioctl" target="_blank">ioctl</a>
+        /// This is a low-level API. It works in a similar way to <a href="https://msdn.microsoft.com/en-us/library/windows/desktop/aa363216%28v=vs.85%29.aspx?f=255&amp;MSPPError=-2147217396">
+        /// DeviceIoControl</a> on Windows and <a href="https://developer.apple.com/library/archive/documentation/System/Conceptual/ManPages_iPhoneOS/man2/ioctl.2.html#//apple_ref/doc/man/2/ioctl">ioctl</a>
         /// on UNIX-like systems.
         /// </remarks>
         public unsafe long ExecuteCommand<TCommand>(ref TCommand command)
diff --git a/Packages/com.unity.inputsystem/InputSystem/Devices/Keyboard.cs b/Packages/com.unity.inputsystem/InputSystem/Devices/Keyboard.cs
index 20b8e0ecb3..319e3cc4c0 100644
--- a/Packages/com.unity.inputsystem/InputSystem/Devices/Keyboard.cs
+++ b/Packages/com.unity.inputsystem/InputSystem/Devices/Keyboard.cs
@@ -17,24 +17,32 @@ namespace UnityEngine.InputSystem.LowLevel
     /// </summary>
     /// <remarks>
     /// Can be used to update the state of <see cref="Keyboard"/> devices.
-    ///
+    /// </remarks>
     /// <example>
     /// <code>
-    /// // Send input event with A key pressed on keyboard.
-    /// InputSystem.QueueStateEvent(Keyboard.current,
-    ///     new KeyboardState(Key.A));
+    /// using UnityEngine;
+    /// using UnityEngine.InputSystem;
+    /// using UnityEngine.InputSystem.LowLevel;
+    ///
+    /// public class Example : MonoBehaviour
+    /// {
+    ///     void Start()
+    ///     {
+    ///         // Send input event with A key pressed on keyboard.
+    ///         InputSystem.QueueStateEvent(Keyboard.current,
+    ///             new KeyboardState(Key.A));
+    ///     }
+    /// }
     /// </code>
     /// </example>
-    /// </remarks>
     /// <seealso cref="Keyboard"/>
     // NOTE: This layout has to match the KeyboardInputState layout used in native!
     [StructLayout(LayoutKind.Sequential)]
     public unsafe struct KeyboardState : IInputStateTypeInfo
     {
         /// <summary>
-        /// Memory format tag for KeybboardState.
+        /// Memory format tag for KeyboardState. Returns "KEYS".
         /// </summary>
-        /// <value>Returns "KEYS".</value>
         /// <seealso cref="InputStateBlock.format"/>
         public static FourCC Format => new FourCC('K', 'E', 'Y', 'S');
 
@@ -220,17 +228,25 @@ namespace UnityEngine.InputSystem
     ///
     /// To find the text character (if any) generated by a key according to the currently active keyboard
     /// layout, use the <see cref="InputControl.displayName"/> property of <see cref="KeyControl"/>.
-    ///
+    /// </remarks>
     /// <example>
     /// <code>
-    /// // Look up key by key code.
-    /// var aKey = Keyboard.current[Key.A];
+    /// using UnityEngine;
+    /// using UnityEngine.InputSystem;
     ///
-    /// // Find out which text is produced by the key.
-    /// Debug.Log($"The '{aKey.keyCode}' key produces '{aKey.displayName}' as text input");
+    /// public class Example : MonoBehaviour
+    /// {
+    ///     void LookUpTextInputByKey()
+    ///     {
+    ///         // Look up key by key code.
+    ///         var aKey = Keyboard.current[Key.A];
+    ///
+    ///         // Find out which text is produced by the key.
+    ///         Debug.Log($"The '{aKey.keyCode}' key produces '{aKey.displayName}' as text input");
+    ///     }
+    /// }
     /// </code>
     /// </example>
-    /// </remarks>
     // NOTE: Has to match up with 'KeyboardInputState::KeyCode' in native.
     // NOTE: In the keyboard code, we depend on the order of the keys in the various keyboard blocks.
     public enum Key
@@ -876,6 +892,32 @@ public enum Key
     /// keyboard or not. It is thus not possible to find out this way whether the underlying
     /// keyboard has certain keys or not.
     /// </remarks>
+    /// <example>
+    /// <code>
+    /// using UnityEngine;
+    /// using UnityEngine.InputSystem;
+    ///
+    /// public class InputExample : MonoBehaviour
+    /// {
+    ///     private string inputText = "";
+    ///     void Start()
+    ///     {
+    ///         Keyboard.current.onTextInput += OnTextInput;
+    ///     }
+    ///     void Update()
+    ///     {
+    ///         // Check whether the A key on the current keyboard is pressed.
+    ///         if (Keyboard.current.aKey.wasPressedThisFrame)
+    ///             Debug.Log("A Key pressed");
+    ///     }
+    ///     private void OnTextInput(char ch)
+    ///     {
+    ///         inputText += ch;
+    ///     }
+    /// }
+    /// </code>
+    /// </example>
+    /// <seealso cref="InputDevice"/>
     [InputControlLayout(stateType = typeof(KeyboardState), isGenericTypeOfDevice = true)]
     public class Keyboard : InputDevice, ITextInputReceiver
     {
@@ -883,16 +925,18 @@ public class Keyboard : InputDevice, ITextInputReceiver
         /// Total number of key controls on a keyboard, i.e. the number of controls
         /// in <see cref="allKeys"/>.
         /// </summary>
-        /// <value>Total number of key controls.</value>
         public const int KeyCount = (int)Key.OEM5;
 
         /// <summary>
         /// Event that is fired for every single character entered on the keyboard.
+        /// See <see cref="Keyboard.OnTextInput"/>.
         /// </summary>
-        /// <value>Triggered whenever the keyboard receives text input.</value>
-        /// <remarks>
         /// <example>
         /// <code>
+        /// using System;
+        /// using UnityEngine;
+        /// using UnityEngine.InputSystem;
+        ///
         /// // Let's say we want to do a typing game. We could define a component
         /// // something along those lines to match the typed input.
         /// public class MatchTextByTyping : MonoBehaviour
@@ -932,7 +976,7 @@ public class Keyboard : InputDevice, ITextInputReceiver
         ///         {
         ///             ++m_Position;
         ///             if (m_Position == m_Text.Length)
-        ///                 onTextTypeCorrectly?.Invoke();
+        ///                 onTextTypedCorrectly?.Invoke();
         ///         }
         ///         else
         ///         {
@@ -945,7 +989,6 @@ public class Keyboard : InputDevice, ITextInputReceiver
         /// }
         /// </code>
         /// </example>
-        /// </remarks>
         public event Action<char> onTextInput
         {
             add
@@ -959,11 +1002,13 @@ public event Action<char> onTextInput
         }
 
         /// <summary>
-        /// An event that is fired to get IME composition strings.  Fired once for every change containing the entire string to date.
-        /// When using an IME, this event can be used to display the composition string while it is being edited. When a composition
-        /// string is submitted, one or many <see cref="Keyboard.OnTextInput"/> events will fire with the submitted characters.
+        /// When a user is entering text using IME composition, this event occurs each time the IME composition string changes, and provides the new composition string as a value.
+        /// When using an IME, this event can be used to display the composition string while it is being edited.
         /// </summary>
         /// <remarks>
+        /// The composition string is held by the <see cref="UnityEngine.InputSystem.LowLevel.IMECompositionString"/> struct.
+        /// When a composition string is submitted, one or many <see cref="Keyboard.OnTextInput"/> events will fire with the submitted characters.
+        ///
         /// Some languages use complex input methods which involve opening windows to insert characters.
         /// Typically, this is not desirable while playing a game, as games may just interpret key strokes as game input, not as text.
         ///
@@ -975,11 +1020,20 @@ public event Action<char> onTextInput
         /// <example>
         /// <para>To subscribe to the onIMECompositionChange event, use the following sample code:</para>
         /// <code>
-        /// var compositionString = "";
-        /// Keyboard.current.onIMECompositionChange += composition =>
+        /// using UnityEngine;
+        /// using UnityEngine.InputSystem;
+        ///
+        /// public class KeyboardUtils : MonoBehaviour
         /// {
-        ///    compositionString = composition.ToString();
-        /// };
+        ///     private string compositionString = "";
+        ///
+        ///     void Start(){
+        ///         Keyboard.current.onIMECompositionChange += composition =>
+        ///         {
+        ///             compositionString = composition.ToString();
+        ///         };
+        ///     }
+        /// }
         /// </code>
         /// </example>
         public event Action<IMECompositionString> onIMECompositionChange
@@ -995,7 +1049,7 @@ public event Action<IMECompositionString> onIMECompositionChange
         }
 
         /// <summary>
-        /// Activates/deactivates IME composition while typing.  This decides whether or not to use the OS supplied IME system.
+        /// Activates/deactivates IME composition while typing.  This decides whether to use the OS supplied IME system or not.
         /// </summary>
         /// <remarks>
         ///
@@ -1006,6 +1060,28 @@ public event Action<IMECompositionString> onIMECompositionChange
         /// See <see cref="Keyboard.SetIMECursorPosition"/>, <see cref="Keyboard.onIMECompositionChange"/>,
         /// <see cref="Keyboard.imeSelected"/> for more IME settings and data.
         /// </remarks>
+        /// <param name="enabled">
+        ///     The IME composition enabled state. <see langword="true"/> to enable the IME, <see langword="false"/> to disable it.
+        /// </param>
+        /// <example>
+        /// <code>
+        /// using UnityEngine;
+        /// using UnityEngine.InputSystem;
+        ///
+        /// public class KeyboardUtils : MonoBehaviour
+        /// {
+        ///     private string compositionString = "";
+        ///
+        ///     void Start(){
+        ///         Keyboard.current.SetIMEEnabled(true);
+        ///         Keyboard.current.onIMECompositionChange += composition =>
+        ///         {
+        ///             compositionString = composition.ToString();
+        ///         };
+        ///     }
+        /// }
+        /// </code>
+        /// </example>
         public void SetIMEEnabled(bool enabled)
         {
             var command = EnableIMECompositionCommand.Create(enabled);
@@ -1021,6 +1097,29 @@ public void SetIMEEnabled(bool enabled)
         ///
         /// See <see cref="Keyboard.SetIMEEnabled"/> for turning IME on/off
         /// </remarks>
+        /// <param name="position">
+        ///     A Vector2 of the IME cursor position to set.
+        /// </param>
+        /// <example>
+        /// <code>
+        /// using UnityEngine;
+        /// using UnityEngine.InputSystem;
+        ///
+        /// public class KeyboardUtils : MonoBehaviour
+        /// {
+        ///     private Vector2 cursorPosition;
+        ///
+        ///     void Update ()
+        ///     {
+        ///         // Set the IME cursor position to the mouse position
+        ///         var x = Mouse.current.position.x.ReadValue();
+        ///         var y = Mouse.current.position.y.ReadValue();
+        ///         cursorPosition = new Vector2(x, y);
+        ///         Keyboard.current.SetIMECursorPosition(cursorPosition);
+        ///     }
+        /// }
+        /// </code>
+        /// </example>
         public void SetIMECursorPosition(Vector2 position)
         {
             SetIMECursorPositionCommand command = SetIMECursorPositionCommand.Create(position);
@@ -1051,471 +1150,473 @@ public string keyboardLayout
         /// <summary>
         /// A synthetic button control that is considered pressed if any key on the keyboard is pressed.
         /// </summary>
-        /// <value>Control representing the synthetic "anyKey".</value>
+        /// <remarks><see cref="AnyKeyControl"/> representing the synthetic "anyKey".</remarks>
         public AnyKeyControl anyKey { get; protected set; }
 
         /// <summary>
-        /// The space bar key.
+        /// The space bar key at the bottom of the keyboard.
         /// </summary>
-        /// <value>Control representing the space bar key.</value>
+        /// <remarks><see cref="KeyControl"/> representing the space bar key.</remarks>
         public KeyControl spaceKey => this[Key.Space];
 
         /// <summary>
         /// The enter/return key in the main key block.
         /// </summary>
-        /// <value>Control representing the enter key.</value>
         /// <remarks>
+        /// <see cref="KeyControl"/> representing the enter key.
         /// This key is distinct from the enter key on the numpad which is <see cref="numpadEnterKey"/>.
         /// </remarks>
         public KeyControl enterKey => this[Key.Enter];
 
         /// <summary>
-        /// The tab key.
+        /// The tab key, which is generally located on the left side above the <see cref="capsLockKey"/>.
         /// </summary>
-        /// <value>Control representing the tab key.</value>
+        /// <remarks><see cref="KeyControl"/> representing the tab key.</remarks>
         public KeyControl tabKey => this[Key.Tab];
 
         /// <summary>
         /// The ` key. The leftmost key in the row of digits. Directly above <see cref="tabKey"/>.
         /// </summary>
-        /// <value>Control representing the backtick/quote key.</value>
+        /// <remarks><see cref="KeyControl"/> representing the backtick/quote key.</remarks>
         public KeyControl backquoteKey => this[Key.Backquote];
 
         /// <summary>
         /// The ' key. The key immediately to the left of <see cref="enterKey"/>.
         /// </summary>
-        /// <value>Control representing the quote key.</value>
+        /// <remarks><see cref="KeyControl"/> representing the quote key.</remarks>
         public KeyControl quoteKey => this[Key.Quote];
 
         /// <summary>
         /// The ';' key. The key immediately to the left of <see cref="quoteKey"/>.
         /// </summary>
-        /// <value>Control representing the semicolon key.</value>
+        /// <remarks><see cref="KeyControl"/> representing the semicolon key.</remarks>
         public KeyControl semicolonKey => this[Key.Semicolon];
 
         /// <summary>
         /// The ',' key. Third key to the left of <see cref="rightShiftKey"/>.
         /// </summary>
-        /// <value>Control representing the comma key.</value>
+        /// <remarks><see cref="KeyControl"/> representing the comma key.</remarks>
         public KeyControl commaKey => this[Key.Comma];
 
         /// <summary>
         /// The '.' key. Second key to the left of <see cref="rightShiftKey"/>.
         /// </summary>
-        /// <value>Control representing the period key.</value>
+        /// <remarks><see cref="KeyControl"/> representing the period key.</remarks>
         public KeyControl periodKey => this[Key.Period];
 
         /// <summary>
         /// The '/' key. The key immediately to the left of <see cref="rightShiftKey"/>.
         /// </summary>
-        /// <value>Control representing the forward slash key.</value>
+        /// <remarks><see cref="KeyControl"/> representing the forward slash key.</remarks>
         public KeyControl slashKey => this[Key.Slash];
 
         /// <summary>
         /// The '\' key. The key immediately to the right of <see cref="rightBracketKey"/> and
         /// next to or above <see cref="enterKey"/>.
         /// </summary>
-        /// <value>Control representing the backslash key.</value>
+        /// <remarks><see cref="KeyControl"/> representing the backslash key.</remarks>
         public KeyControl backslashKey => this[Key.Backslash];
 
         /// <summary>
         /// The '[' key. The key immediately to the left of <see cref="rightBracketKey"/>.
         /// </summary>
-        /// <value>Control representing the left bracket key.</value>
+        /// <remarks><see cref="KeyControl"/> representing the left bracket key.</remarks>
         public KeyControl leftBracketKey => this[Key.LeftBracket];
 
         /// <summary>
         /// The ']' key. The key in-between <see cref="leftBracketKey"/> to the left and
         /// <see cref="backslashKey"/> to the right.
         /// </summary>
-        /// <value>Control representing the right bracket key.</value>
+        /// <remarks><see cref="KeyControl"/> representing the right bracket key.</remarks>
         public KeyControl rightBracketKey => this[Key.RightBracket];
 
         /// <summary>
         /// The '-' key. The second key to the left of <see cref="backspaceKey"/>.
         /// </summary>
-        /// <value>Control representing the minus key.</value>
+        /// <remarks><see cref="KeyControl"/> representing the minus key.</remarks>
         public KeyControl minusKey => this[Key.Minus];
 
         /// <summary>
         /// The '=' key in the main key block. The key in-between <see cref="minusKey"/> to the left
         /// and <see cref="backspaceKey"/> to the right.
         /// </summary>
-        /// <value>Control representing the equals key.</value>
+        /// <remarks><see cref="KeyControl"/> representing the equals key.</remarks>
         public KeyControl equalsKey => this[Key.Equals];
 
         /// <summary>
         /// The 'a' key. The key immediately to the right of <see cref="capsLockKey"/>.
         /// </summary>
-        /// <value>Control representing the a key.</value>
+        /// <remarks><see cref="KeyControl"/> representing the a key.</remarks>
         public KeyControl aKey => this[Key.A];
 
         /// <summary>
         /// The 'b' key. The key in-between the <see cref="vKey"/> to the left and the <see cref="nKey"/>
         /// to the right in the bottom-most row of alphabetic characters.
         /// </summary>
-        /// <value>Control representing the b key.</value>
+        /// <remarks><see cref="KeyControl"/> representing the b key.</remarks>
         public KeyControl bKey => this[Key.B];
 
         /// <summary>
         /// The 'c' key. The key in-between the <see cref="xKey"/> to the left and the <see cref="vKey"/>
         /// to the right in the bottom-most row of alphabetic characters.
         /// </summary>
-        /// <value>Control representing the c key.</value>
+        /// <remarks><see cref="KeyControl"/> representing the c key.</remarks>
         public KeyControl cKey => this[Key.C];
 
         /// <summary>
         /// The 'd' key. The key in-between the <see cref="sKey"/> to the left and the <see cref="fKey"/>
         /// to the right in the middle row of alphabetic characters.
         /// </summary>
-        /// <value>Control representing the d key.</value>
+        /// <remarks><see cref="KeyControl"/> representing the d key.</remarks>
         public KeyControl dKey => this[Key.D];
 
         /// <summary>
         /// The 'e' key. The key in-between the <see cref="wKey"/> to the left and the <see cref="rKey"/>
         /// to the right in the topmost row of alphabetic characters.
         /// </summary>
-        /// <value>Control representing the e key.</value>
+        /// <remarks><see cref="KeyControl"/> representing the e key.</remarks>
         public KeyControl eKey => this[Key.E];
 
         /// <summary>
         /// The 'f' key. The key in-between the <see cref="dKey"/> to the left and the <see cref="gKey"/>
         /// to the right in the middle row of alphabetic characters.
         /// </summary>
-        /// <value>Control representing the f key.</value>
+        /// <remarks><see cref="KeyControl"/> representing the f key.</remarks>
         public KeyControl fKey => this[Key.F];
 
         /// <summary>
         /// The 'g' key. The key in-between the <see cref="fKey"/> to the left and the <see cref="hKey"/>
         /// to the right in the middle row of alphabetic characters.
         /// </summary>
-        /// <value>Control representing the g key.</value>
+        /// <remarks><see cref="KeyControl"/> representing the g key.</remarks>
         public KeyControl gKey => this[Key.G];
 
         /// <summary>
         /// The 'h' key. The key in-between the <see cref="gKey"/> to the left and the <see cref="jKey"/>
         /// to the right in the middle row of alphabetic characters.
         /// </summary>
-        /// <value>Control representing the h key.</value>
+        /// <remarks><see cref="KeyControl"/> representing the h key.</remarks>
         public KeyControl hKey => this[Key.H];
 
         /// <summary>
         /// The 'i' key. The key in-between the <see cref="uKey"/> to the left and the <see cref="oKey"/>
         /// to the right in the top row of alphabetic characters.
         /// </summary>
+        /// <remarks><see cref="KeyControl"/> representing the i key.</remarks>
         public KeyControl iKey => this[Key.I];
 
         /// <summary>
         /// The 'j' key. The key in-between the <see cref="hKey"/> to the left and the <see cref="kKey"/>
         /// to the right in the middle row of alphabetic characters.
         /// </summary>
-        /// <value>Control representing the j key.</value>
+        /// <remarks><see cref="KeyControl"/> representing the j key.</remarks>
         public KeyControl jKey => this[Key.J];
 
         /// <summary>
         /// The 'k' key. The key in-between the <see cref="jKey"/> to the left and the <see cref="lKey"/>
         /// to the right in the middle row of alphabetic characters.
         /// </summary>
-        /// <value>Control representing the k key.</value>
+        /// <remarks><see cref="KeyControl"/> representing the k key.</remarks>
         public KeyControl kKey => this[Key.K];
 
         /// <summary>
         /// The 'l' key. The key in-between the <see cref="kKey"/> to the left and the <see cref="semicolonKey"/>
         /// to the right in the middle row of alphabetic characters.
         /// </summary>
-        /// <value>Control representing the l key.</value>
+        /// <remarks><see cref="KeyControl"/> representing the l key.</remarks>
         public KeyControl lKey => this[Key.L];
 
         /// <summary>
         /// The 'm' key. The key in-between the <see cref="nKey"/> to the left and the <see cref="commaKey"/>
         /// to the right in the bottom row of alphabetic characters.
         /// </summary>
-        /// <value>Control representing the m key.</value>
+        /// <remarks><see cref="KeyControl"/> representing the m key.</remarks>
         public KeyControl mKey => this[Key.M];
 
         /// <summary>
         /// The 'n' key. The key in-between the <see cref="bKey"/> to the left and the <see cref="mKey"/> to
         /// the right in the bottom row of alphabetic characters.
         /// </summary>
-        /// <value>Control representing the n key.</value>
+        /// <remarks><see cref="KeyControl"/> representing the n key.</remarks>
         public KeyControl nKey => this[Key.N];
 
         /// <summary>
         /// The 'o' key. The key in-between the <see cref="iKey"/> to the left and the <see cref="pKey"/> to
         /// the right in the top row of alphabetic characters.
         /// </summary>
-        /// <value>Control representing the o key.</value>
+        /// <remarks><see cref="KeyControl"/> representing the o key.</remarks>
         public KeyControl oKey => this[Key.O];
 
         /// <summary>
         /// The 'p' key. The key in-between the <see cref="oKey"/> to the left and the <see cref="leftBracketKey"/>
         /// to the right in the top row of alphabetic characters.
         /// </summary>
-        /// <value>Control representing the p key.</value>
+        /// <remarks><see cref="KeyControl"/> representing the p key.</remarks>
         public KeyControl pKey => this[Key.P];
 
         /// <summary>
         /// The 'q' key. The key in-between the <see cref="tabKey"/> to the left and the <see cref="wKey"/>
         /// to the right in the top row of alphabetic characters.
         /// </summary>
-        /// <value>Control representing the q key.</value>
+        /// <remarks><see cref="KeyControl"/> representing the q key.</remarks>
         public KeyControl qKey => this[Key.Q];
 
         /// <summary>
         /// The 'r' key. The key in-between the <see cref="eKey"/> to the left and the <see cref="tKey"/>
         /// to the right in the top row of alphabetic characters.
         /// </summary>
-        /// <value>Control representing the r key.</value>
+        /// <remarks><see cref="KeyControl"/> representing the r key.</remarks>
         public KeyControl rKey => this[Key.R];
 
         /// <summary>
         /// The 's' key. The key in-between the <see cref="aKey"/> to the left and the <see cref="dKey"/>
         /// to the right in the middle row of alphabetic characters.
         /// </summary>
-        /// <value>Control representing the s key.</value>
+        /// <remarks><see cref="KeyControl"/> representing the s key.</remarks>
         public KeyControl sKey => this[Key.S];
 
         /// <summary>
         /// The 't' key. The key in-between the <see cref="rKey"/> to the left and the <see cref="yKey"/>
         /// to the right in the top row of alphabetic characters.
         /// </summary>
-        /// <value>Control representing the t key.</value>
+        /// <remarks><see cref="KeyControl"/> representing the t key.</remarks>
         public KeyControl tKey => this[Key.T];
 
         /// <summary>
         /// The 'u' key. The key in-between the <see cref="yKey"/> to the left and the <see cref="iKey"/>
         /// to the right in the top row of alphabetic characters.
         /// </summary>
-        /// <value>Control representing the u key.</value>
+        /// <remarks><see cref="KeyControl"/> representing the u key.</remarks>
         public KeyControl uKey => this[Key.U];
 
         /// <summary>
         /// The 'v' key. The key in-between the <see cref="cKey"/> to the left and the <see cref="bKey"/>
         /// to the right in the bottom row of alphabetic characters.
         /// </summary>
-        /// <value>Control representing the v key.</value>
+        /// <remarks><see cref="KeyControl"/> representing the v key.</remarks>
         public KeyControl vKey => this[Key.V];
 
         /// <summary>
         /// The 'w' key. The key in-between the <see cref="qKey"/> to the left and the <see cref="eKey"/>
         /// to the right in the top row of alphabetic characters.
         /// </summary>
-        /// <value>Control representing the w key.</value>
+        /// <remarks><see cref="KeyControl"/> representing the w key.</remarks>
         public KeyControl wKey => this[Key.W];
 
         /// <summary>
         /// The 'x' key. The key in-between the <see cref="zKey"/> to the left and the <see cref="cKey"/>
         /// to the right in the bottom row of alphabetic characters.
         /// </summary>
-        /// <value>Control representing the x key.</value>
+        /// <remarks><see cref="KeyControl"/> representing the x key.</remarks>
         public KeyControl xKey => this[Key.X];
 
         /// <summary>
         /// The 'y' key. The key in-between the <see cref="tKey"/> to the left and the <see cref="uKey"/>
         /// to the right in the top row of alphabetic characters.
         /// </summary>
-        /// <value>Control representing the y key.</value>
+        /// <remarks><see cref="KeyControl"/> representing the y key.</remarks>
         public KeyControl yKey => this[Key.Y];
 
         /// <summary>
         /// The 'z' key. The key in-between the <see cref="leftShiftKey"/> to the left and the <see cref="xKey"/>
         /// to the right in the bottom row of alphabetic characters.
         /// </summary>
-        /// <value>Control representing the z key.</value>
+        /// <remarks><see cref="KeyControl"/> representing the z key.</remarks>
         public KeyControl zKey => this[Key.Z];
 
         /// <summary>
         /// The '1' key. The key in-between the <see cref="backquoteKey"/> to the left and the <see cref="digit2Key"/>
         /// to the right in the row of digit characters.
         /// </summary>
-        /// <value>Control representing the 1 key.</value>
+        /// <remarks><see cref="KeyControl"/> representing the 1 key.</remarks>
         public KeyControl digit1Key => this[Key.Digit1];
 
         /// <summary>
         /// The '2' key. The key in-between the <see cref="digit1Key"/> to the left and the <see cref="digit3Key"/>
         /// to the right in the row of digit characters.
         /// </summary>
-        /// <value>Control representing the 2 key.</value>
+        /// <remarks><see cref="KeyControl"/> representing the 2 key.</remarks>
         public KeyControl digit2Key => this[Key.Digit2];
 
         /// <summary>
         /// The '3' key. The key in-between the <see cref="digit2Key"/> to the left and the <see cref="digit4Key"/>
         /// to the right in the row of digit characters.
         /// </summary>
-        /// <value>Control representing the 3 key.</value>
+        /// <remarks><see cref="KeyControl"/> representing the 3 key.</remarks>
         public KeyControl digit3Key => this[Key.Digit3];
 
         /// <summary>
         /// The '4' key. The key in-between the <see cref="digit3Key"/> to the left and the <see cref="digit5Key"/>
         /// to the right in the row of digit characters.
         /// </summary>
-        /// <value>Control representing the 4 key.</value>
+        /// <remarks><see cref="KeyControl"/> representing the 4 key.</remarks>
         public KeyControl digit4Key => this[Key.Digit4];
 
         /// <summary>
         /// The '5' key. The key in-between the <see cref="digit4Key"/> to the left and the <see cref="digit6Key"/>
         /// to the right in the row of digit characters.
         /// </summary>
-        /// <value>Control representing the 5 key.</value>
+        /// <remarks><see cref="KeyControl"/> representing the 5 key.</remarks>
         public KeyControl digit5Key => this[Key.Digit5];
 
         /// <summary>
         /// The '6' key. The key in-between the <see cref="digit5Key"/> to the left and the <see cref="digit7Key"/>
         /// to the right in the row of digit characters.
         /// </summary>
-        /// <value>Control representing the 6 key.</value>
+        /// <remarks><see cref="KeyControl"/> representing the 6 key.</remarks>
         public KeyControl digit6Key => this[Key.Digit6];
 
         /// <summary>
         /// The '7' key. The key in-between the <see cref="digit6Key"/> to the left and the <see cref="digit8Key"/>
         /// to the right in the row of digit characters.
         /// </summary>
-        /// <value>Control representing the 7 key.</value>
+        /// <remarks><see cref="KeyControl"/> representing the 7 key.</remarks>
         public KeyControl digit7Key => this[Key.Digit7];
 
         /// <summary>
         /// The '8' key. The key in-between the <see cref="digit7Key"/> to the left and the <see cref="digit9Key"/>
         /// to the right in the row of digit characters.
         /// </summary>
-        /// <value>Control representing the 8 key.</value>
+        /// <remarks><see cref="KeyControl"/> representing the 8 key.</remarks>
         public KeyControl digit8Key => this[Key.Digit8];
 
         /// <summary>
         /// The '9' key. The key in-between the <see cref="digit8Key"/> to the left and the <see cref="digit0Key"/>
         /// to the right in the row of digit characters.
         /// </summary>
-        /// <value>Control representing the 9 key.</value>
+        /// <remarks><see cref="KeyControl"/> representing the 9 key.</remarks>
         public KeyControl digit9Key => this[Key.Digit9];
 
         /// <summary>
         /// The '0' key. The key in-between the <see cref="digit9Key"/> to the left and the <see cref="minusKey"/>
         /// to the right in the row of digit characters.
         /// </summary>
-        /// <value>Control representing the 0 key.</value>
+        /// <remarks><see cref="KeyControl"/> representing the 0 key.</remarks>
         public KeyControl digit0Key => this[Key.Digit0];
 
         /// <summary>
         /// The shift key on the left side of the keyboard.
         /// </summary>
-        /// <value>Control representing the left shift key.</value>
+        /// <remarks><see cref="KeyControl"/> representing the left shift key.</remarks>
         public KeyControl leftShiftKey => this[Key.LeftShift];
 
         /// <summary>
         /// The shift key on the right side of the keyboard.
         /// </summary>
-        /// <value>Control representing the right shift key.</value>
+        /// <remarks><see cref="KeyControl"/> representing the right shift key.</remarks>
         public KeyControl rightShiftKey => this[Key.RightShift];
 
         /// <summary>
         /// The alt/option key on the left side of the keyboard.
         /// </summary>
-        /// <value>Control representing the left alt/option key.</value>
+        /// <remarks><see cref="KeyControl"/> representing the left alt/option key.</remarks>
         public KeyControl leftAltKey => this[Key.LeftAlt];
 
         /// <summary>
         /// The alt/option key on the right side of the keyboard.
         /// </summary>
-        /// <value>Control representing the right alt/option key.</value>
+        /// <remarks><see cref="KeyControl"/> representing the right alt/option key.</remarks>
         public KeyControl rightAltKey => this[Key.RightAlt];
 
         /// <summary>
         /// The control/ctrl key on the left side of the keyboard.
         /// </summary>
-        /// <value>Control representing the left control key.</value>
+        /// <remarks><see cref="KeyControl"/> representing the left control key.</remarks>
         public KeyControl leftCtrlKey => this[Key.LeftCtrl];
 
         /// <summary>
         /// The control/ctrl key on the right side of the keyboard.
         /// </summary>
-        /// <remarks>This key is usually not present on Mac laptops.</remarks>
-        /// <value>Control representing the right control key.</value>
+        /// <remarks>
+        /// This key is usually not present on Mac laptops.
+        /// <see cref="KeyControl"/> representing the right control key.
+        /// </remarks>
         public KeyControl rightCtrlKey => this[Key.RightCtrl];
 
         /// <summary>
         /// The system "meta" key (Windows key on PC, Apple/command key on Mac) on the left
         /// side of the keyboard.
         /// </summary>
-        /// <value>Control representing the left system meta key.</value>
+        /// <remarks><see cref="KeyControl"/> representing the left system meta key.</remarks>
         public KeyControl leftMetaKey => this[Key.LeftMeta];
 
         /// <summary>
         /// The system "meta" key (Windows key on PC, Apple/command key on Mac) on the right
         /// side of the keyboard.
         /// </summary>
-        /// <value>Control representing the right system meta key.</value>
+        /// <remarks><see cref="KeyControl"/> representing the right system meta key.</remarks>
         public KeyControl rightMetaKey => this[Key.RightMeta];
 
         /// <summary>
         /// Same as <see cref="leftMetaKey"/>. Windows system key on left side of keyboard.
         /// </summary>
-        /// <value>Control representing the left Windows system key.</value>
+        /// <remarks><see cref="KeyControl"/> representing the left Windows system key.</remarks>
         public KeyControl leftWindowsKey => this[Key.LeftWindows];
 
         /// <summary>
         /// Same as <see cref="rightMetaKey"/>. Windows system key on right side of keyboard.
         /// </summary>
-        /// <value>Control representing the right Windows system key.</value>
+        /// <remarks><see cref="KeyControl"/> representing the right Windows system key.</remarks>
         public KeyControl rightWindowsKey => this[Key.RightWindows];
 
         /// <summary>
         /// Same as <see cref="leftMetaKey"/>. Apple/command system key on left side of keyboard.
         /// </summary>
-        /// <value>Control representing the left Apple/command system key.</value>
+        /// <remarks><see cref="KeyControl"/> representing the left Apple/command system key.</remarks>
         public KeyControl leftAppleKey => this[Key.LeftApple];
 
         /// <summary>
         /// Same as <see cref="rightMetaKey"/>. Apple/command system key on right side of keyboard.
         /// </summary>
-        /// <value>Control representing the right Apple/command system key.</value>
+        /// <remarks><see cref="KeyControl"/> representing the right Apple/command system key.</remarks>
         public KeyControl rightAppleKey => this[Key.RightApple];
 
         /// <summary>
         /// Same as <see cref="leftMetaKey"/>. Apple/command system key on left side of keyboard.
         /// </summary>
-        /// <value>Control representing the left Apple/command system key.</value>
+        /// <remarks><see cref="KeyControl"/> representing the left Apple/command system key.</remarks>
         public KeyControl leftCommandKey => this[Key.LeftCommand];
 
         /// <summary>
         /// Same as <see cref="rightMetaKey"/>. Apple/command system key on right side of keyboard.
         /// </summary>
-        /// <value>Control representing the right Apple/command system key.</value>
+        /// <remarks><see cref="KeyControl"/> representing the right Apple/command system key.</remarks>
         public KeyControl rightCommandKey => this[Key.RightCommand];
 
         /// <summary>
-        /// The context menu key. This key is generally only found on PC keyboards. If present,
-        /// the key is found in-between the <see cref="rightWindowsKey"/> to the left and the
-        /// <see cref="rightCtrlKey"/> to the right. It's intention is to bring up the context
-        /// menu according to the current selection.
+        /// The context menu key. This key is generally only found on PC keyboards.
+        /// If present, it is located in-between the <see cref="rightWindowsKey"/> and the
+        /// <see cref="rightCtrlKey"/>. It brings up the context menu according to the current selection.
         /// </summary>
-        /// <value>Control representing the context menu key.</value>
+        /// <remarks><see cref="KeyControl"/> representing the context menu key.</remarks>
         public KeyControl contextMenuKey => this[Key.ContextMenu];
 
         /// <summary>
         /// The escape key, i.e. the key generally in the top left corner of the keyboard.
         /// Usually to the left of <see cref="f1Key"/>.
         /// </summary>
-        /// <value>Control representing the escape key.</value>
+        /// <remarks><see cref="KeyControl"/> representing the escape key.</remarks>
         public KeyControl escapeKey => this[Key.Escape];
 
         /// <summary>
         /// The left arrow key. Usually in a block by itself and generally to the left
         /// of <see cref="downArrowKey"/>.
         /// </summary>
-        /// <value>Control representing the left arrow key.</value>
+        /// <remarks><see cref="KeyControl"/> representing the left arrow key.</remarks>
         public KeyControl leftArrowKey => this[Key.LeftArrow];
 
         /// <summary>
         /// The right arrow key. Usually in a block by itself and generally to the right
         /// of <see cref="downArrowKey"/>
         /// </summary>
-        /// <value>Control representing the right arrow key.</value>
+        /// <remarks><see cref="KeyControl"/> representing the right arrow key.</remarks>
         public KeyControl rightArrowKey => this[Key.RightArrow];
 
         /// <summary>
         /// The up arrow key. Usually in a block by itself and generally on top of the
         /// <see cref="downArrowKey"/>.
         /// </summary>
-        /// <value>Control representing the up arrow key.</value>
+        /// <remarks><see cref="KeyControl"/> representing the up arrow key.</remarks>
         public KeyControl upArrowKey => this[Key.UpArrow];
 
         /// <summary>
@@ -1523,15 +1624,16 @@ public string keyboardLayout
         /// <see cref="upArrowKey"/> and in-between <see cref="leftArrowKey"/> to the
         /// left and <see cref="rightArrowKey"/> to the right.
         /// </summary>
-        /// <value>Control representing the down arrow key.</value>
+        /// <remarks><see cref="KeyControl"/> representing the down arrow key.</remarks>
         public KeyControl downArrowKey => this[Key.DownArrow];
 
         /// <summary>
         /// The backspace key (usually labeled "delete" on Mac). The rightmost key
         /// in the top digit row with <see cref="equalsKey"/> to the left.
         /// </summary>
-        /// <value>Control representing the backspace key.</value>
         /// <remarks>
+        /// <see cref="KeyControl"/> representing the backspace key.
+        ///
         /// On the Mac, this key may be labeled "delete" which however is a
         /// key different from <see cref="deleteKey"/>.
         /// </remarks>
@@ -1541,43 +1643,44 @@ public string keyboardLayout
         /// The page down key. Usually in a separate block with <see cref="endKey"/>
         /// to the left and <see cref="pageUpKey"/> above it.
         /// </summary>
-        /// <value>Control representing the page down key.</value>
+        /// <remarks><see cref="KeyControl"/> representing the page down key.</remarks>
         public KeyControl pageDownKey => this[Key.PageDown];
 
         /// <summary>
         /// The page up key. Usually in a separate block with <see cref="homeKey"/>
         /// to the left and <see cref="pageDownKey"/> below it.
         /// </summary>
-        /// <value>Control representing the page up key.</value>
+        /// <remarks><see cref="KeyControl"/> representing the page up key.</remarks>
         public KeyControl pageUpKey => this[Key.PageUp];
 
         /// <summary>
         /// The 'home' key. Usually in a separate block with <see cref="pageUpKey"/>
         /// to the right and <see cref="insertKey"/> to the left.
         /// </summary>
-        /// <value>Control representing the insert key.</value>
+        /// <remarks><see cref="KeyControl"/> representing the insert key.</remarks>
         public KeyControl homeKey => this[Key.Home];
 
         /// <summary>
         /// The 'end' key. Usually in a separate block with <see cref="deleteKey"/>
         /// to the left and <see cref="pageDownKey"/> to the right.
         /// </summary>
-        /// <value>Control representing the end key.</value>
+        /// <remarks><see cref="KeyControl"/> representing the end key.</remarks>
         public KeyControl endKey => this[Key.End];
 
         /// <summary>
         /// The 'insert' key. Usually in a separate block with <see cref="homeKey"/>
         /// to its right and <see cref="deleteKey"/> sitting below it.
         /// </summary>
-        /// <value>Control representing the insert key.</value>
+        /// <remarks><see cref="KeyControl"/> representing the insert key.</remarks>
         public KeyControl insertKey => this[Key.Insert];
 
         /// <summary>
         /// The 'delete' key. Usually in a separate block with <see cref="endKey"/>
         /// to its right and <see cref="insertKey"/> sitting above it.
         /// </summary>
-        /// <value>Control representing the delete key.</value>
         /// <remarks>
+        /// <see cref="KeyControl"/> representing the delete key.
+        ///
         /// On the Mac, the <see cref="backspaceKey"/> is also labeled "delete".
         /// However, this is not this key.
         /// </remarks>
@@ -1587,7 +1690,7 @@ public string keyboardLayout
         /// The Caps Lock key. The key below <see cref="tabKey"/> and above
         /// <see cref="leftShiftKey"/>.
         /// </summary>
-        /// <value>Control representing the caps lock key.</value>
+        /// <remarks><see cref="KeyControl"/> representing the caps lock key.</remarks>
         public KeyControl capsLockKey => this[Key.CapsLock];
 
         /// <summary>
@@ -1595,7 +1698,7 @@ public string keyboardLayout
         /// to the left and the <see cref="pauseKey"/> to the right. May also
         /// be labeled "F14".
         /// </summary>
-        /// <value>Control representing the scroll lock key.</value>
+        /// <remarks><see cref="KeyControl"/> representing the scroll lock key.</remarks>
         public KeyControl scrollLockKey => this[Key.ScrollLock];
 
         /// <summary>
@@ -1603,7 +1706,7 @@ public string keyboardLayout
         /// numpad and which usually toggles the numpad between generating
         /// digits and triggering functions like "insert" etc. instead.
         /// </summary>
-        /// <value>Control representing the num lock key.</value>
+        /// <remarks><see cref="KeyControl"/> representing the num lock key.</remarks>
         public KeyControl numLockKey => this[Key.NumLock];
 
         /// <summary>
@@ -1611,29 +1714,30 @@ public string keyboardLayout
         /// to the left and <see cref="scrollLockKey"/> to the right. May also
         /// be labeled "F13".
         /// </summary>
-        /// <value>Control representing the print screen key.</value>
+        /// <remarks><see cref="KeyControl"/> representing the print screen key.</remarks>
         public KeyControl printScreenKey => this[Key.PrintScreen];
 
         /// <summary>
         /// The pause/break key. The key sitting to the left of <see cref="scrollLockKey"/>.
         /// May also be labeled "F15".
         /// </summary>
-        /// <value>Control representing the pause/break key.</value>
+        /// <remarks><see cref="KeyControl"/> representing the pause/break key.</remarks>
         public KeyControl pauseKey => this[Key.Pause];
 
         /// <summary>
         /// The enter key on the numpad. The key sitting in the bottom right corner
         /// of the numpad.
         /// </summary>
-        /// <value>Control representing the numpad enter key.</value>
+        /// <remarks><see cref="KeyControl"/> representing the numpad enter key.</remarks>
         public KeyControl numpadEnterKey => this[Key.NumpadEnter];
 
         /// <summary>
         /// The divide ('/') key on the numpad. The key in-between <see cref="numpadEqualsKey"/>
         /// to the left and <see cref="numpadMultiplyKey"/> to the right.
         /// </summary>
-        /// <value>Control representing the numpad divide key.</value>
         /// <remarks>
+        /// <see cref="KeyControl"/> representing the numpad divide key.
+        ///
         /// PC keyboards usually have a 17-key numpad layout that differs from the 18-key layout
         /// we use for reference. The 18-key layout is usually found on Mac keyboards. The numpad
         /// divide key usually is the <see cref="numpadEqualsKey"/> on PC keyboards.
@@ -1645,8 +1749,9 @@ public string keyboardLayout
         /// with <see cref="numpadDivideKey"/> to the left and <see cref="numpadMultiplyKey"/>
         /// below it.
         /// </summary>
-        /// <value>Control representing the numpad multiply key.</value>
         /// <remarks>
+        /// <see cref="KeyControl"/> representing the numpad multiply key.
+        ///
         /// PC keyboards usually have a 17-key numpad layout that differs from the 18-key layout
         /// we use for reference. The 18-key layout is usually found on Mac keyboards. The numpad
         /// multiply key usually is the <see cref="numpadMinusKey"/> on PC keyboards.
@@ -1657,8 +1762,9 @@ public string keyboardLayout
         /// The minus ('-') key on the numpad. The key on the right side of the numpad with
         /// <see cref="numpadMultiplyKey"/> above it and <see cref="numpadPlusKey"/> below it.
         /// </summary>
-        /// <value>Control representing the numpad minus key.</value>
         /// <remarks>
+        /// <see cref="KeyControl"/> representing the numpad minus key.
+        ///
         /// PC keyboards usually have a 17-key numpad layout that differs from the 18-key layout
         /// we use for reference. The 18-key layout is usually found on Mac keyboards. The numpad
         /// minus key is usually <em>not</em> present on PC keyboards. Instead, the 17-key layout
@@ -1670,8 +1776,9 @@ public string keyboardLayout
         /// The plus ('+') key on the numpad. The key on the right side of the numpad with
         /// <see cref="numpadMinusKey"/> above it and <see cref="numpadEnterKey"/> below it.
         /// </summary>
-        /// <value>Control representing the numpad plus key.</value>
         /// <remarks>
+        /// <see cref="KeyControl"/> representing the numpad plus key.
+        ///
         /// PC keyboards usually have a 17-key numpad layout that differs from the 18-key layout
         /// we use for reference. The 18-key layout is usually found on Mac keyboards.
         ///
@@ -1687,8 +1794,9 @@ public string keyboardLayout
         /// The period ('.') key on the numpad. The key in-between the <see cref="numpadEnterKey"/>
         /// to the right and the <see cref="numpad0Key"/> to the left.
         /// </summary>
-        /// <value>Control representing the numpad period key.</value>
         /// <remarks>
+        /// <see cref="KeyControl"/> representing the numpad period key.
+        ///
         /// This key is the same in 17-key and 18-key numpad layouts.
         /// </remarks>
         public KeyControl numpadPeriodKey => this[Key.NumpadPeriod];
@@ -1697,8 +1805,9 @@ public string keyboardLayout
         /// The equals ('=') key on the numpad. The key in-between <see cref="numLockKey"/> to the left
         /// and <see cref="numpadDivideKey"/> to the right in the top row of the numpad.
         /// </summary>
-        /// <value>Control representing the numpad equals key.</value>
         /// <remarks>
+        /// <see cref="KeyControl"/> representing the numpad equals key.
+        ///
         /// PC keyboards usually have a 17-key numpad layout that differs from the 18-key layout
         /// we use for reference. The 18-key layout is usually found on Mac keyboards.
         ///
@@ -1711,63 +1820,63 @@ public string keyboardLayout
         /// The 0 key on the numpad. The key in the bottom left corner of the numpad. Usually
         /// and elongated key.
         /// </summary>
-        /// <value>Control representing the numpad 0 key.</value>
+        /// <remarks><see cref="KeyControl"/> representing the numpad 0 key.</remarks>
         public KeyControl numpad0Key => this[Key.Numpad0];
 
         /// <summary>
         /// The 1 key on the numpad. The key on the left side of the numpad with <see cref="numpad0Key"/>
         /// below it and <see cref="numpad4Key"/> above it.
         /// </summary>
-        /// <value>Control representing the numpad 1 key.</value>
+        /// <remarks><see cref="KeyControl"/> representing the numpad 1 key.</remarks>
         public KeyControl numpad1Key => this[Key.Numpad1];
 
         /// <summary>
         /// The 2 key on the numpad. The key with the <see cref="numpad1Key"/> to its left and
         /// the <see cref="numpad3Key"/> to its right.
         /// </summary>
-        /// <value>Control representing the numpad 2 key.</value>
+        /// <remarks><see cref="KeyControl"/> representing the numpad 2 key.</remarks>
         public KeyControl numpad2Key => this[Key.Numpad2];
 
         /// <summary>
         /// The 3 key on the numpad. The key with the <see cref="numpad2Key"/> to its left and
         /// the <see cref="numpadEnterKey"/> to its right.
         /// </summary>
-        /// <value>Control representing the numpad 3 key.</value>
+        /// <remarks><see cref="KeyControl"/> representing the numpad 3 key.</remarks>
         public KeyControl numpad3Key => this[Key.Numpad3];
 
         /// <summary>
         /// The 4 key on the numpad. The key on the left side of the numpad with the <see cref="numpad1Key"/>
         /// below it and the <see cref="numpad7Key"/> above it.
         /// </summary>
-        /// <value>Control representing the numpad 4 key.</value>
+        /// <remarks><see cref="KeyControl"/> representing the numpad 4 key.</remarks>
         public KeyControl numpad4Key => this[Key.Numpad4];
 
         /// <summary>
         /// The 5 key on the numpad. The key in-between the <see cref="numpad4Key"/> to the left and the
         /// <see cref="numpad6Key"/> to the right.
         /// </summary>
-        /// <value>Control representing the numpad 5 key.</value>
+        /// <remarks><see cref="KeyControl"/> representing the numpad 5 key.</remarks>
         public KeyControl numpad5Key => this[Key.Numpad5];
 
         /// <summary>
         /// The 6 key on the numpad. The key in-between the <see cref="numpad5Key"/> to the let and
         /// the <see cref="numpadPlusKey"/> to the right.
         /// </summary>
-        /// <value>Control representing the numpad 6 key.</value>
+        /// <remarks><see cref="KeyControl"/> representing the numpad 6 key.</remarks>
         public KeyControl numpad6Key => this[Key.Numpad6];
 
         /// <summary>
         /// The 7 key on the numpad. The key on the left side of the numpad with <see cref="numpad4Key"/>
         /// below it and <see cref="numLockKey"/> above it.
         /// </summary>
-        /// <value>Control representing the numpad 7 key.</value>
+        /// <remarks><see cref="KeyControl"/> representing the numpad 7 key.</remarks>
         public KeyControl numpad7Key => this[Key.Numpad7];
 
         /// <summary>
         /// The 8 key on the numpad. The key in-between the <see cref="numpad7Key"/> to the left and the
         /// <see cref="numpad9Key"/> to the right.
         /// </summary>
-        /// <value>Control representing the numpad 8 key.</value>
+        /// <remarks><see cref="KeyControl"/> representing the numpad 8 key.</remarks>
         public KeyControl numpad8Key => this[Key.Numpad8];
 
         /// <summary>
@@ -1775,98 +1884,99 @@ public string keyboardLayout
         /// the <see cref="numpadMinusKey"/> to the right (or, on 17-key PC keyboard numpads, the elongated
         /// plus key).
         /// </summary>
-        /// <value>Control representing the numpad 9 key.</value>
+        /// <remarks><see cref="KeyControl"/> representing the numpad 9 key.</remarks>
         public KeyControl numpad9Key => this[Key.Numpad9];
 
         /// <summary>
         /// The F1 key. The key in-between <see cref="escapeKey"/> to the left and <see cref="f1Key"/>
         /// to the right in the topmost row of keys.
         /// </summary>
-        /// <value>Control representing the F1 key.</value>
+        /// <remarks><see cref="KeyControl"/> representing the F1 key.</remarks>
         public KeyControl f1Key => this[Key.F1];
 
         /// <summary>
         /// The F2 key. The key in-between <see cref="f1Key"/> to the left and <see cref="f3Key"/>
         /// to the right in the topmost row of keys.
         /// </summary>
-        /// <value>Control representing the F2 key.</value>
+        /// <remarks><see cref="KeyControl"/> representing the F2 key.</remarks>
         public KeyControl f2Key => this[Key.F2];
 
         /// <summary>
         /// The F3 key. The key in-between <see cref="f2Key"/> to the left and <see cref="f4Key"/>
         /// to the right in the topmost row of keys.
         /// </summary>
-        /// <value>Control representing the F3 key.</value>
+        /// <remarks><see cref="KeyControl"/> representing the F3 key.</remarks>
         public KeyControl f3Key => this[Key.F3];
 
         /// <summary>
         /// The F4 key. The key in-between <see cref="f3Key"/> to the left and <see cref="f5Key"/>
         /// to the right in the topmost row of keys.
         /// </summary>
-        /// <value>Control representing the F4 key.</value>
+        /// <remarks><see cref="KeyControl"/> representing the F4 key.</remarks>
         public KeyControl f4Key => this[Key.F4];
 
         /// <summary>
         /// The F5 key. The key in-between <see cref="f4Key"/> to the left and <see cref="f6Key"/>
         /// to the right in the topmost row of keys.
         /// </summary>
-        /// <value>Control representing the F5 key.</value>
+        /// <remarks><see cref="KeyControl"/> representing the F5 key.</remarks>
         public KeyControl f5Key => this[Key.F5];
 
         /// <summary>
         /// The F6 key. The key in-between <see cref="f5Key"/> to the left and <see cref="f7Key"/>
         /// to the right in the topmost row of keys.
         /// </summary>
-        /// <value>Control representing the F6 key.</value>
+        /// <remarks><see cref="KeyControl"/> representing the F6 key.</remarks>
         public KeyControl f6Key => this[Key.F6];
 
         /// <summary>
         /// The F7 key. The key in-between <see cref="f6Key"/> to the left and <see cref="f8Key"/>
         /// to the right in the topmost row of keys.
         /// </summary>
-        /// <value>Control representing the F7 key.</value>
+        /// <remarks><see cref="KeyControl"/> representing the F7 key.</remarks>
         public KeyControl f7Key => this[Key.F7];
 
         /// <summary>
         /// The F8 key. The key in-between <see cref="f7Key"/> to the left and <see cref="f9Key"/>
         /// to the right in the topmost row of keys.
         /// </summary>
-        /// <value>Control representing the F8 key.</value>
+        /// <remarks><see cref="KeyControl"/> representing the F8 key.</remarks>
         public KeyControl f8Key => this[Key.F8];
 
         /// <summary>
         /// The F9 key. The key in-between <see cref="f8Key"/> to the left and <see cref="f10Key"/>
         /// to the right in the topmost row of keys.
         /// </summary>
-        /// <value>Control representing the F9 key.</value>
+        /// <remarks><see cref="KeyControl"/> representing the F9 key.</remarks>
         public KeyControl f9Key => this[Key.F9];
 
         /// <summary>
         /// The F10 key. The key in-between <see cref="f9Key"/> to the left and <see cref="f11Key"/>
         /// to the right in the topmost row of keys.
         /// </summary>
-        /// <value>Control representing the F10 key.</value>
+        /// <remarks><see cref="KeyControl"/> representing the F10 key.</remarks>
         public KeyControl f10Key => this[Key.F10];
 
         /// <summary>
         /// The F11 key. The key in-between <see cref="f10Key"/> to the left and <see cref="f12Key"/>
         /// to the right in the topmost row of keys.
         /// </summary>
-        /// <value>Control representing the F11 key.</value>
+        /// <remarks><see cref="KeyControl"/> representing the F11 key.</remarks>
         public KeyControl f11Key => this[Key.F11];
 
         /// <summary>
         /// The F12 key. The key in-between <see cref="f11Key"/> to the left and <see cref="printScreenKey"/>
         /// to the right in the topmost row of keys.
         /// </summary>
-        /// <value>Control representing the F12 key.</value>
+        /// <remarks><see cref="KeyControl"/> representing the F12 key.</remarks>
         public KeyControl f12Key => this[Key.F12];
 
         /// <summary>
         /// First additional key on the keyboard.
         /// </summary>
-        /// <value>Control representing <see cref="Key.OEM1"/>.</value>
         /// <remarks>
+        /// <see cref="KeyControl"/> representing <see cref="Key.OEM1"/>.
+        ///
         /// Keyboards may have additional keys that are not part of the standardized 104-key keyboard layout
         /// (105 in the case of an 18-key numpad). For example, many non-English keyboard layouts have an additional
         /// key in-between <see cref="leftShiftKey"/> and <see cref="zKey"/>.
@@ -1880,8 +1990,9 @@ public string keyboardLayout
         /// <summary>
         /// Second additional key on the keyboard.
         /// </summary>
-        /// <value>Control representing <see cref="Key.OEM2"/>.</value>
         /// <remarks>
+        /// <see cref="KeyControl"/> representing <see cref="Key.OEM2"/>.
+        ///
         /// Keyboards may have additional keys that are not part of the standardized 104-key keyboard layout
         /// (105 in the case of an 18-key numpad). For example, many non-English keyboard layouts have an additional
         /// key in-between <see cref="leftShiftKey"/> and <see cref="zKey"/>.
@@ -1895,8 +2006,9 @@ public string keyboardLayout
         /// <summary>
         /// Third additional key on the keyboard.
         /// </summary>
-        /// <value>Control representing <see cref="Key.OEM3"/>.</value>
         /// <remarks>
+        /// <see cref="KeyControl"/> representing <see cref="Key.OEM3"/>.
+        ///
         /// Keyboards may have additional keys that are not part of the standardized 104-key keyboard layout
         /// (105 in the case of an 18-key numpad). For example, many non-English keyboard layouts have an additional
         /// key in-between <see cref="leftShiftKey"/> and <see cref="zKey"/>.
@@ -1910,8 +2022,9 @@ public string keyboardLayout
         /// <summary>
         /// Fourth additional key on the keyboard.
         /// </summary>
-        /// <value>Control representing <see cref="Key.OEM4"/>.</value>
         /// <remarks>
+        /// <see cref="KeyControl"/> representing <see cref="Key.OEM4"/>.
+        ///
         /// Keyboards may have additional keys that are not part of the standardized 104-key keyboard layout
         /// (105 in the case of an 18-key numpad). For example, many non-English keyboard layouts have an additional
         /// key in-between <see cref="leftShiftKey"/> and <see cref="zKey"/>.
@@ -1925,8 +2038,9 @@ public string keyboardLayout
         /// <summary>
         /// Fifth additional key on the keyboard.
         /// </summary>
-        /// <value>Control representing <see cref="Key.OEM5"/>.</value>
         /// <remarks>
+        /// <see cref="KeyControl"/> representing <see cref="Key.OEM5"/>.
+        ///
         /// Keyboards may have additional keys that are not part of the standardized 104-key keyboard layout
         /// (105 in the case of an 18-key numpad). For example, many non-English keyboard layouts have an additional
         /// key in-between <see cref="leftShiftKey"/> and <see cref="zKey"/>.
@@ -1940,8 +2054,9 @@ public string keyboardLayout
         /// <summary>
         /// An artificial combination of <see cref="leftShiftKey"/> and <see cref="rightShiftKey"/> into one control.
         /// </summary>
-        /// <value>Control representing a combined left and right shift key.</value>
         /// <remarks>
+        /// <see cref="ButtonControl"/> representing a combined left and right shift key.
+        ///
         /// This is a <see cref="InputControl.synthetic"/> button which is considered pressed whenever the left and/or
         /// right shift key is pressed.
         /// </remarks>
@@ -1950,8 +2065,9 @@ public string keyboardLayout
         /// <summary>
         /// An artificial combination of <see cref="leftCtrlKey"/> and <see cref="rightCtrlKey"/> into one control.
         /// </summary>
-        /// <value>Control representing a combined left and right ctrl key.</value>
         /// <remarks>
+        /// <see cref="ButtonControl"/> representing a combined left and right ctrl key.
+        ///
         /// This is a <see cref="InputControl.synthetic"/> button which is considered pressed whenever the left and/or
         /// right ctrl key is pressed.
         /// </remarks>
@@ -1960,8 +2076,9 @@ public string keyboardLayout
         /// <summary>
         /// An artificial combination of <see cref="leftAltKey"/> and <see cref="rightAltKey"/> into one control.
         /// </summary>
-        /// <value>Control representing a combined left and right alt key.</value>
         /// <remarks>
+        /// <see cref="ButtonControl"/> representing a combined left and right alt key.
+        ///
         /// This is a <see cref="InputControl.synthetic"/> button which is considered pressed whenever the left and/or
         /// right alt key is pressed.
         /// </remarks>
@@ -1971,9 +2088,8 @@ public string keyboardLayout
         /// True when IME composition is enabled.  Requires <see cref="Keyboard.SetIMEEnabled"/> to be called to enable IME, and the user to enable it at the OS level.
         /// </summary>
         /// <remarks>
-        ///
         /// Some languages use complex input methods which involve opening windows to insert characters.
-        /// Typically, this is not desirable while playing a game, as games may just interpret key strokes as game input, not as text.
+        /// Typically, this is not desirable while playing a game, as games may just interpret keystrokes as game input, not as text.
         ///
         /// See <see cref="Keyboard.SetIMEEnabled"/> for turning IME on/off
         /// </remarks>
@@ -1983,7 +2099,7 @@ public string keyboardLayout
         /// Look up a key control by its key code.
         /// </summary>
         /// <param name="key">Key code of key control to return.</param>
-        /// <exception cref="ArgumentOutOfRangeException">The given <paramref cref="key"/> is not valid.</exception>
+        /// <exception cref="ArgumentOutOfRangeException">The given <paramref name="key"/> is not valid.</exception>
         /// <remarks>
         /// This is equivalent to <c>allKeys[(int)key - 1]</c>.
         /// </remarks>
@@ -2008,22 +2124,35 @@ public KeyControl this[Key key]
         /// </summary>
         public static Keyboard current { get; private set; }
 
-        /// <summary>
-        /// Make the keyboard the current keyboard (i.e. <see cref="current"/>).
-        /// </summary>
+        /// <inheritdoc cref="InputDevice.MakeCurrent"/>
         /// <remarks>
         /// A keyboard will automatically be made current when receiving input or when
         /// added to the input system.
+        /// The currently active keyboard is tracked in <see cref="Keyboard.current"/>.
         /// </remarks>
+        /// <example>
+        /// <code>
+        /// using UnityEngine;
+        /// using UnityEngine.InputSystem;
+        ///
+        /// public class InputExample : MonoBehaviour
+        /// {
+        ///     void Start()
+        ///     {
+        ///         // Add a keyboard and make it the current keyboard.
+        ///         var keyboard = InputSystem.AddDevice("Keyboard");
+        ///         keyboard.MakeCurrent();
+        ///     }
+        /// }
+        /// </code>
+        /// </example>
         public override void MakeCurrent()
         {
             base.MakeCurrent();
             current = this;
         }
 
-        /// <summary>
-        /// Called when the keyboard is removed from the system.
-        /// </summary>
+        /// <inheritdoc/>
         protected override void OnRemoved()
         {
             base.OnRemoved();
@@ -2035,6 +2164,27 @@ protected override void OnRemoved()
         /// Called after the keyboard has been constructed but before it is added to
         /// the system.
         /// </summary>
+        /// <remarks>
+        /// This method can be overridden to perform control- or device-specific setup work. The most
+        /// common use case is for looking up child controls and storing them in local getters.
+        ///</remarks>
+        /// <example>
+        /// <code>
+        /// using UnityEngine.InputSystem;
+        /// using UnityEngine.InputSystem.Controls;
+        ///
+        /// public class MyKeyboard : Keyboard
+        /// {
+        ///     public ButtonControl button { get; private set; }
+        ///
+        ///     protected override void FinishSetup()
+        ///     {
+        ///         // Cache controls in getters.
+        ///         button = (ButtonControl)GetChildControl("button");
+        ///     }
+        /// }
+        /// </code>
+        /// </example>
         protected override void FinishSetup()
         {
             var keyStrings = new[]
@@ -2182,11 +2332,26 @@ protected override void RefreshConfiguration()
         /// <summary>
         /// Called when text input on the keyboard is received.
         /// </summary>
-        /// <param name="character">Character that has been entered.</param>
+        /// <param name="character">A <see langword="char"/> type value that represents the character that has been entered.</param>
         /// <remarks>
-        /// The system will call this automatically whenever a <see cref="TextEvent"/> is
-        /// received that targets the keyboard device.
+        /// The system will call this method automatically whenever a <see cref="TextEvent"/> is
+        /// received that targets the keyboard device. Subscribe to this event by using <see cref="onTextInput"/>.
         /// </remarks>
+        /// <example>
+        /// <code>
+        /// using UnityEngine;
+        /// using UnityEngine.InputSystem;
+        ///
+        /// public class OnTextInputExample : MonoBehaviour
+        /// {
+        ///     // Simulate text input event on the current keyboard.
+        ///     private void FakeInput()
+        ///     {
+        ///         Keyboard.current.OnTextInput('a');
+        ///     }
+        /// }
+        /// </code>
+        /// </example>
         public void OnTextInput(char character)
         {
             for (var i = 0; i < m_TextInputListeners.length; ++i)
@@ -2204,11 +2369,22 @@ public void OnTextInput(char character)
         /// In most cases, this means that the key inputs the given text when pressed. However, this does not have to be the
         /// case. Keys do not necessarily lead to character input.
         ///
+        /// </remarks>
         /// <example>
-        /// // Find key that prints 'q' character (if any).
-        /// Keyboard.current.FindKeyOnCurrentKeyboardLayout("q");
+        /// <code>
+        /// using UnityEngine;
+        /// using UnityEngine.InputSystem;
+        ///
+        /// public class KeyboardUtils : MonoBehaviour
+        /// {
+        ///     private void FindKey()
+        ///     {
+        ///         // Retrieve the q key on the current keyboard layout.
+        ///         Keyboard.current.FindKeyOnCurrentKeyboardLayout("q");
+        ///     }
+        /// }
+        /// </code>
         /// </example>
-        /// </remarks>
         /// <seealso cref="keyboardLayout"/>
         public KeyControl FindKeyOnCurrentKeyboardLayout(string displayName)
         {
@@ -2219,6 +2395,33 @@ public KeyControl FindKeyOnCurrentKeyboardLayout(string displayName)
             return null;
         }
 
+        /// <summary>
+        /// This is called to set the IME composition strings. Fired once for every change containing the entire string.
+        /// </summary>
+        /// <param name="compositionString">The <see cref="IMECompositionString"/> for the IME composition.</param>
+        /// <remarks>
+        /// To call back to the changed composition string, subscribe to the <see cref="onIMECompositionChange"/> event.
+        /// </remarks>
+        /// <example>
+        /// <code>
+        /// using UnityEngine;
+        /// using UnityEngine.InputSystem;
+        /// using UnityEngine.InputSystem.LowLevel;
+        ///
+        /// public class KeyboardUtils : MonoBehaviour
+        /// {
+        ///     private string compositionString = "";
+        ///     void ChangeIMEComposition()
+        ///     {
+        ///         // Manually creating an input event to change the IME composition
+        ///         var inputEvent = IMECompositionEvent.Create(Keyboard.current.deviceId, "CompositionTestCharacters! ɝ", Time.time);
+        ///         Keyboard.current.OnIMECompositionChanged(inputEvent.compositionString);
+        ///     }
+        /// }
+        /// </code>
+        /// </example>
+        /// <seealso cref="IMECompositionString"/>
+        /// <seealso cref="onIMECompositionChange"/>
         public void OnIMECompositionChanged(IMECompositionString compositionString)
         {
             if (m_ImeCompositionListeners.length > 0)
diff --git a/Packages/com.unity.inputsystem/InputSystem/Devices/Mouse.cs b/Packages/com.unity.inputsystem/InputSystem/Devices/Mouse.cs
index 9c67513fa4..1740b9e3c2 100644
--- a/Packages/com.unity.inputsystem/InputSystem/Devices/Mouse.cs
+++ b/Packages/com.unity.inputsystem/InputSystem/Devices/Mouse.cs
@@ -171,18 +171,37 @@ namespace UnityEngine.InputSystem
     /// An input device representing a mouse.
     /// </summary>
     /// <remarks>
-    /// Adds a scroll wheel and a typical 3-button setup with a left, middle, and right
-    /// button.
+    /// Adds a scroll wheel and a typical 5-button setup with a left, middle, right,
+    /// forward and backward button.
     ///
     /// To control cursor display and behavior, use <see cref="UnityEngine.Cursor"/>.
     /// </remarks>
+    /// <example>
+    ///
+    /// <code>
+    /// using UnityEngine;
+    /// using UnityEngine.InputSystem;
+    ///
+    /// public class ExampleScript : MonoBehaviour
+    /// {
+    ///     void Update()
+    ///     {
+    ///         // If there is a current mouse and the left button was pressed
+    ///         if (Mouse.current != null &amp;&amp; Mouse.current.leftButton.wasPressedThisFrame)
+    ///         {
+    ///              // handle left mouse button being pressed
+    ///         }
+    ///     }
+    /// }
+    /// </code>
+    /// </example>
+    /// <seealso cref="Pointer"/>
     [InputControlLayout(stateType = typeof(MouseState), isGenericTypeOfDevice = true)]
     public class Mouse : Pointer, IInputStateCallbackReceiver
     {
         /// <summary>
-        /// The horizontal and vertical scroll wheels.
+        /// Control representing horizontal and vertical scroll wheels of a Mouse device.
         /// </summary>
-        /// <value>Control representing the mouse scroll wheels.</value>
         /// <remarks>
         /// The <c>x</c> component corresponds to the horizontal scroll wheel, the
         /// <c>y</c> component to the vertical scroll wheel. Most mice do not have
@@ -191,58 +210,57 @@ public class Mouse : Pointer, IInputStateCallbackReceiver
         public DeltaControl scroll { get; protected set; }
 
         /// <summary>
-        /// The left mouse button.
+        /// Control representing left button of a Mouse device.
         /// </summary>
-        /// <value>Control representing the left mouse button.</value>
         public ButtonControl leftButton { get; protected set; }
 
         /// <summary>
-        /// The middle mouse button.
+        /// Control representing middle button of a Mouse device.
         /// </summary>
-        /// <value>Control representing the middle mouse button.</value>
         public ButtonControl middleButton { get; protected set; }
 
         /// <summary>
-        /// The right mouse button.
+        /// Control representing right button of a Mouse device.
         /// </summary>
-        /// <value>Control representing the right mouse button.</value>
         public ButtonControl rightButton { get; protected set; }
 
         /// <summary>
-        /// The first side button, often labeled/used as "back".
+        /// Control representing the first side button, often labeled/used as "back", of a Mouse device.
         /// </summary>
-        /// <value>Control representing the back button on the mouse.</value>
         /// <remarks>
         /// On Windows, this corresponds to <c>RI_MOUSE_BUTTON_4</c>.
         /// </remarks>
         public ButtonControl backButton { get; protected set; }
 
         /// <summary>
-        /// The second side button, often labeled/used as "forward".
+        /// Control representing the second side button, often labeled/used as "forward", of a Mouse device.
         /// </summary>
-        /// <value>Control representing the forward button on the mouse.</value>
         /// <remarks>
         /// On Windows, this corresponds to <c>RI_MOUSE_BUTTON_5</c>.
         /// </remarks>
         public ButtonControl forwardButton { get; protected set; }
 
         /// <summary>
-        /// Number of times any of the mouse buttons has been clicked in succession within
+        /// Control representing the number of times any of the mouse buttons has been clicked in succession within
         /// the system-defined click time threshold.
         /// </summary>
-        /// <value>Control representing the mouse click count.</value>
         public IntegerControl clickCount { get; protected set;  }
 
         /// <summary>
         /// The mouse that was added or updated last or null if there is no mouse
         /// connected to the system.
         /// </summary>
-        /// <seealso cref="InputDevice.MakeCurrent"/>
+        /// <remarks>
+        /// To set a mouse device as current, use <see cref="Mouse.MakeCurrent"/>.
+        /// </remarks>
         public new static Mouse current { get; private set; }
 
         /// <summary>
         /// Called when the mouse becomes the current mouse.
         /// </summary>
+        /// <remarks>
+        /// This is called automatically by the system when there is input on a connected mouse.
+        /// </remarks>
         public override void MakeCurrent()
         {
             base.MakeCurrent();
@@ -274,7 +292,9 @@ protected override void OnRemoved()
 
         ////REVIEW: how should we handle this being called from EditorWindow's? (where the editor window space processor will turn coordinates automatically into editor window space)
         /// <summary>
-        /// Move the operating system's mouse cursor.
+        /// Move the operating system's mouse cursor by performing a device command in a similar way to <a href="https://msdn.microsoft.com/en-us/library/windows/desktop/aa363216%28v=vs.85%29.aspx?f=255&amp;MSPPError=-2147217396" >
+        /// DeviceIoControl</a> on Windows and <a href="https://developer.apple.com/library/archive/documentation/System/Conceptual/ManPages_iPhoneOS/man2/ioctl.2.html#//apple_ref/doc/man/2/ioctl" >ioctl</a>
+        /// on UNIX-like systems.
         /// </summary>
         /// <param name="position">New position in player window space.</param>
         /// <remarks>
@@ -313,7 +333,9 @@ protected override void FinishSetup()
         /// <summary>
         /// Implements <see cref="IInputStateCallbackReceiver.OnStateEvent"/> for the mouse.
         /// </summary>
-        /// <param name="eventPtr"></param>
+        /// <param name="eventPtr">Pointer to an <see cref="InputEvent"/>. Makes it easier to
+        /// work with InputEvents and hides the unsafe operations necessary to work with them.
+        /// </param>
         protected new unsafe void OnStateEvent(InputEventPtr eventPtr)
         {
             scroll.AccumulateValueInEvent(currentStatePtr, eventPtr);
diff --git a/Packages/com.unity.inputsystem/InputSystem/Devices/Pen.cs b/Packages/com.unity.inputsystem/InputSystem/Devices/Pen.cs
index 96b0257c67..9c0f8e5a07 100644
--- a/Packages/com.unity.inputsystem/InputSystem/Devices/Pen.cs
+++ b/Packages/com.unity.inputsystem/InputSystem/Devices/Pen.cs
@@ -98,8 +98,10 @@ public struct PenState : IInputStateTypeInfo
         [FieldOffset(32)]
         public ushort buttons;
 
-        // Not currently used, but still needed in this struct for padding,
-        // as il2cpp does not implement FieldOffset.
+        /// <summary>
+        /// The index of the display that was touched.
+        /// </summary>
+        [InputControl(name = "displayIndex", displayName = "Display Index", layout = "Integer")]
         [FieldOffset(34)]
         ushort displayIndex;
 
@@ -379,6 +381,7 @@ protected override void FinishSetup()
             inRange = GetChildControl<ButtonControl>("inRange");
             tilt = GetChildControl<Vector2Control>("tilt");
             twist = GetChildControl<AxisControl>("twist");
+            displayIndex = GetChildControl<IntegerControl>("displayIndex");
             base.FinishSetup();
         }
     }
diff --git a/Packages/com.unity.inputsystem/InputSystem/Devices/Precompiled/FastKeyboard.cs b/Packages/com.unity.inputsystem/InputSystem/Devices/Precompiled/FastKeyboard.cs
index a88bd0784b..8f7b888534 100644
--- a/Packages/com.unity.inputsystem/InputSystem/Devices/Precompiled/FastKeyboard.cs
+++ b/Packages/com.unity.inputsystem/InputSystem/Devices/Precompiled/FastKeyboard.cs
@@ -1,7 +1,7 @@
 //------------------------------------------------------------------------------
 // <auto-generated>
 //     This code was auto-generated by com.unity.inputsystem:InputLayoutCodeGenerator
-//     version 1.11.3
+//     version 1.12.0
 //     from "Keyboard" layout
 //
 //     Changes to this file may cause incorrect behavior and will be lost if
diff --git a/Packages/com.unity.inputsystem/InputSystem/Devices/Precompiled/FastMouse.cs b/Packages/com.unity.inputsystem/InputSystem/Devices/Precompiled/FastMouse.cs
index cde3f67046..98fa06543a 100644
--- a/Packages/com.unity.inputsystem/InputSystem/Devices/Precompiled/FastMouse.cs
+++ b/Packages/com.unity.inputsystem/InputSystem/Devices/Precompiled/FastMouse.cs
@@ -1,7 +1,7 @@
 //------------------------------------------------------------------------------
 // <auto-generated>
 //     This code was auto-generated by com.unity.inputsystem:InputLayoutCodeGenerator
-//     version 1.11.3
+//     version 1.12.0
 //     from "Mouse" layout
 //
 //     Changes to this file may cause incorrect behavior and will be lost if
diff --git a/Packages/com.unity.inputsystem/InputSystem/Devices/Precompiled/FastTouchscreen.cs b/Packages/com.unity.inputsystem/InputSystem/Devices/Precompiled/FastTouchscreen.cs
index e563c51633..c899aeda76 100644
--- a/Packages/com.unity.inputsystem/InputSystem/Devices/Precompiled/FastTouchscreen.cs
+++ b/Packages/com.unity.inputsystem/InputSystem/Devices/Precompiled/FastTouchscreen.cs
@@ -1,7 +1,7 @@
 //------------------------------------------------------------------------------
 // <auto-generated>
 //     This code was auto-generated by com.unity.inputsystem:InputLayoutCodeGenerator
-//     version 1.11.3
+//     version 1.12.0
 //     from "Touchscreen" layout
 //
 //     Changes to this file may cause incorrect behavior and will be lost if
diff --git a/Packages/com.unity.inputsystem/InputSystem/Editor/AssetEditor/InputActionEditorWindow.cs b/Packages/com.unity.inputsystem/InputSystem/Editor/AssetEditor/InputActionEditorWindow.cs
index f3fcc1ab33..2aa6a7d990 100644
--- a/Packages/com.unity.inputsystem/InputSystem/Editor/AssetEditor/InputActionEditorWindow.cs
+++ b/Packages/com.unity.inputsystem/InputSystem/Editor/AssetEditor/InputActionEditorWindow.cs
@@ -45,7 +45,7 @@ static InputActionEditorWindow()
         public static bool OnOpenAsset(int instanceId, int line)
         {
 #if UNITY_INPUT_SYSTEM_PROJECT_WIDE_ACTIONS
-            if (!InputSystem.settings.IsFeatureEnabled(InputFeatureNames.kUseIMGUIEditorForAssets))
+            if (!InputSystem.settings.useIMGUIEditorForAssets)
                 return false;
 #endif
             var path = AssetDatabase.GetAssetPath(instanceId);
diff --git a/Packages/com.unity.inputsystem/InputSystem/Editor/AssetEditor/ParameterListView.cs b/Packages/com.unity.inputsystem/InputSystem/Editor/AssetEditor/ParameterListView.cs
index d7bf20c47c..4e1df4bb84 100644
--- a/Packages/com.unity.inputsystem/InputSystem/Editor/AssetEditor/ParameterListView.cs
+++ b/Packages/com.unity.inputsystem/InputSystem/Editor/AssetEditor/ParameterListView.cs
@@ -280,6 +280,7 @@ void OnEditEnd()
                 {
                     var intValue = parameter.value.value.ToInt32();
                     var field = new DropdownField(label.text, parameter.enumNames.Select(x => x.text).ToList(), intValue);
+                    field.tooltip = label.tooltip;
                     field.RegisterValueChangedCallback(evt => OnValueChanged(ref parameter, field.index, closedIndex));
                     field.RegisterCallback<BlurEvent>(_ => OnEditEnd());
                     root.Add(field);
@@ -287,7 +288,7 @@ void OnEditEnd()
                 else if (parameter.value.type == TypeCode.Int64 || parameter.value.type == TypeCode.UInt64)
                 {
                     var longValue = parameter.value.value.ToInt64();
-                    var field = new LongField(label.text) { value = longValue };
+                    var field = new LongField(label.text) { value = longValue, tooltip = label.tooltip };
                     field.RegisterValueChangedCallback(evt => OnValueChanged(ref parameter, evt.newValue, closedIndex));
                     field.RegisterCallback<BlurEvent>(_ => OnEditEnd());
                     root.Add(field);
@@ -295,7 +296,7 @@ void OnEditEnd()
                 else if (parameter.value.type.IsInt())
                 {
                     var intValue = parameter.value.value.ToInt32();
-                    var field = new IntegerField(label.text) { value = intValue };
+                    var field = new IntegerField(label.text) { value = intValue, tooltip = label.tooltip };
                     field.RegisterValueChangedCallback(evt => OnValueChanged(ref parameter, evt.newValue, closedIndex));
                     field.RegisterCallback<BlurEvent>(_ => OnEditEnd());
                     root.Add(field);
@@ -303,7 +304,7 @@ void OnEditEnd()
                 else if (parameter.value.type == TypeCode.Single)
                 {
                     var floatValue = parameter.value.value.ToSingle();
-                    var field = new FloatField(label.text) { value = floatValue };
+                    var field = new FloatField(label.text) { value = floatValue, tooltip = label.tooltip };
                     field.RegisterValueChangedCallback(evt => OnValueChanged(ref parameter, evt.newValue, closedIndex));
                     field.RegisterCallback<BlurEvent>(_ => OnEditEnd());
                     root.Add(field);
@@ -311,7 +312,7 @@ void OnEditEnd()
                 else if (parameter.value.type == TypeCode.Double)
                 {
                     var floatValue = parameter.value.value.ToDouble();
-                    var field = new DoubleField(label.text) { value = floatValue };
+                    var field = new DoubleField(label.text) { value = floatValue, tooltip = label.tooltip };
                     field.RegisterValueChangedCallback(evt => OnValueChanged(ref parameter, evt.newValue, closedIndex));
                     field.RegisterCallback<BlurEvent>(_ => OnEditEnd());
                     root.Add(field);
@@ -319,7 +320,7 @@ void OnEditEnd()
                 else if (parameter.value.type == TypeCode.Boolean)
                 {
                     var boolValue = parameter.value.value.ToBoolean();
-                    var field = new Toggle(label.text) { value = boolValue };
+                    var field = new Toggle(label.text) { value = boolValue, tooltip = label.tooltip };
                     field.RegisterValueChangedCallback(evt => OnValueChanged(ref parameter, evt.newValue, closedIndex));
                     field.RegisterValueChangedCallback(_ => OnEditEnd());
                     root.Add(field);
@@ -352,7 +353,7 @@ public void OnGUI()
 
 #if UNITY_INPUT_SYSTEM_PROJECT_WIDE_ACTIONS
             // handled by OnDrawVisualElements with UI Toolkit
-            if (!InputSystem.settings.IsFeatureEnabled(InputFeatureNames.kUseIMGUIEditorForAssets)) return;
+            if (!InputSystem.settings.useIMGUIEditorForAssets) return;
 #endif
             // Otherwise, fall back to our default logic.
             if (m_Parameters == null)
diff --git a/Packages/com.unity.inputsystem/InputSystem/Editor/AssetImporter/InputActionImporterEditor.cs b/Packages/com.unity.inputsystem/InputSystem/Editor/AssetImporter/InputActionImporterEditor.cs
index f13391c2e2..74244994c8 100644
--- a/Packages/com.unity.inputsystem/InputSystem/Editor/AssetImporter/InputActionImporterEditor.cs
+++ b/Packages/com.unity.inputsystem/InputSystem/Editor/AssetImporter/InputActionImporterEditor.cs
@@ -150,7 +150,7 @@ private static void OpenEditor(InputActionAsset asset)
             }
 
             // Redirect to UI-Toolkit window editor if not configured to use IMGUI explicitly
-            if (!InputSystem.settings.IsFeatureEnabled(InputFeatureNames.kUseIMGUIEditorForAssets))
+            if (!InputSystem.settings.useIMGUIEditorForAssets)
                 InputActionsEditorWindow.OpenEditor(asset);
             else
                 InputActionEditorWindow.OpenEditor(asset);
diff --git a/Packages/com.unity.inputsystem/InputSystem/Editor/InputParameterEditor.cs b/Packages/com.unity.inputsystem/InputSystem/Editor/InputParameterEditor.cs
index cbb906652a..2ecbf89e00 100644
--- a/Packages/com.unity.inputsystem/InputSystem/Editor/InputParameterEditor.cs
+++ b/Packages/com.unity.inputsystem/InputSystem/Editor/InputParameterEditor.cs
@@ -249,8 +249,16 @@ public void OnDrawVisualElements(VisualElement root, Action onChangedCallback)
 
                 m_HelpBox = new HelpBox(m_HelpBoxText.text, HelpBoxMessageType.None);
 
-                m_DefaultToggle = new Toggle("Default") { value = m_UseDefaultValue };
+                m_DefaultToggle = new Toggle("Default")
+                {
+                    value = m_UseDefaultValue,
+                    style =
+                    {
+                        flexDirection = FlexDirection.RowReverse
+                    }
+                };
                 m_DefaultToggle.RegisterValueChangedCallback(evt => ToggleUseDefaultValue(evt, onChangedCallback));
+                m_DefaultToggle.Q<Label>().style.minWidth = new StyleLength(StyleKeyword.Auto);
 
 
                 var buttonContainer = new VisualElement
diff --git a/Packages/com.unity.inputsystem/InputSystem/Editor/InputSystemPackageControl.cs b/Packages/com.unity.inputsystem/InputSystem/Editor/InputSystemPackageControl.cs
new file mode 100644
index 0000000000..8fba9fe05f
--- /dev/null
+++ b/Packages/com.unity.inputsystem/InputSystem/Editor/InputSystemPackageControl.cs
@@ -0,0 +1,49 @@
+#if UNITY_EDITOR && UNITY_2020_2_OR_NEWER
+using System;
+using System.Collections.ObjectModel;
+using UnityEditor;
+using UnityEditor.PackageManager;
+
+namespace UnityEngine.InputSystem.Editor
+{
+    /// <summary>
+    /// Forces the Editor to restart if the InputSystem package is removed to activate and initialize it on the managed side.
+    /// Automatically sets "Project Settings > Player > Active Input Handling" to "Input Manager" once the package is removed.
+    /// </summary>
+    internal class InputSystemPackageControl
+    {
+        const string packageName = "com.unity.inputsystem";
+
+        [InitializeOnLoadMethod]
+        static void  SubscribePackageManagerEvent()
+        {
+            //There's a number of cases where it might not be called, for instance if the user changed the project manifest and deleted the Library folder before opening the project
+            UnityEditor.PackageManager.Events.registeringPackages += CheckForInputSystemPackageRemoved;
+        }
+
+        private static void CheckForInputSystemPackageRemoved(PackageRegistrationEventArgs packageArgs)
+        {
+            if (IsInputSystemRemoved(packageArgs.removed))
+                HandleInputSystemRemoved();
+        }
+
+        private static bool IsInputSystemRemoved(ReadOnlyCollection<UnityEditor.PackageManager.PackageInfo> packages)
+        {
+            foreach (var package in packages)
+            {
+                if (package.name == packageName)
+                    return true;
+            }
+            return false;
+        }
+
+        private static void HandleInputSystemRemoved()
+        {
+            //Set input handling to InputManager
+            EditorPlayerSettingHelpers.newSystemBackendsEnabled = false;
+            if (EditorUtility.DisplayDialog("The Unity Editor needs to be restarted", "You've removed the Input System package. This requires a restart of the Unity Editor.", "Restart the Editor", "Ignore (Not recommended)"))
+                EditorApplication.OpenProject(Environment.CurrentDirectory);
+        }
+    }
+}
+#endif
diff --git a/Packages/com.unity.inputsystem/InputSystem/Editor/InputSystemPackageControl.cs.meta b/Packages/com.unity.inputsystem/InputSystem/Editor/InputSystemPackageControl.cs.meta
new file mode 100644
index 0000000000..bd16b2d4b4
--- /dev/null
+++ b/Packages/com.unity.inputsystem/InputSystem/Editor/InputSystemPackageControl.cs.meta
@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 40a0b3d771450454796d773d18ae0c31
\ No newline at end of file
diff --git a/Packages/com.unity.inputsystem/InputSystem/Editor/PropertyDrawers/InputActionDrawerBase.cs b/Packages/com.unity.inputsystem/InputSystem/Editor/PropertyDrawers/InputActionDrawerBase.cs
index a817161c6c..06d2df3fe5 100644
--- a/Packages/com.unity.inputsystem/InputSystem/Editor/PropertyDrawers/InputActionDrawerBase.cs
+++ b/Packages/com.unity.inputsystem/InputSystem/Editor/PropertyDrawers/InputActionDrawerBase.cs
@@ -180,9 +180,12 @@ public static void Show(Rect btnRect, PropertiesViewBase view)
                 window.ShowAsDropDown(btnRect, new Vector2(300, 350));
             }
 
+            private Vector2 m_ScrollPos;
             private void OnGUI()
             {
+                m_ScrollPos = EditorGUILayout.BeginScrollView(m_ScrollPos);
                 m_PropertyView.OnGUI();
+                EditorGUILayout.EndScrollView();
             }
 
             private PropertiesViewBase m_PropertyView;
diff --git a/Packages/com.unity.inputsystem/InputSystem/Editor/UITKAssetEditor/Commands/ControlSchemeCommands.cs b/Packages/com.unity.inputsystem/InputSystem/Editor/UITKAssetEditor/Commands/ControlSchemeCommands.cs
index 3dfa009b1b..33d186f8a3 100644
--- a/Packages/com.unity.inputsystem/InputSystem/Editor/UITKAssetEditor/Commands/ControlSchemeCommands.cs
+++ b/Packages/com.unity.inputsystem/InputSystem/Editor/UITKAssetEditor/Commands/ControlSchemeCommands.cs
@@ -18,7 +18,7 @@ public static Command AddNewControlScheme()
             {
                 state.m_Analytics?.RegisterControlSchemeEdit();
                 return state.With(selectedControlScheme: new InputControlScheme(
-                    MakeUniqueControlSchemeName(state, kNewControlSchemeName)));
+                    MakeUniqueControlSchemeName(state, kNewControlSchemeName)), selectedDeviceRequirementIndex: -1);
             };
         }
 
diff --git a/Packages/com.unity.inputsystem/InputSystem/Editor/UITKAssetEditor/InputActionsEditorWindow.cs b/Packages/com.unity.inputsystem/InputSystem/Editor/UITKAssetEditor/InputActionsEditorWindow.cs
index f5147547c7..58b5782d1b 100644
--- a/Packages/com.unity.inputsystem/InputSystem/Editor/UITKAssetEditor/InputActionsEditorWindow.cs
+++ b/Packages/com.unity.inputsystem/InputSystem/Editor/UITKAssetEditor/InputActionsEditorWindow.cs
@@ -29,7 +29,7 @@ static InputActionsEditorWindow()
             InputActionAssetEditor.RegisterType<InputActionsEditorWindow>();
         }
 
-        static readonly Vector2 k_MinWindowSize = new Vector2(650, 450);
+        static readonly Vector2 k_MinWindowSize = new Vector2(740, 450);
         // For UI testing purpose
         internal InputActionAsset currentAssetInEditor => m_AssetObjectForEditing;
         [SerializeField] private InputActionAsset m_AssetObjectForEditing;
diff --git a/Packages/com.unity.inputsystem/InputSystem/Editor/UITKAssetEditor/PackageResources/InputActionsEditor.uxml b/Packages/com.unity.inputsystem/InputSystem/Editor/UITKAssetEditor/PackageResources/InputActionsEditor.uxml
index e992fcecd6..56b0e2db1a 100644
--- a/Packages/com.unity.inputsystem/InputSystem/Editor/UITKAssetEditor/PackageResources/InputActionsEditor.uxml
+++ b/Packages/com.unity.inputsystem/InputSystem/Editor/UITKAssetEditor/PackageResources/InputActionsEditor.uxml
@@ -28,7 +28,7 @@
                     </ui:VisualElement>
                     <ui:VisualElement name="rclick-area-to-add-new-action-map" style="flex-direction: column; flex-grow: 1;" />
                 </ui:VisualElement>
-                <ui:TwoPaneSplitView name="actions-and-properties-split-view" fixed-pane-index="1" fixed-pane-initial-dimension="230" style="height: auto; min-width: 450px">
+                <ui:TwoPaneSplitView name="actions-and-properties-split-view" fixed-pane-index="1" fixed-pane-initial-dimension="320" style="height: auto; min-width: 450px;">
                     <ui:VisualElement name="actions-container" class="body-panel-container">
                         <ui:VisualElement name="header" class="body-panel-header" style="justify-content: space-between;">
                             <ui:Label text="Actions" display-tooltip-when-elided="true" name="actions-label" />
@@ -39,7 +39,7 @@
                         </ui:VisualElement>
                         <ui:VisualElement name="rclick-area-to-add-new-action" style="flex-direction: column; flex-grow: 1;" />
                     </ui:VisualElement>
-                    <ui:VisualElement name="properties-container" class="body-panel-container body-panel-container" style="min-width: 220;">
+                    <ui:VisualElement name="properties-container" class="body-panel-container body-panel-container" style="min-width: 310px;">
                         <ui:VisualElement name="header" class="body-panel-header">
                             <ui:Label text="Action Properties" display-tooltip-when-elided="true" name="properties-header-label" />
                         </ui:VisualElement>
diff --git a/Packages/com.unity.inputsystem/InputSystem/InputSettings.cs b/Packages/com.unity.inputsystem/InputSystem/InputSettings.cs
index 4ee37718d9..bed8bddbc3 100644
--- a/Packages/com.unity.inputsystem/InputSystem/InputSettings.cs
+++ b/Packages/com.unity.inputsystem/InputSystem/InputSettings.cs
@@ -978,6 +978,17 @@ public enum InputActionPropertyDrawerMode
             MultilineBoth,
         }
 
+#if UNITY_EDITOR && UNITY_INPUT_SYSTEM_PROJECT_WIDE_ACTIONS
+        /// <summary>
+        /// Determines if we should render the UI with IMGUI even if an UI Toolkit UI is available.
+        ///
+        /// This should be used when writing a custom <see cref="InputParameterEditor"/> to :
+        /// * support inspector view which only work in IMGUI for now.
+        /// * prevent the UI to be rendered in IMGUI and UI Toolkit in the Input Actions Editor window.
+        /// </summary>
+        public bool useIMGUIEditorForAssets => UnityEditor.EditorGUI.indentLevel > 0 || IsFeatureEnabled(InputFeatureNames.kUseIMGUIEditorForAssets);
+#endif
+
         private static bool CompareFloats(float a, float b)
         {
             return (a - b) <= float.Epsilon;
diff --git a/Packages/com.unity.inputsystem/InputSystem/Plugins/EnhancedTouch/Touch.cs b/Packages/com.unity.inputsystem/InputSystem/Plugins/EnhancedTouch/Touch.cs
index 096f8c9659..32b02471ac 100644
--- a/Packages/com.unity.inputsystem/InputSystem/Plugins/EnhancedTouch/Touch.cs
+++ b/Packages/com.unity.inputsystem/InputSystem/Plugins/EnhancedTouch/Touch.cs
@@ -22,7 +22,7 @@ namespace UnityEngine.InputSystem.EnhancedTouch
     /// and touch phases (<see cref="TouchControl.phase"/>) in order to tell one touch apart from another.
     ///
     /// Also, this class protects against losing touches. If a touch is shorter-lived than a single input update,
-    /// <see cref="Touchscreen"/> may overwrite it with a new touch coming in in the same update whereas this class
+    /// <see cref="Touchscreen"/> may overwrite it with a new touch coming in the same update whereas this class
     /// will retain all changes that happened on the touchscreen in any particular update.
     ///
     /// The API makes a distinction between "fingers" and "touches". A touch refers to one contact state change event, that is, a
@@ -33,6 +33,52 @@ namespace UnityEngine.InputSystem.EnhancedTouch
     /// A Touch instance is a struct which only contains a reference to the actual data which is stored in unmanaged
     /// memory.
     /// </remarks>
+    /// <example>
+    /// <code>
+    /// using UnityEngine;
+    /// using UnityEngine.InputSystem.EnhancedTouch;
+    ///
+    /// // Alias EnhancedTouch.Touch to "Touch" for less typing.
+    /// using Touch = UnityEngine.InputSystem.EnhancedTouch.Touch;
+    /// using TouchPhase = UnityEngine.InputSystem.TouchPhase;
+    ///
+    /// public class Example : MonoBehaviour
+    /// {
+    ///     void Awake()
+    ///     {
+    ///         // Note that enhanced touch support needs to be explicitly enabled.
+    ///         EnhancedTouchSupport.Enable();
+    ///     }
+    ///
+    ///     void Update()
+    ///     {
+    ///         // Illustrates how to examine all active touches once per frame and show their last recorded position
+    ///         // in the associated screen-space.
+    ///         foreach (var touch in Touch.activeTouches)
+    ///         {
+    ///             switch (touch.phase)
+    ///             {
+    ///                 case TouchPhase.Began:
+    ///                     Debug.Log($"Frame {Time.frameCount}: Touch {touch} started this frame at ({touch.screenPosition.x}, {touch.screenPosition.y})");
+    ///                     break;
+    ///                 case TouchPhase.Ended:
+    ///                     Debug.Log($"Frame {Time.frameCount}:Touch {touch} ended this frame at ({touch.screenPosition.x}, {touch.screenPosition.y})");
+    ///                     break;
+    ///                 case TouchPhase.Moved:
+    ///                     Debug.Log($"Frame {Time.frameCount}: Touch {touch} moved this frame to ({touch.screenPosition.x}, {touch.screenPosition.y})");
+    ///                     break;
+    ///                 case TouchPhase.Canceled:
+    ///                     Debug.Log($"Frame {Time.frameCount}: Touch {touch} was canceled this frame");
+    ///                     break;
+    ///                 case TouchPhase.Stationary:
+    ///                     Debug.Log($"Frame {Time.frameCount}: ouch {touch} was not updated this frame");
+    ///                     break;
+    ///             }
+    ///         }
+    ///     }
+    /// }
+    /// </code>
+    /// </example>
     [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1724:TypeNamesShouldNotMatchNamespaces")]
     public struct Touch : IEquatable<Touch>
     {
@@ -42,132 +88,148 @@ public struct Touch : IEquatable<Touch>
         /// <summary>
         /// Whether this touch record holds valid data.
         /// </summary>
-        /// <value>If true, the data contained in the touch is valid.</value>
         /// <remarks>
+        /// <para>
         /// Touch data is stored in unmanaged memory as a circular input buffer. This means that when
         /// the buffer runs out of capacity, older touch entries will get reused. When this happens,
         /// existing <c>Touch</c> instances referring to the record become invalid.
-        ///
+        /// </para>
+        /// <para>
         /// This property can be used to determine whether the record held on to by the <c>Touch</c>
         /// instance is still valid.
-        ///
+        /// </para>
+        /// <para>
         /// This property will be <c>false</c> for default-initialized <c>Touch</c> instances.
-        ///
+        /// </para>
+        /// <para>
         /// Note that accessing most of the other properties on this struct when the touch is
-        /// invalid will trigger <c>InvalidOperationException</c>.
+        /// invalid will trigger <see cref="InvalidOperationException"/>.
+        /// </para>
         /// </remarks>
         public bool valid => m_TouchRecord.valid;
 
         /// <summary>
-        /// The finger used for the touch contact. Null only for default-initialized
-        /// instances of the struct.
+        /// The finger used for the touch contact.
         /// </summary>
-        /// <value>Finger used for the touch contact.</value>
-        /// <seealso cref="activeFingers"/>
+        /// <remarks>
+        /// <para>
+        /// Note that this is only <c>null</c> for default-initialized instances of the struct.
+        /// </para>
+        /// <para>
+        /// See <see cref="activeFingers"/> for how to access all active fingers.
+        /// </para>
+        /// </remarks>
         public Finger finger => m_Finger;
 
         /// <summary>
-        /// Current phase of the touch.
+        /// The current touch phase of the touch indicating its current state in the phase cycle.
         /// </summary>
-        /// <value>Current phase of the touch.</value>
         /// <remarks>
+        /// <para>
         /// Every touch goes through a predefined cycle that starts with <see cref="TouchPhase.Began"/>,
         /// then potentially <see cref="TouchPhase.Moved"/> and/or <see cref="TouchPhase.Stationary"/>,
         /// and finally concludes with either <see cref="TouchPhase.Ended"/> or <see cref="TouchPhase.Canceled"/>.
-        ///
-        /// This property indicates where in the cycle the touch is.
+        /// </para>
+        /// <para>
+        /// This property indicates where in the cycle the touch is and is based on <see cref="TouchControl.phase"/>.
+        /// </para>
+        /// <para>
+        /// Use <see cref="isInProgress"/> to more conveniently evaluate whether this touch is currently active or not.
+        /// </para>
         /// </remarks>
-        /// <seealso cref="isInProgress"/>
-        /// <seealso cref="TouchControl.phase"/>
         public TouchPhase phase => state.phase;
 
         /// <summary>
         /// Whether the touch has begun this frame, i.e. whether <see cref="phase"/> is <see cref="TouchPhase.Began"/>.
         /// </summary>
-        /// <seealso cref="phase"/>
-        /// <seealso cref="ended"/>
-        /// <seealso cref="inProgress"/>
+        /// <remarks>
+        /// Use <see cref="isInProgress"/> to more conveniently evaluate whether this touch is currently active or not.
+        /// </remarks>
         public bool began => phase == TouchPhase.Began;
 
         /// <summary>
         /// Whether the touch is currently in progress, i.e. whether <see cref="phase"/> is either
         /// <see cref="TouchPhase.Moved"/>, <see cref="TouchPhase.Stationary"/>, or <see cref="TouchPhase.Began"/>.
         /// </summary>
-        /// <seealso cref="phase"/>
-        /// <seealso cref="began"/>
-        /// <seealso cref="ended"/>
         public bool inProgress => phase == TouchPhase.Moved || phase == TouchPhase.Stationary || phase == TouchPhase.Began;
 
         /// <summary>
         /// Whether the touch has ended this frame, i.e. whether <see cref="phase"/> is either
         /// <see cref="TouchPhase.Ended"/> or <see cref="TouchPhase.Canceled"/>.
         /// </summary>
-        /// <seealso cref="phase"/>
-        /// <seealso cref="began"/>
-        /// <seealso cref="isInProgress"/>
+        /// <remarks>
+        /// Use <see cref="isInProgress"/> to more conveniently evaluate whether this touch is currently active or not.
+        /// </remarks>
         public bool ended => phase == TouchPhase.Ended || phase == TouchPhase.Canceled;
 
         /// <summary>
         /// Unique ID of the touch as (usually) assigned by the platform.
         /// </summary>
-        /// <value>Unique, non-zero ID of the touch.</value>
         /// <remarks>
-        /// Each touch contact that is made with the screen receives its own unique ID which is
-        /// normally assigned by the underlying platform.
-        ///
+        /// <para>
+        /// Each touch contact that is made with the screen receives its own unique, non-zero ID which is
+        /// normally assigned by the underlying platform via <see cref="TouchControl.touchId"/>.
+        /// </para>
+        /// <para>
         /// Note a platform may reuse touch IDs after their respective touches have finished.
         /// This means that the guarantee of uniqueness is only made with respect to <see cref="activeTouches"/>.
-        ///
+        /// </para>
+        /// <para>
         /// In particular, all touches in <see cref="history"/> will have the same ID whereas
-        /// touches in the a finger's <see cref="Finger.touchHistory"/> may end up having the same
+        /// touches in the finger's <see cref="Finger.touchHistory"/> may end up having the same
         /// touch ID even though constituting different physical touch contacts.
+        /// </para>
         /// </remarks>
-        /// <seealso cref="TouchControl.touchId"/>
         public int touchId => state.touchId;
 
         /// <summary>
         /// Normalized pressure of the touch against the touch surface.
         /// </summary>
-        /// <value>Pressure level of the touch.</value>
         /// <remarks>
+        /// <para>
         /// Not all touchscreens are pressure-sensitive. If unsupported, this property will
         /// always return 0.
-        ///
+        /// </para>
+        /// <para>
         /// In general, touch pressure is supported on mobile platforms only.
-        ///
+        /// </para>
+        /// <para>
+        /// Touch pressure may also be retrieved directly from the device control via <see cref="TouchControl.pressure"/>.
+        /// </para>
+        /// <para>
         /// Note that it is possible for the value to go above 1 even though it is considered normalized. The reason is
         /// that calibration on the system can put the maximum pressure point below the physically supported maximum value.
+        /// </para>
         /// </remarks>
-        /// <seealso cref="TouchControl.pressure"/>
         public float pressure => state.pressure;
 
         /// <summary>
-        /// Screen-space radius of the touch.
+        /// Screen-space radius of the touch which define its horizontal and vertical extents.
         /// </summary>
-        /// <value>Horizontal and vertical extents of the touch contact.</value>
         /// <remarks>
+        /// <para>
         /// If supported by the underlying device, this reports the size of the touch contact based on its
         /// <see cref="screenPosition"/> center point. If not supported, this will be <c>default(Vector2)</c>.
+        /// </para>
+        /// <para>
+        /// Touch radius may also be retrieved directly from the device control via <see cref="TouchControl.radius"/>.
+        /// </para>
         /// </remarks>
-        /// <seealso cref="TouchControl.radius"/>
         public Vector2 radius => state.radius;
 
         /// <summary>
-        /// Time in seconds on the same timeline as <c>Time.realTimeSinceStartup</c> when the touch began.
+        /// Start time of the touch in seconds on the same timeline as <c>Time.realTimeSinceStartup</c>.
         /// </summary>
-        /// <value>Start time of the touch.</value>
         /// <remarks>
         /// This is the value of <see cref="InputEvent.time"/> when the touch started with
-        /// <see cref="phase"/> <see cref="TouchPhase.Began"/>.
+        /// <see cref="phase"/> <see cref="TouchPhase.Began"/>. Note that start time may also be retrieved directly
+        /// from the device control via <see cref="TouchControl.startTime"/>.
         /// </remarks>
-        /// <seealso cref="TouchControl.startTime"/>
         public double startTime => state.startTime;
 
         /// <summary>
-        /// Time in seconds on the same timeline as <c>Time.realTimeSinceStartup</c> when the touch record was
-        /// reported.
+        /// Time the touch record was reported on the same timeline as <see cref="UnityEngine.Time.realtimeSinceStartup"/>.
         /// </summary>
-        /// <value>Time the touch record was reported.</value>
         /// <remarks>
         /// This is the value <see cref="InputEvent.time"/> of the event that signaled the current state
         /// change for the touch.
@@ -175,34 +237,36 @@ public struct Touch : IEquatable<Touch>
         public double time => m_TouchRecord.time;
 
         /// <summary>
-        /// The touchscreen on which the touch occurred.
+        /// The <see cref="Touchscreen"/> associated with the touch contact.
         /// </summary>
-        /// <value>Touchscreen associated with the touch.</value>
         public Touchscreen screen => finger.screen;
 
         /// <summary>
         /// Screen-space position of the touch.
         /// </summary>
-        /// <value>Screen-space position of the touch.</value>
-        /// <seealso cref="TouchControl.position"/>
+        /// <remarks>Also see <see cref="TouchControl.position"/> for retrieving position directly from a device
+        /// control.</remarks>
         public Vector2 screenPosition => state.position;
 
         /// <summary>
         /// Screen-space position where the touch started.
         /// </summary>
-        /// <value>Start position of the touch.</value>
-        /// <seealso cref="TouchControl.startPosition"/>
+        /// <remarks>Also see <see cref="TouchControl.startPosition"/> for retrieving start position directly from
+        /// a device control.</remarks>
         public Vector2 startScreenPosition => state.startPosition;
 
         /// <summary>
         /// Screen-space motion delta of the touch.
         /// </summary>
-        /// <value>Screen-space motion delta of the touch.</value>
         /// <remarks>
+        /// <para>
         /// Note that deltas have behaviors attached to them different from most other
         /// controls. See <see cref="Pointer.delta"/> for details.
+        /// </para>
+        /// <para>
+        /// Also see <see cref="TouchControl.delta"/> for retrieving delta directly from a device control.
+        /// </para>
         /// </remarks>
-        /// <seealso cref="TouchControl.delta"/>
         public Vector2 delta => state.delta;
 
         /// <summary>
@@ -210,12 +274,16 @@ public struct Touch : IEquatable<Touch>
         /// </summary>
         /// <value>Indicates how many taps have been performed one after the other.</value>
         /// <remarks>
+        /// <para>
         /// Successive taps have to come within <see cref="InputSettings.multiTapDelayTime"/> for them
         /// to increase the tap count. I.e. if a new tap finishes within that time after <see cref="startTime"/>
         /// of the previous touch, the tap count is increased by one. If more than <see cref="InputSettings.multiTapDelayTime"/>
         /// passes after a tap with no successive tap, the tap count is reset to zero.
+        /// </para>
+        /// <para>
+        /// Also see <see cref="TouchControl.tapCount"/> for retrieving tap count directly from a device control.
+        /// </para>
         /// </remarks>
-        /// <seealso cref="TouchControl.tapCount"/>
         public int tapCount => state.tapCount;
 
         /// <summary>
@@ -223,31 +291,42 @@ public struct Touch : IEquatable<Touch>
         /// </summary>
         /// <value>Indicates whether the touch has tapped the screen.</value>
         /// <remarks>
+        /// <para>
         /// A tap is defined as a touch that begins and ends within <see cref="InputSettings.defaultTapTime"/> and
         /// stays within <see cref="InputSettings.tapRadius"/> of its <see cref="startScreenPosition"/>. If this
         /// is the case for a touch, this button is set to 1 at the time the touch goes to <see cref="phase"/>
         /// <see cref="TouchPhase.Ended"/>.
-        ///
+        /// </para>
+        /// <para>
         /// Resets to 0 only when another touch is started on the control or when the control is reset.
+        /// </para>
+        /// <para>
+        /// Use <see cref="tapCount"/> to determine if there were multiple taps occurring during the frame.
+        /// Also note that <see cref="TouchControl.tap"/> may be used to determine whether there was a tap.
+        /// </para>
         /// </remarks>
-        /// <seealso cref="tapCount"/>
-        /// <seealso cref="InputSettings.defaultTapTime"/>
-        /// <seealso cref="TouchControl.tap"/>
         public bool isTap => state.isTap;
 
         /// <summary>
         /// The index of the display containing the touch.
         /// </summary>
-        /// <value>A zero based number representing the display index containing the touch.</value>
-        /// <seealso cref="TouchControl.displayIndex"/>
-        /// <seealso cref="Display"/>
+        /// <remarks>
+        /// <para>
+        /// A zero based number representing the display index of the <see cref="Display"/> that contains the touch.
+        /// </para>
+        /// <para>
+        /// Also see <see cref="TouchControl.displayIndex"/> for retrieving display index directly from a device
+        /// control.
+        /// </para>
+        /// </remarks>
         public int displayIndex => state.displayIndex;
 
         /// <summary>
-        /// Whether the touch is currently in progress, i.e. has a <see cref="phase"/> of
-        /// <see cref="TouchPhase.Began"/>, <see cref="TouchPhase.Moved"/>, or <see cref="TouchPhase.Stationary"/>.
+        /// Whether the touch is currently in progress.
         /// </summary>
-        /// <value>Whether the touch is currently ongoing.</value>
+        /// <remarks>This is effectively equivalent to checking if <see cref="phase"/> is equal to either of:
+        /// <see cref="TouchPhase.Began"/>, <see cref="TouchPhase.Moved"/>, or <see cref="TouchPhase.Stationary"/>.
+        /// </remarks>
         public bool isInProgress
         {
             get
@@ -271,7 +350,7 @@ public bool isInProgress
             ref *(ExtraDataPerTouchState*)m_TouchRecord.GetUnsafeExtraMemoryPtr();
 
         /// <summary>
-        /// History for this specific touch.
+        /// History touch readings for this specific touch contact.
         /// </summary>
         /// <remarks>
         /// Unlike <see cref="Finger.touchHistory"/>, this gives the history of this touch only.
@@ -287,7 +366,7 @@ public TouchHistory history
         }
 
         /// <summary>
-        /// All touches that are either on-going as of the current frame or have ended in the current frame.
+        /// All touches that are either ongoing as of the current frame or have ended in the current frame.
         /// </summary>
         /// <remarks>
         /// A touch that begins in a frame will always have its phase set to <see cref="TouchPhase.Began"/> even
@@ -304,7 +383,7 @@ public TouchHistory history
         /// case <see cref="phase"/> will be <see cref="TouchPhase.Ended"/> instead of <see cref="TouchPhase.Moved"/>).
         ///
         /// Note that the touches reported by this API do <em>not</em> necessarily have to match the contents of
-        /// <see href="https://docs.unity3d.com/ScriptReference/Input-touches.html">UnityEngine.Input.touches</see>.
+        /// <a href="https://docs.unity3d.com/ScriptReference/Input-touches.html">UnityEngine.Input.touches</a>.
         /// The reason for this is that the <c>UnityEngine.Input</c> API and the Input System API flush their input
         /// queues at different points in time and may thus have a different view on available input. In particular,
         /// the Input System event queue is flushed <em>later</em> in the frame than inputs for <c>UnityEngine.Input</c>
@@ -313,27 +392,55 @@ public TouchHistory history
         /// Due to this setup, touch events that will reach <c>UnityEngine.Input</c> only in the next frame may have
         /// already reached the Input System.
         ///
+        /// In order to evaluate all active touches on a per-frame basis see <see cref="activeFingers"/>.
+        /// </remarks>
         /// <example>
         /// <code>
-        /// void Awake()
-        /// {
-        ///     // Enable EnhancedTouch.
-        ///     EnhancedTouchSupport.Enable();
-        /// }
+        /// using UnityEngine;
+        /// using UnityEngine.InputSystem.EnhancedTouch;
+        ///
+        /// // Alias EnhancedTouch.Touch to "Touch" for less typing.
+        /// using Touch = UnityEngine.InputSystem.EnhancedTouch.Touch;
+        /// using TouchPhase = UnityEngine.InputSystem.TouchPhase;
         ///
-        /// void Update()
+        /// public class Example : MonoBehaviour
         /// {
-        ///     foreach (var touch in Touch.activeTouches)
-        ///         if (touch.began)
-        ///             Debug.Log($"Touch {touch} started this frame");
-        ///         else if (touch.ended)
-        ///             Debug.Log($"Touch {touch} ended this frame");
+        ///     void Awake()
+        ///     {
+        ///         // Note that enhanced touch support needs to be explicitly enabled.
+        ///         EnhancedTouchSupport.Enable();
+        ///     }
+        ///
+        ///     void Update()
+        ///     {
+        ///         // Illustrates how to examine all active touches once per frame and show their last recorded position
+        ///         // in the associated screen-space.
+        ///         foreach (var touch in Touch.activeTouches)
+        ///         {
+        ///             switch (touch.phase)
+        ///             {
+        ///                 case TouchPhase.Began:
+        ///                     Debug.Log($"Frame {Time.frameCount}: Touch {touch} started this frame at ({touch.screenPosition.x}, {touch.screenPosition.y})");
+        ///                     break;
+        ///                 case TouchPhase.Ended:
+        ///                     Debug.Log($"Frame {Time.frameCount}:Touch {touch} ended this frame at ({touch.screenPosition.x}, {touch.screenPosition.y})");
+        ///                     break;
+        ///                 case TouchPhase.Moved:
+        ///                     Debug.Log($"Frame {Time.frameCount}: Touch {touch} moved this frame to ({touch.screenPosition.x}, {touch.screenPosition.y})");
+        ///                     break;
+        ///                 case TouchPhase.Canceled:
+        ///                     Debug.Log($"Frame {Time.frameCount}: Touch {touch} was canceled this frame");
+        ///                     break;
+        ///                 case TouchPhase.Stationary:
+        ///                     Debug.Log($"Frame {Time.frameCount}: ouch {touch} was not updated this frame");
+        ///                     break;
+        ///             }
+        ///         }
+        ///     }
         /// }
         /// </code>
         /// </example>
-        /// </remarks>
         /// <exception cref="InvalidOperationException"><c>EnhancedTouch</c> has not been enabled via <see cref="EnhancedTouchSupport.Enable"/>.</exception>
-        /// <seealso cref="activeFingers"/>
         public static ReadOnlyArray<Touch> activeTouches
         {
             get
@@ -351,14 +458,13 @@ public static ReadOnlyArray<Touch> activeTouches
         /// </summary>
         /// <remarks>
         /// For querying only active fingers, use <see cref="activeFingers"/>.
+        /// For querying only active touches, use <see cref="activeTouches"/>.
         ///
         /// The length of this array will always correspond to the maximum number of concurrent touches supported by the system.
         /// Note that the actual number of physically supported concurrent touches as determined by the current hardware and
         /// operating system may be lower than this number.
         /// </remarks>
         /// <exception cref="InvalidOperationException"><c>EnhancedTouch</c> has not been enabled via <see cref="EnhancedTouchSupport.Enable"/>.</exception>
-        /// <seealso cref="activeTouches"/>
-        /// <seealso cref="activeFingers"/>
         public static ReadOnlyArray<Finger> fingers
         {
             get
@@ -371,9 +477,10 @@ public static ReadOnlyArray<Finger> fingers
         /// <summary>
         /// Set of currently active fingers, i.e. touch contacts that currently have an active touch (as defined by <see cref="activeTouches"/>).
         /// </summary>
+        /// <remarks>
+        /// To instead get a collection of all fingers (not only currently active) use <see cref="fingers"/>.
+        /// </remarks>
         /// <exception cref="InvalidOperationException"><c>EnhancedTouch</c> has not been enabled via <see cref="EnhancedTouchSupport.Enable"/>.</exception>
-        /// <seealso cref="activeTouches"/>
-        /// <seealso cref="fingers"/>
         public static ReadOnlyArray<Finger> activeFingers
         {
             get
@@ -401,9 +508,11 @@ public static IEnumerable<Touchscreen> screens
         /// <summary>
         /// Event that is invoked when a finger touches a <see cref="Touchscreen"/>.
         /// </summary>
+        /// <remarks>
+        /// In order to react to a finger being moved or released, see <see cref="onFingerMove"/> and
+        /// <see cref="onFingerUp"/> respectively.
+        /// </remarks>
         /// <exception cref="InvalidOperationException"><c>EnhancedTouch</c> has not been enabled via <see cref="EnhancedTouchSupport.Enable"/>.</exception>
-        /// <seealso cref="onFingerUp"/>
-        /// <seealso cref="onFingerMove"/>
         public static event Action<Finger> onFingerDown
         {
             add
@@ -425,9 +534,11 @@ public static event Action<Finger> onFingerDown
         /// <summary>
         /// Event that is invoked when a finger stops touching a <see cref="Touchscreen"/>.
         /// </summary>
+        /// <remarks>
+        /// In order to react to a finger that touches a <see cref="Touchscreen"/> or a finger that is being moved
+        /// use <see cref="onFingerDown"/> and <see cref="onFingerMove"/> respectively.
+        /// </remarks>
         /// <exception cref="InvalidOperationException"><c>EnhancedTouch</c> has not been enabled via <see cref="EnhancedTouchSupport.Enable"/>.</exception>
-        /// <seealso cref="onFingerDown"/>
-        /// <seealso cref="onFingerMove"/>
         public static event Action<Finger> onFingerUp
         {
             add
@@ -450,9 +561,11 @@ public static event Action<Finger> onFingerUp
         /// Event that is invoked when a finger that is in contact with a <see cref="Touchscreen"/> moves
         /// on the screen.
         /// </summary>
+        /// <remarks>
+        /// In order to react to a finger that touches a <see cref="Touchscreen"/> or a finger that stops touching
+        /// a <see cref="Touchscreen"/>, use <see cref="onFingerDown"/> and <see cref="onFingerUp"/> respectively.
+        /// </remarks>
         /// <exception cref="InvalidOperationException"><c>EnhancedTouch</c> has not been enabled via <see cref="EnhancedTouchSupport.Enable"/>.</exception>
-        /// <seealso cref="onFingerUp"/>
-        /// <seealso cref="onFingerDown"/>
         public static event Action<Finger> onFingerMove
         {
             add
@@ -501,6 +614,7 @@ internal Touch(Finger finger, InputStateHistory<TouchState>.Record touchRecord)
             m_TouchRecord = touchRecord;
         }
 
+        /// <inheritdoc/>
         public override string ToString()
         {
             if (!valid)
@@ -509,16 +623,24 @@ public override string ToString()
             return $"{{id={touchId} finger={finger.index} phase={phase} position={screenPosition} delta={delta} time={time}}}";
         }
 
+        /// <summary>
+        /// Compares this touch for equality with another instance <paramref name="other"/>.
+        /// </summary>
+        /// <param name="other">The other instance to compare with.</param>
+        /// <returns><c>true</c> if this touch and <paramref name="other"/> represents the same finger and maps to the
+        /// same touch record, otherwise <c>false</c></returns>
         public bool Equals(Touch other)
         {
             return Equals(m_Finger, other.m_Finger) && m_TouchRecord.Equals(other.m_TouchRecord);
         }
 
+        /// <inheritdoc/>
         public override bool Equals(object obj)
         {
             return obj is Touch other && Equals(other);
         }
 
+        /// <inheritdoc/>
         public override int GetHashCode()
         {
             unchecked
diff --git a/Packages/com.unity.inputsystem/InputSystem/Plugins/InputForUI/InputSystemProvider.cs b/Packages/com.unity.inputsystem/InputSystem/Plugins/InputForUI/InputSystemProvider.cs
index 2af56bd88c..9cb34c56a4 100644
--- a/Packages/com.unity.inputsystem/InputSystem/Plugins/InputForUI/InputSystemProvider.cs
+++ b/Packages/com.unity.inputsystem/InputSystem/Plugins/InputForUI/InputSystemProvider.cs
@@ -420,7 +420,7 @@ void OnPointerPerformed(InputAction.CallbackContext ctx)
                 m_SeenPenEvents = true;
 
             var positionISX = ctx.ReadValue<Vector2>();
-            var targetDisplay = asPointerDevice != null ? asPointerDevice.displayIndex.ReadValue() : (asTouchscreenDevice != null ? asTouchscreenDevice.displayIndex.ReadValue() : 0);
+            var targetDisplay = asPointerDevice != null ? asPointerDevice.displayIndex.ReadValue() : (asTouchscreenDevice != null ? asTouchscreenDevice.displayIndex.ReadValue() : (asPenDevice != null ? asPenDevice.displayIndex.ReadValue() : 0));
             var position = ScreenBottomLeftToPanelPosition(positionISX, targetDisplay);
             var delta = pointerState.LastPositionValid ? position - pointerState.LastPosition : Vector2.zero;
 
diff --git a/Packages/com.unity.inputsystem/InputSystem/Plugins/PlayerInput/InputValue.cs b/Packages/com.unity.inputsystem/InputSystem/Plugins/PlayerInput/InputValue.cs
index c781ae9418..61cba088fb 100644
--- a/Packages/com.unity.inputsystem/InputSystem/Plugins/PlayerInput/InputValue.cs
+++ b/Packages/com.unity.inputsystem/InputSystem/Plugins/PlayerInput/InputValue.cs
@@ -22,10 +22,10 @@ namespace UnityEngine.InputSystem
     public class InputValue
     {
         /// <summary>
-        /// Read the value as an object.
+        /// Read the current value as an object.
         /// </summary>
         /// <remarks>
-        /// This method allocates GC memory and will thus created garbage. If used during gameplay,
+        /// This method allocates GC memory and will thus create garbage. If used during gameplay,
         /// it will lead to GC spikes.
         /// </remarks>
         /// <returns>The current value in the form of a boxed object.</returns>
@@ -35,6 +35,45 @@ public object Get()
         }
 
         ////TODO: add automatic conversions
+        /// <summary>
+        /// Read the current value of the action.
+        /// </summary>
+        /// <returns>The current value from the action cast to the specified type.</returns>
+        /// <typeparam name="TValue">Type of value to read. This must correspond to the
+        /// <see cref="InputControl.valueType"/> of the action or, if it is a composite, by the
+        /// <see cref="InputBindingComposite.valueType"/>.
+        /// The type depends on what type of controls the action is bound to.
+        /// Common types are <c>float</c> and <see cref="UnityEngine.Vector2"/></typeparam>
+        /// <exception cref="InvalidOperationException">The given type <typeparamref name="TValue"/>
+        /// does not match the value type expected by the control or binding composite.</exception>
+        /// <remarks>
+        /// The following example shows how to read a value from a <see cref="PlayerInput"/> message.
+        /// The given <c>InputValue</c> is only valid for the duration of the callback. Storing the <c>InputValue</c> references somewhere and calling Get&lt;T&gt;() later does not work correctly.
+        /// </remarks>
+        /// <example>
+        /// <code>
+        /// using UnityEngine;
+        /// using UnityEngine.InputSystem;
+        /// [RequireComponent(typeof(PlayerInput))]
+        /// public class MyPlayerLogic : MonoBehaviour
+        /// {
+        ///     private Vector2 m_Move;
+        ///
+        ///     // 'Move' input action has been triggered.
+        ///     public void OnMove(InputValue value)
+        ///     {
+        ///         // Read value from control. The type depends on what type of controls the action is bound to.
+        ///         m_Move = value.Get&lt;Vector2&gt;();
+        ///     }
+        ///
+        ///     public void Update()
+        ///     {
+        ///         // Update transform from m_Move
+        ///     }
+        /// }
+        /// </code>
+        /// </example>
+        /// <seealso cref="InputAction.CallbackContext.ReadValue{TValue}"/>
         public TValue Get<TValue>()
             where TValue : struct
         {
@@ -45,6 +84,34 @@ public TValue Get<TValue>()
         }
 
         ////TODO: proper message if value type isn't right
+        /// <summary>
+        /// Check if the action button is pressed.
+        /// </summary>
+        /// <remarks>
+        /// True if the button is activated over the button threshold. False otherwise
+        /// The following example check if a button is pressed when receiving a <see cref="PlayerInput"/> message.
+        /// The given <c>InputValue</c> is only valid for the duration of the callback. Storing the <c>InputValue</c> references somewhere and calling Get&lt;T&gt;() later does not work correctly.
+        /// </remarks>
+        /// <example>
+        /// <code>
+        /// [RequireComponent(typeof(PlayerInput))]
+        /// public class MyPlayerLogic : MonoBehaviour
+        /// {
+        ///     // 'Fire' input action has been triggered.
+        ///     public void OnFire(InputValue value)
+        ///     {
+        ///         if (value.isPressed)
+        ///             FireWeapon();
+        ///     }
+        ///
+        ///     public void FireWeapon()
+        ///     {
+        ///         // Weapon firing code
+        ///     }
+        /// }
+        /// </code>
+        /// </example>
+        /// <seealso cref="ButtonControl.pressPointOrDefault"/>
         public bool isPressed => Get<float>() >= ButtonControl.s_GlobalDefaultButtonPressPoint;
 
         internal InputAction.CallbackContext? m_Context;
diff --git a/Packages/com.unity.inputsystem/InputSystem/Plugins/PlayerInput/PlayerInput.cs b/Packages/com.unity.inputsystem/InputSystem/Plugins/PlayerInput/PlayerInput.cs
index ce27ff2620..1375503db1 100644
--- a/Packages/com.unity.inputsystem/InputSystem/Plugins/PlayerInput/PlayerInput.cs
+++ b/Packages/com.unity.inputsystem/InputSystem/Plugins/PlayerInput/PlayerInput.cs
@@ -55,6 +55,7 @@ namespace UnityEngine.InputSystem
     /// to the player and a set of paired device.
     /// </summary>
     /// <remarks>
+    /// <para>
     /// PlayerInput is a high-level wrapper around much of the input system's functionality
     /// which is meant to help getting set up with the new input system quickly. It takes
     /// care of <see cref="InputAction"/> bookkeeping and has a custom UI(requires the "Unity UI" package) to help
@@ -70,8 +71,76 @@ namespace UnityEngine.InputSystem
     /// <see cref="GameObject.SendMessage(string,object)"/> to send messages to the <see cref="GameObject"/>
     /// that PlayerInput sits on.
     ///
+    /// When enabled, PlayerInput will create an <see cref="InputUser"/> and pair devices to the
+    /// user which are then specific to the player. The set of devices can be controlled explicitly
+    /// when instantiating a PlayerInput through <see cref="Instantiate(GameObject,int,string,int,InputDevice[])"/>
+    /// or <see cref="Instantiate(GameObject,int,string,int,InputDevice)"/>. This also makes it possible
+    /// to assign the same device to two different players, e.g. for split-keyboard play.
+    ///
+    /// </para>
+    /// <code>
+    /// var p1 = PlayerInput.Instantiate(playerPrefab,
+    ///     controlScheme: "KeyboardLeft", device: Keyboard.current);
+    /// var p2 = PlayerInput.Instantiate(playerPrefab,
+    ///     controlScheme: "KeyboardRight", device: Keyboard.current);
+    /// </code>
+    /// <para>
+    ///
+    /// If no specific devices are given to a PlayerInput, the component will look for compatible
+    /// devices present in the system and pair them to itself automatically. If the PlayerInput's
+    /// <see cref="actions"/> have control schemes defined for them, PlayerInput will look for a
+    /// control scheme for which all required devices are available and not paired to any other player.
+    /// It will try <see cref="defaultControlScheme"/> first (if set), but then fall back to trying
+    /// all available schemes in order. Once a scheme is found for which all required devices are
+    /// available, PlayerInput will pair those devices to itself and select the given scheme.
+    ///
+    /// If no control schemes are defined, PlayerInput will try to bind as many as-of-yet unpaired
+    /// devices to itself as it can match to bindings present in the <see cref="actions"/>. This means
+    /// that if, for example, there's binding for both keyboard and gamepad and there is one keyboard
+    /// and two gamepads available when PlayerInput is enabled, all three devices will be paired to
+    /// the player.
+    ///
+    /// Note that when using <see cref="PlayerInputManager"/>, device pairing to players is controlled
+    /// from the joining logic. In that case, PlayerInput will automatically pair the device from which
+    /// the player joined. If control schemes are present in <see cref="actions"/>, the first one compatible
+    /// with that device is chosen. If additional devices are required, these will be paired from the pool
+    /// of currently unpaired devices.
+    ///
+    /// Device pairings can be changed at any time by either manually controlling pairing through
+    /// <see cref="InputUser.PerformPairingWithDevice"/> (and related methods) using a PlayerInput's
+    /// assigned <see cref="user"/> or by switching control schemes (e.g. using
+    /// <see cref="SwitchCurrentControlScheme(string,InputDevice[])"/>), if any are present in the PlayerInput's
+    /// <see cref="actions"/>.
+    ///
+    /// When a player loses a device paired to it (e.g. when it is unplugged or loses power), <see cref="InputUser"/>
+    /// will signal <see cref="InputUserChange.DeviceLost"/> which is also surfaced as a message,
+    /// <see cref="deviceLostEvent"/>, or <see cref="onDeviceLost"/> (depending on <see cref="notificationBehavior"/>).
+    /// When a device is reconnected, <see cref="InputUser"/> will signal <see cref="InputUserChange.DeviceRegained"/>
+    /// which also is surfaced as a message, as <see cref="deviceRegainedEvent"/>, or <see cref="onDeviceRegained"/>
+    /// (depending on <see cref="notificationBehavior"/>).
+    ///
+    /// When there is only a single active PlayerInput in the game, joining is not enabled (see
+    /// <see cref="PlayerInputManager.joiningEnabled"/>), and <see cref="neverAutoSwitchControlSchemes"/> is not
+    /// set to <c>true</c>, device pairings for the player will also update automatically based on device usage.
+    ///
+    /// If control schemes are present in <see cref="actions"/>, then if a device is used (not merely plugged in
+    /// but rather receives input on a non-noisy, non-synthetic control) which is compatible with a control scheme
+    /// other than the currently used one, PlayerInput will attempt to switch to that control scheme. Success depends
+    /// on whether all device requirements for that scheme are met from the set of available devices. If a control
+    /// scheme happens, <see cref="InputUser"/> signals <see cref="InputUserChange.ControlSchemeChanged"/> on
+    /// <see cref="InputUser.onChange"/>.
+    ///
+    /// If no control schemes are present in <see cref="actions"/>, PlayerInput will automatically pair any newly
+    /// available device to itself if the given device has any bindings available for it.
+    ///
+    /// Both behaviors described in the previous two paragraphs are automatically disabled if more than one
+    /// PlayerInput is active.
+    /// </para>
+    /// </remarks>
     /// <example>
     /// <code>
+    /// using UnityEngine;
+    /// using UnityEngine.InputSystem;
     /// // Component to sit next to PlayerInput.
     /// [RequireComponent(typeof(PlayerInput))]
     /// public class MyPlayerLogic : MonoBehaviour
@@ -110,14 +179,14 @@ namespace UnityEngine.InputSystem
     ///     }
     /// }
     /// </code>
-    /// </example>
-    ///
+    /// <para>
     /// It is also possible to use the polling API of <see cref="InputAction"/>s (see
     /// <see cref="InputAction.triggered"/> and <see cref="InputAction.ReadValue{TValue}"/>)
     /// in combination with PlayerInput.
-    ///
-    /// <example>
+    /// </para>
     /// <code>
+    /// using UnityEngine;
+    /// using UnityEngine.InputSystem;
     /// // Component to sit next to PlayerInput.
     /// [RequireComponent(typeof(PlayerInput))]
     /// public class MyPlayerLogic : MonoBehaviour
@@ -152,72 +221,6 @@ namespace UnityEngine.InputSystem
     /// }
     /// </code>
     /// </example>
-    ///
-    /// When enabled, PlayerInput will create an <see cref="InputUser"/> and pair devices to the
-    /// user which are then specific to the player. The set of devices can be controlled explicitly
-    /// when instantiating a PlayerInput through <see cref="Instantiate(GameObject,int,string,int,InputDevice[])"/>
-    /// or <see cref="Instantiate(GameObject,int,string,int,InputDevice)"/>. This also makes it possible
-    /// to assign the same device to two different players, e.g. for split-keyboard play.
-    ///
-    /// <example>
-    /// <code>
-    /// var p1 = PlayerInput.Instantiate(playerPrefab,
-    ///     controlScheme: "KeyboardLeft", device: Keyboard.current);
-    /// var p2 = PlayerInput.Instantiate(playerPrefab,
-    ///     controlScheme: "KeyboardRight", device: Keyboard.current);
-    /// </code>
-    /// </example>
-    ///
-    /// If no specific devices are given to a PlayerInput, the component will look for compatible
-    /// devices present in the system and pair them to itself automatically. If the PlayerInput's
-    /// <see cref="actions"/> have control schemes defined for them, PlayerInput will look for a
-    /// control scheme for which all required devices are available and not paired to any other player.
-    /// It will try <see cref="defaultControlScheme"/> first (if set), but then fall back to trying
-    /// all available schemes in order. Once a scheme is found for which all required devices are
-    /// available, PlayerInput will pair those devices to itself and select the given scheme.
-    ///
-    /// If no control schemes are defined, PlayerInput will try to bind as many as-of-yet unpaired
-    /// devices to itself as it can match to bindings present in the <see cref="actions"/>. This means
-    /// that if, for example, there's binding for both keyboard and gamepad and there is one keyboard
-    /// and two gamepads available when PlayerInput is enabled, all three devices will be paired to
-    /// the player.
-    ///
-    /// Note that when using <see cref="PlayerInputManager"/>, device pairing to players is controlled
-    /// from the joining logic. In that case, PlayerInput will automatically pair the device from which
-    /// the player joined. If control schemes are present in <see cref="actions"/>, the first one compatible
-    /// with that device is chosen. If additional devices are required, these will be paired from the pool
-    /// of currently unpaired devices.
-    ///
-    /// Device pairings can be changed at any time by either manually controlling pairing through
-    /// <see cref="InputUser.PerformPairingWithDevice"/> (and related methods) using a PlayerInput's
-    /// assigned <see cref="user"/> or by switching control schemes (e.g. using
-    /// <see cref="SwitchCurrentControlScheme(string,InputDevice[])"/>), if any are present in the PlayerInput's
-    /// <see cref="actions"/>.
-    ///
-    /// When a player loses a device paired to it (e.g. when it is unplugged or loses power), <see cref="InputUser"/>
-    /// will signal <see cref="InputUserChange.DeviceLost"/> which is also surfaced as a message,
-    /// <see cref="deviceLostEvent"/>, or <see cref="onDeviceLost"/> (depending on <see cref="notificationBehavior"/>).
-    /// When a device is reconnected, <see cref="InputUser"/> will signal <see cref="InputUserChange.DeviceRegained"/>
-    /// which also is surfaced as a message, as <see cref="deviceRegainedEvent"/>, or <see cref="onDeviceRegained"/>
-    /// (depending on <see cref="notificationBehavior"/>).
-    ///
-    /// When there is only a single active PlayerInput in the game, joining is not enabled (see
-    /// <see cref="PlayerInputManager.joiningEnabled"/>), and <see cref="neverAutoSwitchControlSchemes"/> is not
-    /// set to <c>true</c>, device pairings for the player will also update automatically based on device usage.
-    ///
-    /// If control schemes are present in <see cref="actions"/>, then if a device is used (not merely plugged in
-    /// but rather receives input on a non-noisy, non-synthetic control) which is compatible with a control scheme
-    /// other than the currently used one, PlayerInput will attempt to switch to that control scheme. Success depends
-    /// on whether all device requirements for that scheme are met from the set of available devices. If a control
-    /// scheme happens, <see cref="InputUser"/> signals <see cref="InputUserChange.ControlSchemeChanged"/> on
-    /// <see cref="InputUser.onChange"/>.
-    ///
-    /// If no control schemes are present in <see cref="actions"/>, PlayerInput will automatically pair any newly
-    /// available device to itself if the given device has any bindings available for it.
-    ///
-    /// Both behaviors described in the previous two paragraphs are automatically disabled if more than one
-    /// PlayerInput is active.
-    /// </remarks>
     /// <seealso cref="UnityEngine.InputSystem.PlayerInputManager"/>
     [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1724:TypeNamesShouldNotMatchNamespaces")]
     [AddComponentMenu("Input/Player Input")]
@@ -229,29 +232,36 @@ public class PlayerInput : MonoBehaviour
         /// Name of the message that is sent with <c>UnityEngine.Object.SendMessage</c> when a
         /// player loses a device.
         /// </summary>
-        /// <seealso cref="onDeviceLost"/>
+        /// <remarks>
+        /// The default value is <see cref="onDeviceLost"/>.
+        /// </remarks>
         public const string DeviceLostMessage = "OnDeviceLost";
 
         /// <summary>
         /// Name of the message that is sent with <c>UnityEngine.Object.SendMessage</c> when a
         /// player regains a device.
         /// </summary>
-        /// <seealso cref="onDeviceRegained"/>
+        /// <remarks>
+        /// The default value is <see cref="onDeviceRegained"/>.
+        /// </remarks>
         public const string DeviceRegainedMessage = "OnDeviceRegained";
 
         /// <summary>
         /// Name of the message that is sent with <c>UnityEngine.Object.SendMessage</c> when the
         /// controls used by a player are changed.
         /// </summary>
-        /// <seealso cref="onControlsChanged"/>
+        /// <remarks>
+        /// The default value is <see cref="onControlsChanged"/>.
+        /// </remarks>
         public const string ControlsChangedMessage = "OnControlsChanged";
 
         /// <summary>
         /// Whether input is on the player is active.
         /// </summary>
         /// <value>If true, the player is receiving input.</value>
-        /// <seealso cref="ActivateInput"/>
-        /// <seealso cref="DeactivateInput"/>
+        /// <remarks>
+        /// To activate and deactivate input use <see cref="ActivateInput"/> or <see cref="DeactivateInput"/>.
+        /// </remarks>
         public bool inputIsActive => m_InputActive;
 
         [Obsolete("Use inputIsActive instead.")]
@@ -260,7 +270,6 @@ public class PlayerInput : MonoBehaviour
         /// <summary>
         /// Unique, zero-based index of the player. For example, <c>2</c> for the third player.
         /// </summary>
-        /// <value>Unique index of the player.</value>
         /// <remarks>
         /// Once assigned, a player index will not change.
         ///
@@ -274,19 +283,20 @@ public class PlayerInput : MonoBehaviour
         /// If split-screen is enabled (<see cref="UnityEngine.InputSystem.PlayerInputManager.splitScreen"/>),
         /// this is the index of the screen area used by the player.
         /// </summary>
-        /// <value>Index of split-screen area assigned to player or -1 if the player is not
-        /// using split-screen.</value>
         /// <remarks>
+        /// Index of split-screen area assigned to player or -1 if the player is not
+        /// using split-screen.
+        ///
         /// Split screen areas are enumerated row by row and within rows, column by column. So, if, for example,
-        /// there are four separate split-screen areas, the upper left one is #0, the upper right one is #1,
+        /// there are four separate <see cref="PlayerInputManager.splitScreen"/> areas, the upper left one is #0, the upper right one is #1,
         /// the lower left one is #2, and the lower right one is #3.
         ///
         /// Split screen areas are usually assigned automatically but players can also be assigned to
         /// areas explicitly through <see cref="Instantiate(GameObject,int,string,int,InputDevice)"/> or
         /// <see cref="PlayerInputManager.JoinPlayer(int,int,string,InputDevice)"/>.
+        ///
+        /// See <see cref="camera"/>
         /// </remarks>
-        /// <seealso cref="camera"/>
-        /// <seealso cref="PlayerInputManager.splitScreen"/>
         public int splitScreenIndex => m_SplitScreenIndex;
 
         /// <summary>
@@ -308,9 +318,9 @@ public class PlayerInput : MonoBehaviour
         /// Notifications will be sent for all actions in the asset, not just for those in the first action
         /// map. This means that if additional maps are manually enabled and disabled, notifications will
         /// be sent for their actions as they receive input.
+        ///
+        /// Actions can also be associated with a user via <see cref="InputUser.actions"/>.
         /// </remarks>
-        /// <seealso cref="InputUser.actions"/>
-        /// <seealso cref="SwitchCurrentActionMap"/>
         public InputActionAsset actions
         {
             get
@@ -350,12 +360,12 @@ public InputActionAsset actions
         /// </summary>
         /// <value>Name of the currently active control scheme or <c>null</c>.</value>
         /// <remarks>
-        /// Note that this property will be <c>null</c> if there are no control schemes
+        /// Note that this property will be <c>null</c> if there are no <see cref="InputActionAsset.controlSchemes"/>
         /// defined in <see cref="actions"/>.
+        ///
+        /// This can be set via <see cref="SwitchCurrentControlScheme(UnityEngine.InputSystem.InputDevice[])"/>.
+        /// When the player input is enabled it is dependent on <see cref="defaultControlScheme"/>.
         /// </remarks>
-        /// <seealso cref="SwitchCurrentControlScheme(UnityEngine.InputSystem.InputDevice[])"/>
-        /// <seealso cref="defaultControlScheme"/>
-        /// <seealso cref="InputActionAsset.controlSchemes"/>
         public string currentControlScheme
         {
             get
@@ -369,7 +379,7 @@ public string currentControlScheme
         }
 
         /// <summary>
-        /// The default control scheme to try.
+        /// The default control scheme to try to activate when the PlayerInput component is enabled
         /// </summary>
         /// <value>Name of the default control scheme.</value>
         /// <remarks>
@@ -382,9 +392,9 @@ public string currentControlScheme
         /// Note that this property only determines the first control scheme to try. If using the
         /// control scheme fails, PlayerInput will fall back to trying the other control schemes
         /// (if any) available from <see cref="actions"/>.
+        ///
+        /// Note that you can switch the <see cref="currentControlScheme"/> manually using <see cref="SwitchCurrentControlScheme(InputDevice[])"/>.
         /// </remarks>
-        /// <seealso cref="SwitchCurrentControlScheme(InputDevice[])"/>
-        /// <seealso cref="currentControlScheme"/>
         public string defaultControlScheme
         {
             get => m_DefaultControlScheme;
@@ -397,7 +407,7 @@ public string defaultControlScheme
         /// </summary>
         /// <value>If true, do not switch control schemes when other devices are used.</value>
         /// <remarks>
-        /// By default, when there is only a single PlayerInput enabled, we assume that the game is in
+        /// By default, when there is only a single PlayerInput enabled (see <see cref="isSinglePlayer"/>), we assume that the game is in
         /// single-player mode and that the player should be able to freely switch between the control schemes
         /// supported by the game. For example, if the player is currently using mouse and keyboard, but is
         /// then switching to a gamepad, PlayerInput should automatically switch to the control scheme for
@@ -410,11 +420,9 @@ public string defaultControlScheme
         /// By setting this property to true, auto-switching of control schemes is forcibly turned off and
         /// will thus not be performed even if there is only a single PlayerInput in the game.
         ///
-        /// Note that you can still switch control schemes manually using <see
+        /// Note that you can still switch the <see cref="currentControlScheme"/> manually using <see
         /// cref="SwitchCurrentControlScheme(string,InputDevice[])"/>.
         /// </remarks>
-        /// <seealso cref="currentControlScheme"/>
-        /// <seealso cref="isSinglePlayer"/>
         public bool neverAutoSwitchControlSchemes
         {
             get => m_NeverAutoSwitchControlSchemes;
@@ -435,9 +443,9 @@ public bool neverAutoSwitchControlSchemes
 
         ////REVIEW: this is inconsistent; currentControlScheme is a string, this is an InputActionMap
         /// <summary>
-        /// The currently enabled action map.
+        /// The currently enabled action map on the PlayerInput component.
         /// </summary>
-        /// <value>Reference to the currently enabled action or <c>null</c> if no action
+        /// <value>Reference to the currently enabled action map or <c>null</c> if no action
         /// map has been enabled by PlayerInput.</value>
         /// <remarks>
         /// Note that the concept of "current action map" is local to PlayerInput. You can still freely
@@ -445,7 +453,6 @@ public bool neverAutoSwitchControlSchemes
         /// only tracks which action map has been enabled under the control of PlayerInput, i.e. either
         /// by means of <see cref="defaultActionMap"/> or by using <see cref="SwitchCurrentActionMap"/>.
         /// </remarks>
-        /// <seealso cref="SwitchCurrentActionMap"/>
         public InputActionMap currentActionMap
         {
             get => m_CurrentActionMap;
@@ -473,9 +480,10 @@ public InputActionMap currentActionMap
         /// By default, when enabled, PlayerInput will not enable any of the actions in the <see cref="actions"/>
         /// asset. By setting this property, however, PlayerInput can be made to automatically enable the respective
         /// action map.
+        ///
+        /// It will impact the <see cref="currentActionMap"/> when the PlayerInput is enabled.
+        /// Note that you can still switch action map manually using <see cref="SwitchCurrentActionMap"/>.
         /// </remarks>
-        /// <seealso cref="currentActionMap"/>
-        /// <seealso cref="SwitchCurrentActionMap"/>
         public string defaultActionMap
         {
             get => m_DefaultActionMap;
@@ -491,10 +499,10 @@ public string defaultActionMap
         /// By default, the component will use <see cref="GameObject.SendMessage(string,object)"/> to send messages
         /// to the <see cref="GameObject"/>. This can be changed by selecting a different <see cref="UnityEngine.InputSystem.PlayerNotifications"/>
         /// behavior.
+        ///
+        /// Action Events are listed in <see cref="actionEvents"/>.
+        /// Device events can be set via <see cref="deviceLostEvent"/> and <see cref="deviceRegainedEvent"/>.
         /// </remarks>
-        /// <seealso cref="actionEvents"/>
-        /// <seealso cref="deviceLostEvent"/>
-        /// <seealso cref="deviceRegainedEvent"/>
         public PlayerNotifications notificationBehavior
         {
             get => m_NotificationBehavior;
@@ -519,6 +527,8 @@ public PlayerNotifications notificationBehavior
         /// <remarks>
         /// This array is only used if <see cref="notificationBehavior"/> is set to
         /// <see cref="UnityEngine.InputSystem.PlayerNotifications.InvokeUnityEvents"/>.
+        ///
+        /// The list of actions will be dependent on the <see cref="InputActionAsset"/> specified in the <see cref="PlayerInput"/> Editor UI.
         /// </remarks>
         public ReadOnlyArray<ActionEvent> actionEvents
         {
@@ -604,6 +614,26 @@ public ControlsChangedEvent controlsChangedEvent
         /// The callbacks are called in sync (and with the same argument) with <see cref="InputAction.started"/>,
         /// <see cref="InputAction.performed"/>, and <see cref="InputAction.canceled"/>.
         /// </remarks>
+        /// <example>
+        /// <code>
+        /// using UnityEngine;
+        /// using UnityEngine.InputSystem;
+        /// // Component to sit next to PlayerInput.
+        /// [RequireComponent(typeof(PlayerInput))]
+        /// public class MyPlayerLogic : MonoBehaviour
+        /// {
+        ///     public void OnEnable()
+        ///     {
+        ///         var playerInput = GetComponent&lt;PlayerInput&gt;();
+        ///         playerInput.onActionTriggered += OnAction;
+        ///     }
+        ///
+        ///     void OnAction(InputAction.CallbackContext context)
+        ///     {
+        ///     }
+        /// }
+        /// </code>
+        /// </example>
         /// <seealso cref="InputActionMap.actionTriggered"/>
         /// <seealso cref="InputAction.started"/>
         /// <seealso cref="InputAction.performed"/>
@@ -636,6 +666,26 @@ public event Action<InputAction.CallbackContext> onActionTriggered
         ///
         /// The argument is the player that lost its device (i.e. the player on which the callback is installed).
         /// </remarks>
+        /// <example>
+        /// <code>
+        /// using UnityEngine;
+        /// using UnityEngine.InputSystem;
+        /// // Component to sit next to PlayerInput.
+        /// [RequireComponent(typeof(PlayerInput))]
+        /// public class MyPlayerLogic : MonoBehaviour
+        /// {
+        ///     public void OnEnable()
+        ///     {
+        ///         var playerInput = GetComponent&lt;PlayerInput&gt;();
+        ///         playerInput.onDeviceLost += OnDeviceLost;
+        ///     }
+        ///
+        ///     void OnDeviceLost(PlayerInput context)
+        ///     {
+        ///     }
+        /// }
+        /// </code>
+        /// </example>
         /// <seealso cref="onDeviceRegained"/>
         /// <seealso cref="InputUserChange.DeviceLost"/>
         public event Action<PlayerInput> onDeviceLost
@@ -665,6 +715,26 @@ public event Action<PlayerInput> onDeviceLost
         ///
         /// The argument is the player that regained a device (i.e. the player on which the callback is installed).
         /// </remarks>
+        /// <example>
+        /// <code>
+        /// using UnityEngine;
+        /// using UnityEngine.InputSystem;
+        /// // Component to sit next to PlayerInput.
+        /// [RequireComponent(typeof(PlayerInput))]
+        /// public class MyPlayerLogic : MonoBehaviour
+        /// {
+        ///     public void OnEnable()
+        ///     {
+        ///         var playerInput = GetComponent&lt;PlayerInput&gt;();
+        ///         playerInput.onDeviceRegained += OnDeviceRegained;
+        ///     }
+        ///
+        ///     void OnDeviceRegained(PlayerInput player)
+        ///     {
+        ///     }
+        /// }
+        /// </code>
+        /// </example>
         /// <seealso cref="onDeviceLost"/>
         /// <seealso cref="InputUserChange.DeviceRegained"/>
         public event Action<PlayerInput> onDeviceRegained
@@ -694,6 +764,26 @@ public event Action<PlayerInput> onDeviceRegained
         /// for <see cref="Keyboard"/> devices, the callback is invoked when the currently used
         /// keyboard layout (see <see cref="Keyboard.keyboardLayout"/>) changes.
         /// </remarks>
+        /// <example>
+        /// <code>
+        /// using UnityEngine;
+        /// using UnityEngine.InputSystem;
+        /// // Component to sit next to PlayerInput.
+        /// [RequireComponent(typeof(PlayerInput))]
+        /// public class MyPlayerLogic : MonoBehaviour
+        /// {
+        ///     public void OnEnable()
+        ///     {
+        ///         var playerInput = GetComponent&lt;PlayerInput&gt;();
+        ///         playerInput.onControlsChanged += OnControlsChanged;
+        ///     }
+        ///
+        ///     void OnControlsChanged(PlayerInput context)
+        ///     {
+        ///     }
+        /// }
+        /// </code>
+        /// </example>
         public event Action<PlayerInput> onControlsChanged
         {
             add
@@ -714,14 +804,14 @@ public event Action<PlayerInput> onControlsChanged
         /// <summary>
         /// Optional camera associated with the player.
         /// </summary>
-        /// <value>Camera specific to the player or <c>null</c>.</value>
         /// <remarks>
+        /// Camera specific to the player or <c>null</c>.
         /// This is <c>null</c> by default.
         ///
         /// Associating a camera with a player is necessary only when using split-screen (see <see cref="PlayerInputManager.splitScreen"/>).
         /// </remarks>
         public
-        #if UNITY_EDITOR
+#if UNITY_EDITOR
         // camera property is deprecated and only available in Editor.
         new
         #endif
@@ -760,12 +850,12 @@ public InputSystemUIInputModule uiInputModule
         public InputUser user => m_InputUser;
 
         /// <summary>
-        /// The devices paired to the player.
+        /// The list of devices paired to the player.
         /// </summary>
         /// <value>List of devices paired to player.</value>
         /// <remarks>
+        /// An InputUser also has a list of <see cref="InputUser.pairedDevices"/>
         /// </remarks>
-        /// <seealso cref="InputUser.pairedDevices"/>
         public ReadOnlyArray<InputDevice> devices
         {
             get
@@ -783,10 +873,10 @@ public ReadOnlyArray<InputDevice> devices
         /// </summary>
         /// <value>True if the player is missing devices required by the control scheme.</value>
         /// <remarks>
-        /// This can happen, for example, if the a device is unplugged during the game.
+        /// This can happen, for example, if a device is unplugged during the game.
+        /// This can also be queried at user level via <see cref="InputUser.hasMissingRequiredDevices"/>.
+        /// The control scheme set on the PlayerInput component will specify the <see cref="InputControlScheme.deviceRequirements"/>.
         /// </remarks>
-        /// <seealso cref="InputControlScheme.deviceRequirements"/>
-        /// <seealso cref="InputUser.hasMissingRequiredDevices"/>
         public bool hasMissingRequiredDevices => user.valid && user.hasMissingRequiredDevices;
 
         /// <summary>
@@ -812,20 +902,27 @@ public ReadOnlyArray<InputDevice> devices
         /// while joining is not enabled in <see cref="PlayerInputManager"/> (if one exists). See <see cref="PlayerInputManager.joiningEnabled"/>.
         ///
         /// Automatic control scheme switching (if enabled) is predicated on single-player mode being active.
+        /// This is controlled by <see cref="neverAutoSwitchControlSchemes"/>.
         /// </remarks>
-        /// <seealso cref="neverAutoSwitchControlSchemes"/>
         public static bool isSinglePlayer =>
             s_AllActivePlayersCount <= 1 &&
             (PlayerInputManager.instance == null || !PlayerInputManager.instance.joiningEnabled);
 
         /// <summary>
         /// Return the first device of the given type from <see cref="devices"/> paired to the player.
-        /// If no device of this type is paired to the player, return <c>null</c>.
         /// </summary>
         /// <typeparam name="TDevice">Type of device to look for (such as <see cref="Mouse"/>). Can be a supertype
         /// of the actual device type. For example, querying for <see cref="Pointer"/>, may return a <see cref="Mouse"/>.</typeparam>
         /// <returns>The first device paired to the player that is of the given type or <c>null</c> if the player
         /// does not have a matching device.</returns>
+        /// <remarks>
+        /// If no device of this type is paired to the player, return <c>null</c>.
+        /// </remarks>
+        /// <example>
+        /// <code>
+        /// var device = PlayerInput.all[0].GetDevice&lt;Mouse&gt;();
+        /// </code>
+        /// </example>
         /// <seealso cref="devices"/>
         public TDevice GetDevice<TDevice>()
             where TDevice : InputDevice
@@ -837,18 +934,24 @@ public TDevice GetDevice<TDevice>()
         }
 
         /// <summary>
-        /// Enable input on the player.
+        /// Enable input on the player, by enabling the current action map
         /// </summary>
         /// <remarks>
         /// Input will automatically be activated when the PlayerInput component is enabled. However, this method
         /// can be called to reactivate input after deactivating it with <see cref="DeactivateInput"/>.
         ///
         /// Note that activating input will activate the current action map only (see <see cref="currentActionMap"/>).
+        /// The state can be checked with <see cref="inputIsActive"/>.
         /// </remarks>
-        /// <see cref="inputIsActive"/>
-        /// <seealso cref="DeactivateInput"/>
+        /// <example>
+        /// <code>
+        /// PlayerInput.all[0].ActivateInput();
+        /// </code>
+        /// </example>
         public void ActivateInput()
         {
+            UpdateDelegates();
+
             m_InputActive = true;
 
             // If we have no current action map but there's a default
@@ -859,8 +962,33 @@ public void ActivateInput()
                 m_CurrentActionMap?.Enable();
         }
 
+        // Users can add and remove actions maps *after* assigning an InputActionAsset to the PlayerInput component.
+        // This ensures "actionTriggered" delegates are assigned for new maps (case isxb-711)
+        //
+        private int m_AllMapsHashCode = 0;
+        private void UpdateDelegates()
+        {
+            if (m_Actions == null)
+            {
+                m_AllMapsHashCode = 0;
+                return;
+            }
+
+            int allMapsHashCode = 0;
+            foreach (var actionMap in m_Actions.actionMaps)
+            {
+                allMapsHashCode ^= actionMap.GetHashCode();
+            }
+            if (m_AllMapsHashCode != allMapsHashCode)
+            {
+                InstallOnActionTriggeredHook();
+                CacheMessageNames();
+                m_AllMapsHashCode = allMapsHashCode;
+            }
+        }
+
         /// <summary>
-        /// Disable input on the player.
+        /// Disable input on the player, by disabling the current action map
         /// </summary>
         /// <remarks>
         /// Input is automatically activated when the PlayerInput component is enabled. This method can be
@@ -868,8 +996,13 @@ public void ActivateInput()
         ///
         /// Note that activating input will deactivate the current action map only (see <see cref="currentActionMap"/>).
         /// </remarks>
-        /// <see cref="ActivateInput"/>
-        /// <see cref="inputIsActive"/>
+        /// <example>
+        /// <code>
+        /// PlayerInput.all[0].DeactivateInput();
+        /// </code>
+        /// </example>
+        /// <seealso cref="ActivateInput"/>
+        /// <seealso cref="inputIsActive"/>
         public void DeactivateInput()
         {
             m_CurrentActionMap?.Disable();
@@ -894,15 +1027,13 @@ public void PassivateInput()
         /// <exception cref="InvalidOperationException"><see cref="actions"/> has not been assigned.</exception>
         /// <remarks>
         /// The player's currently paired devices (see <see cref="devices"/>) will get unpaired.
-        ///
+        /// </remarks>
         /// <example>
         /// <code>
         /// // Switch the first player to keyboard and mouse.
-        /// PlayerInput.all[0]
-        ///     .SwitchCurrentControlScheme(Keyboard.current, Mouse.current);
+        /// PlayerInput.all[0].SwitchCurrentControlScheme(Keyboard.current, Mouse.current);
         /// </code>
         /// </example>
-        /// </remarks>
         /// <seealso cref="currentControlScheme"/>
         /// <seealso cref="InputActionAsset.controlSchemes"/>
         public bool SwitchCurrentControlScheme(params InputDevice[] devices)
@@ -929,13 +1060,14 @@ public bool SwitchCurrentControlScheme(params InputDevice[] devices)
         /// Switch the player to use the given control scheme together with the given devices.
         /// </summary>
         /// <param name="controlScheme">Name of the control scheme. See <see cref="InputControlScheme.name"/>.</param>
-        /// <param name="devices">A list of devices.</param>
+        /// <param name="devices">A list of input devices to consider for pairing against</param>
         /// <exception cref="ArgumentNullException"><paramref name="devices"/> is <c>null</c> -or- <paramref name="controlScheme"/> is
         /// <c>null</c> or empty.</exception>
         /// <remarks>
         /// This method can be used to explicitly force a combination of control scheme and a specific set of
         /// devices.
-        ///
+        /// The player's currently paired devices (see <see cref="devices"/>) will get unpaired.
+        /// </remarks>
         /// <example>
         /// <code>
         /// // Put player 1 on the "Gamepad" control scheme together
@@ -945,9 +1077,6 @@ public bool SwitchCurrentControlScheme(params InputDevice[] devices)
         ///     Gamepad.all[1]);
         /// </code>
         /// </example>
-        ///
-        /// The player's currently paired devices (see <see cref="devices"/>) will get unpaired.
-        /// </remarks>
         /// <seealso cref="InputActionAsset.controlSchemes"/>
         /// <seealso cref="currentControlScheme"/>
         public void SwitchCurrentControlScheme(string controlScheme, params InputDevice[] devices)
@@ -961,6 +1090,19 @@ public void SwitchCurrentControlScheme(string controlScheme, params InputDevice[
             SwitchControlSchemeInternal(ref scheme, devices);
         }
 
+        /// <summary>
+        /// Switch the player to use the given action map
+        /// </summary>
+        /// <param name="mapNameOrId">Name of the action map or its ID.</param>
+        /// <remarks>
+        /// This method can be used to explicitly set an action map.
+        /// </remarks>
+        /// <example>
+        /// <code>
+        /// PlayerInput.all[0].SwitchCurrentActionMap("Player");
+        /// </code>
+        /// </example>
+        /// <seealso cref="InputActionMap"/>
         public void SwitchCurrentActionMap(string mapNameOrId)
         {
             // Must be enabled.
@@ -989,11 +1131,19 @@ public void SwitchCurrentActionMap(string mapNameOrId)
         }
 
         /// <summary>
-        /// Return the Nth player.
+        /// Return the player with specified player index.
         /// </summary>
-        /// <param name="playerIndex">Index of the player to return.</param>
+        /// <param name="playerIndex">The index into the active player list.</param>
         /// <returns>The player with the given player index or <c>null</c> if no such
         /// player exists.</returns>
+        /// <remarks>
+        /// Return the player with specified player index.
+        /// </remarks>
+        /// <example>
+        /// <code>
+        /// PlayerInput player = PlayerInput.GetPlayerByIndex(0);
+        /// </code>
+        /// </example>
         /// <seealso cref="PlayerInput.playerIndex"/>
         public static PlayerInput GetPlayerByIndex(int playerIndex)
         {
@@ -1006,18 +1156,19 @@ public static PlayerInput GetPlayerByIndex(int playerIndex)
         /// <summary>
         /// Find the first PlayerInput who the given device is paired to.
         /// </summary>
-        /// <param name="device">An input device.</param>
+        /// <param name="device">An input device to query</param>
         /// <returns>The player who is paired to the given device or <c>null</c> if no
         /// PlayerInput currently is paired to <paramref name="device"/>.</returns>
         /// <exception cref="ArgumentNullException"><paramref name="device"/> is <c>null</c>.</exception>
         /// <remarks>
+        /// There could be multiple players paired to the device. This function will return the first one found.
+        /// </remarks>
         /// <example>
         /// <code>
         /// // Find the player paired to first gamepad.
         /// var player = PlayerInput.FindFirstPairedToDevice(Gamepad.all[0]);
         /// </code>
         /// </example>
-        /// </remarks>
         public static PlayerInput FindFirstPairedToDevice(InputDevice device)
         {
             if (device == null)
@@ -1033,18 +1184,26 @@ public static PlayerInput FindFirstPairedToDevice(InputDevice device)
         }
 
         /// <summary>
-        /// Instantiate a player object and set up and enable its inputs.
+        /// Instantiate a player object, set up and enable its inputs.
         /// </summary>
         /// <param name="prefab">Prefab to clone. Must contain a PlayerInput component somewhere in its hierarchy.</param>
         /// <param name="playerIndex">Player index to assign to the player. See <see cref="PlayerInput.playerIndex"/>.
         /// By default will be assigned automatically based on how many players are in <see cref="all"/>.</param>
-        /// <param name="controlScheme">Control scheme to activate</param>
-        /// <param name="splitScreenIndex"></param>
+        /// <param name="controlScheme">Control scheme to activate.</param>
+        /// <param name="splitScreenIndex">Which split screen to instantiate on.</param>
         /// <param name="pairWithDevice">Device to pair to the user. By default, this is <c>null</c> which means
         /// that PlayerInput will automatically pair with available, unpaired devices based on the control schemes (if any)
         /// present in <see cref="actions"/> or on the bindings therein (if no control schemes are present).</param>
-        /// <returns></returns>
+        /// <returns>Newly created PlayerInput component.</returns>
         /// <exception cref="ArgumentNullException"><paramref name="prefab"/> is <c>null</c>.</exception>
+        /// <remarks>
+        /// Instantiate a player object, set up and enable its inputs.
+        /// </remarks>
+        /// <example>
+        /// <code>
+        /// var p1 = PlayerInput.Instantiate(playerPrefab, controlScheme: "KeyboardLeft", device: Keyboard.current);
+        /// </code>
+        /// </example>
         public static PlayerInput Instantiate(GameObject prefab, int playerIndex = -1, string controlScheme = null,
             int splitScreenIndex = -1, InputDevice pairWithDevice = null)
         {
@@ -1068,15 +1227,21 @@ public static PlayerInput Instantiate(GameObject prefab, int playerIndex = -1, s
         /// automatically pair one or more specific devices to the newly created player.
         /// </summary>
         /// <param name="prefab">A player prefab containing a <see cref="PlayerInput"/> component in its hierarchy.</param>
-        /// <param name="playerIndex"></param>
-        /// <param name="controlScheme"></param>
-        /// <param name="splitScreenIndex"></param>
-        /// <param name="pairWithDevices"></param>
-        /// <returns></returns>
+        /// <param name="playerIndex">Player index to instantiate.</param>
+        /// <param name="controlScheme">Control scheme to activate.</param>
+        /// <param name="splitScreenIndex">Which split screen to instantiate on.</param>
+        /// <param name="pairWithDevices">Which devices to limit pairing to.</param>
+        /// <returns>Newly created PlayerInput component.</returns>
         /// <remarks>
         /// Note that unlike <see cref="Object.Instantiate(Object)"/>, this method will always activate the resulting
         /// <see cref="GameObject"/> and its components.
         /// </remarks>
+        /// <example>
+        /// <code>
+        /// var devices = new InputDevice[] { Gamepad.all[0], Gamepad.all[1] };
+        /// var p1 = PlayerInput.Instantiate(playerPrefab, controlScheme: "Gamepad", pairWithDevices: devices);
+        /// </code>
+        /// </example>
         public static PlayerInput Instantiate(GameObject prefab, int playerIndex = -1, string controlScheme = null,
             int splitScreenIndex = -1, params InputDevice[] pairWithDevices)
         {
@@ -1377,6 +1542,8 @@ private void CacheMessageNames()
 
         private void ClearCaches()
         {
+            if (m_ActionMessageNames != null)
+                m_ActionMessageNames.Clear();
         }
 
         /// <summary>
@@ -1761,8 +1928,32 @@ private void OnDisable()
 
         // ReSharper disable once UnusedMember.Global
         /// <summary>
-        /// Debug helper method that can be hooked up to actions when using <see cref="UnityEngine.InputSystem.PlayerNotifications.InvokeUnityEvents"/>.
+        /// Debug helper method that can be hooked up to actions.
         /// </summary>
+        /// <param name="context">Information about what triggered the action.</param>
+        /// <remarks>
+        /// Debug helper method that can be hooked up to actions when using <see cref="UnityEngine.InputSystem.PlayerNotifications.InvokeUnityEvents"/>.
+        /// </remarks>
+        /// <example>
+        /// <code>
+        /// using UnityEngine;
+        /// using UnityEngine.InputSystem;
+        /// // Component to sit next to PlayerInput.
+        /// [RequireComponent(typeof(PlayerInput))]
+        /// public class MyPlayerLogic : MonoBehaviour
+        /// {
+        ///     public void OnEnable()
+        ///     {
+        ///         var playerInput = GetComponent&lt;PlayerInput&gt;();
+        ///         playerInput.onActionTriggered += DebugLogAction;
+        ///     }
+        ///     public void OnDisable()
+        ///     {
+        ///         playerInput.onActionTriggered -= DebugLogAction;
+        ///     }
+        /// }
+        /// </code>
+        /// </example>
         public void DebugLogAction(InputAction.CallbackContext context)
         {
             Debug.Log(context.ToString());
@@ -1953,7 +2144,7 @@ private void SwitchControlSchemeInternal(ref InputControlScheme controlScheme, p
         {
             Debug.Assert(devices != null);
 
-            // Note that we are doing two somwhat uncorrelated actions here:
+            // Note that we are doing two somewhat uncorrelated actions here:
             // - Switching control scheme
             // - Explicitly pairing with given devices regardless if making sense with respect to control scheme
             using (InputActionRebindingExtensions.DeferBindingResolution())
@@ -1978,19 +2169,68 @@ private void SwitchControlSchemeInternal(ref InputControlScheme controlScheme, p
             }
         }
 
+        /// <summary>
+        /// An event associated with an PlayerInput action.
+        /// </summary>
+        /// <remarks>
+        /// Represents an event invoked in response to actions being triggered.
+        ///
+        /// Contains the ID and name of the <see cref="InputAction"/> being triggered and the associated <see cref="UnityAction"/> to handle the action response.
+        ///
+        /// The list of action events is specified in <see cref="PlayerInput"/> Editor UI based on the selected <see cref="InputActionAsset"/>.
+        /// The individual action callbacks are then specified in a <see cref="MonoBehaviour"/>.
+        ///
+        /// </remarks>
+        /// <example>
+        /// <code>
+        /// public class MyPlayerScript : MonoBehaviour
+        /// {
+        ///     void OnFireEvent(InputAction.CallbackContext context)
+        ///     {
+        ///         // Handle fire event
+        ///     }
+        /// }
+        /// </code>
+        /// </example>
+        /// <seealso cref="PlayerInput.actionEvents"/>
+        /// <seealso cref="InputAction.CallbackContext"/>
         [Serializable]
         public class ActionEvent : UnityEvent<InputAction.CallbackContext>
         {
+            /// <summary>
+            /// Action GUID string for the action that triggered the event.
+            /// </summary>
             public string actionId => m_ActionId;
+
+            /// <summary>
+            /// Name of the action that triggered the event.
+            /// </summary>
             public string actionName => m_ActionName;
 
             [SerializeField] private string m_ActionId;
             [SerializeField] private string m_ActionName;
 
+            /// <summary>
+            /// Construct an empty action event.
+            /// </summary>
+            /// <remarks>
+            /// The event will not have an associated action.
+            /// </remarks>
+            /// <seealso cref="PlayerInput.actionEvents"/>
             public ActionEvent()
             {
             }
 
+            /// <summary>
+            /// Construct an action event and associate it with an action.
+            /// </summary>
+            /// <remarks>
+            /// The event will be associated with the specified action. The action must be part of an action asset.
+            /// </remarks>
+            /// <param name="action">The action to associate with the event. The action must be part of an action asset.</param>
+            /// <exception cref="ArgumentNullException">The action is <c>null</c>.</exception>
+            /// <exception cref="ArgumentException">The action is not part of an action asset.</exception>
+            /// <seealso cref="PlayerInput.actionEvents"/>
             public ActionEvent(InputAction action)
             {
                 if (action == null)
@@ -2004,6 +2244,15 @@ public ActionEvent(InputAction action)
                 m_ActionName = $"{action.actionMap.name}/{action.name}";
             }
 
+            /// <summary>
+            /// Construct an action event and associated it with an action by GUID.
+            /// </summary>
+            /// <remarks>
+            /// The event will be associated with the specified action.
+            /// </remarks>
+            /// <param name="actionGUID">Action GUID.</param>
+            /// <param name="name">Name of the action.</param>
+            /// <seealso cref="PlayerInput.actionEvents"/>
             public ActionEvent(Guid actionGUID, string name = null)
             {
                 m_ActionId = actionGUID.ToString();
@@ -2014,7 +2263,9 @@ public ActionEvent(Guid actionGUID, string name = null)
         /// <summary>
         /// Event that is triggered when an <see cref="InputDevice"/> paired to a <see cref="PlayerInput"/> is disconnected.
         /// </summary>
-        /// <seealso cref="deviceLostEvent"/>
+        /// <remarks>
+        /// The device lost event can be set on via <see cref="deviceLostEvent"/>.
+        /// </remarks>
         [Serializable]
         public class DeviceLostEvent : UnityEvent<PlayerInput>
         {
@@ -2023,7 +2274,9 @@ public class DeviceLostEvent : UnityEvent<PlayerInput>
         /// <summary>
         /// Event that is triggered when a <see cref="PlayerInput"/> regains an <see cref="InputDevice"/> previously lost.
         /// </summary>
-        /// <seealso cref="deviceRegainedEvent"/>
+        /// <remarks>
+        /// The device regained event can be set on via <see cref="deviceRegainedEvent"/>.
+        /// </remarks>
         [Serializable]
         public class DeviceRegainedEvent : UnityEvent<PlayerInput>
         {
@@ -2032,7 +2285,9 @@ public class DeviceRegainedEvent : UnityEvent<PlayerInput>
         /// <summary>
         /// Event that is triggered when the set of controls used by a <see cref="PlayerInput"/> changes.
         /// </summary>
-        /// <seealso cref="controlsChangedEvent"/>
+        /// <remarks>
+        /// The changed event can be set on via <see cref="controlsChangedEvent"/>.
+        /// </remarks>
         [Serializable]
         public class ControlsChangedEvent : UnityEvent<PlayerInput>
         {
diff --git a/Packages/com.unity.inputsystem/InputSystem/Plugins/UI/InputSystemUIInputModule.cs b/Packages/com.unity.inputsystem/InputSystem/Plugins/UI/InputSystemUIInputModule.cs
index c72e043c71..4d80420a8f 100644
--- a/Packages/com.unity.inputsystem/InputSystem/Plugins/UI/InputSystemUIInputModule.cs
+++ b/Packages/com.unity.inputsystem/InputSystem/Plugins/UI/InputSystemUIInputModule.cs
@@ -39,22 +39,83 @@ namespace UnityEngine.InputSystem.UI
     /// Input module that takes its input from <see cref="InputAction">input actions</see>.
     /// </summary>
     /// <remarks>
+    /// <para>
+    /// This module processes all UI input based on the Input System. It is the "glue" between UI systems (UGUI, UITK)
+    /// and the Input System.
+    /// </para>
+    /// <para>
+    /// When adding this component from code (such as through <c>GameObject.AddComponent</c>), the
+    /// resulting module will automatically have <see cref="DefaultInputActions"/> assigned to it.
+    /// If you want to use your own actions, you should create an <see cref="InputActionAsset"/> with the necessary
+    /// UI actions. You can copy the default actions and edit them as you need. To have editable Input Actions
+    /// out-of-the box you can use the project-wide actions through InputSystem.actions. More information about this
+    /// can be read in the <a href="../Manual/InputActions.html">manual</a> documentation.
+    /// </para>
+    /// <para>
+    /// This module can be configured in the Editor > Inspector when added as a component to a <c>GameObject</c>.
+    /// </para>
+    /// <para>
     /// This UI input module has the advantage over other such modules that it doesn't have to know
     /// what devices and types of devices input is coming from. Instead, the actions hide the actual
     /// sources of input from the module.
-    ///
-    /// When adding this component from code (such as through <c>GameObject.AddComponent</c>), the
-    /// resulting module will automatically have a set of default input actions assigned to it
-    /// (see <see cref="AssignDefaultActions"/>).
+    /// </para>
     /// </remarks>
+    /// <seealso cref="BaseInputModule"/>
+    /// <seealso cref="InputActionAsset"/>
+    /// <seealso cref="InputAction"/>
+    /// <seealso cref="EventSystem"/>
+    /// <seealso cref="AssignDefaultActions"/>
+    /// <example>
+    /// <code>
+    /// using UnityEngine;
+    /// using UnityEngine.InputSystem;
+    /// using UnityEngine.InputSystem.UI;
+    /// using UnityEngine.EventSystems;
+    ///
+    /// class InputSystemUIInputModuleExample : MonoBehaviour
+    /// {
+    ///     private InputSystemUIInputModule uiModule;
+    ///
+    ///     // Configure the InputSystemUIInputModule component programmatically on Start()
+    ///     // But a lot of this could be done at runtime as well.
+    ///     void Start()
+    ///     {
+    ///         // Find the EventSystem in the scene
+    ///         var eventSystem = EventSystem.current;
+    ///
+    ///         // Get the InputSystemUIInputModule component
+    ///         uiModule = eventSystem.GetComponent&lt;InputSystemUIInputModule&gt;();
+    ///
+    ///         // Using the default input actions just as an example. Another InputActionAsset can be used.
+    ///         DefaultInputActions defaultInputActions = new DefaultInputActions();
+    ///         // Example on how to assign individual actions programmatically
+    ///         uiModule.actionsAsset = defaultInputActions.asset;
+    ///         uiModule.leftClick = InputActionReference.Create(defaultInputActions.UI.Click);
+    ///         uiModule.scrollWheel = InputActionReference.Create(defaultInputActions.UI.ScrollWheel);
+    ///
+    ///         // Set other fields programmatically
+    ///         uiModule.deselectOnBackgroundClick = true;
+    ///         uiModule.pointerBehavior = UIPointerBehavior.SingleMouseOrPenButMultiTouchAndTrack;
+    ///         uiModule.cursorLockBehavior = InputSystemUIInputModule.CursorLockBehavior.ScreenCenter;
+    ///     }
+    ///
+    ///     // Example on how programmatically set the move repeat delay based on the move repeat rate
+    ///     void SetMoveRepeat(float value)
+    ///     {
+    ///         uiModule.moveRepeatRate = value;
+    ///         uiModule.moveRepeatDelay = value * (1.2f);
+    ///     }
+    /// }
+    /// </code>
+    /// </example>
     [HelpURL(InputSystem.kDocUrl + "/manual/UISupport.html#setting-up-ui-input")]
     public class InputSystemUIInputModule : BaseInputModule
     {
         /// <summary>
         /// Whether to clear the current selection when a click happens that does not hit any <c>GameObject</c>.
         /// </summary>
-        /// <value>If true (default), clicking outside of any GameObject will reset the current selection.</value>
         /// <remarks>
+        /// If true (default), clicking outside of any GameObject will reset the current selection
         /// By toggling this behavior off, background clicks will keep the current selection. I.e.
         /// <c>EventSystem.currentSelectedGameObject</c> will not be changed.
         /// </remarks>
@@ -137,6 +198,35 @@ public float scrollDeltaPerTick
         /// <summary>
         /// Called by <c>EventSystem</c> when the input module is made current.
         /// </summary>
+        /// <remarks>
+        /// There's no need to call this method directly unless for specific reasons.
+        /// It is called by <c>EventSystem</c> when the input module is made current.
+        /// It sets <see cref="EventSystem.currentSelectedGameObject"/> to
+        /// <see cref="EventSystem.firstSelectedGameObject"/>  if nothing is selected.
+        /// </remarks>
+        /// <example>
+        /// <code>
+        /// using UnityEngine;
+        /// using UnityEngine.EventSystems;
+        /// using UnityEngine.InputSystem.UI;
+        ///
+        /// public class ActivateModuleExample : MonoBehaviour
+        /// {
+        ///     private InputSystemUIInputModule uiModule;
+        ///     void Start()
+        ///     {
+        ///         // Find the EventSystem in the scene
+        ///         var eventSystem = EventSystem.current;
+        ///
+        ///         // Get the InputSystemUIInputModule component
+        ///         uiModule = eventSystem.GetComponent&lt;InputSystemUIInputModule&gt;();
+        ///
+        ///         // Manually activate the module
+        ///         uiModule.ActivateModule();
+        ///     }
+        /// }
+        /// </code>
+        /// </example>
         public override void ActivateModule()
         {
             base.ActivateModule();
@@ -177,7 +267,7 @@ public override void ActivateModule()
         /// Calling this method from within an <see cref="InputAction"/> callback (such as <see cref="InputAction.performed"/>)
         /// will result in a warning. See the "UI vs Game Input" sample shipped with the Input System package for
         /// how to deal with this fact.
-        ///
+        /// </remarks>
         /// <example>
         /// <code>
         /// // In general, the pointer ID corresponds to the device ID:
@@ -197,7 +287,6 @@ public override void ActivateModule()
         /// EventSystem.current.IsPointerOverGameObject(); // Equivalent.
         /// </code>
         /// </example>
-        /// </remarks>
         /// <seealso cref="ExtendedPointerEventData.touchId"/>
         /// <seealso cref="InputDevice.deviceId"/>
         public override bool IsPointerOverGameObject(int pointerOrTouchId)
@@ -252,6 +341,44 @@ public override bool IsPointerOverGameObject(int pointerOrTouchId)
         /// </remarks>
         /// <seealso cref="ExtendedPointerEventData.touchId"/>
         /// <seealso cref="InputDevice.deviceId"/>
+        /// <example>
+        /// <code>
+        /// using UnityEngine;
+        /// using UnityEngine.EventSystems;
+        /// using UnityEngine.InputSystem;
+        /// using UnityEngine.InputSystem.UI;
+        ///
+        /// public class GetLastRaycastResultExample : MonoBehaviour
+        /// {
+        ///     public InputSystemUIInputModule uiModule;
+        ///
+        ///     void PrintLastRaycastResult(int pointerId)
+        ///     {
+        ///         if (uiModule)
+        ///         {
+        ///             // Retrieve the last raycast result for the given pointer ID
+        ///             RaycastResult raycastResult = uiModule.GetLastRaycastResult(pointerId);
+        ///
+        ///             // Check if the raycast result is valid
+        ///             if (raycastResult.isValid)
+        ///             {
+        ///                 // Print details about the raycast result
+        ///                 Debug.Log($"Pointer ID: {pointerId}");
+        ///                 Debug.Log($"Hit GameObject: {raycastResult.gameObject.name}");
+        ///                 Debug.Log($"Distance: {raycastResult.distance}");
+        ///                 Debug.Log($"World Position: {raycastResult.worldPosition}");
+        ///             }
+        ///         }
+        ///
+        ///     }
+        ///
+        ///     void Update()
+        ///     {
+        ///         PrintLastRaycastResult(Mouse.current.deviceId);
+        ///     }
+        /// }
+        /// </code>
+        /// </example>
         public RaycastResult GetLastRaycastResult(int pointerOrTouchId)
         {
             var stateIndex = GetPointerStateIndexFor(pointerOrTouchId);
@@ -850,7 +977,6 @@ private bool IsMoveAllowed(AxisEventData eventData)
         /// </remarks>
         /// <seealso cref="moveRepeatRate"/>
         /// <seealso cref="AxisEventData"/>
-        /// <see cref="move"/>
         public float moveRepeatDelay
         {
             get => m_MoveRepeatDelay;
@@ -867,9 +993,6 @@ public float moveRepeatDelay
         /// Note that a maximum of one <see cref="AxisEventData"/> will be sent per frame. This means that even if multiple time
         /// increments of the repeat delay have passed since the last update, only one move repeat event will be generated.
         /// </remarks>
-        /// <seealso cref="moveRepeatDelay"/>
-        /// <seealso cref="AxisEventData"/>
-        /// <see cref="move"/>
         public float moveRepeatRate
         {
             get => m_MoveRepeatRate;
@@ -887,6 +1010,9 @@ private bool shouldIgnoreFocus
             get => explictlyIgnoreFocus || InputRuntime.s_Instance.runInBackground;
         }
 
+        /// <summary>
+        /// (Obsolete) <inheritdoc cref="moveRepeatRate"/>
+        /// </summary>
         [Obsolete("'repeatRate' has been obsoleted; use 'moveRepeatRate' instead. (UnityUpgradable) -> moveRepeatRate", false)]
         public float repeatRate
         {
@@ -894,6 +1020,9 @@ public float repeatRate
             set => moveRepeatRate = value;
         }
 
+        /// <summary>
+        /// (Obsolete) <inheritdoc cref="moveRepeatDelay"/>
+        /// </summary>
         [Obsolete("'repeatDelay' has been obsoleted; use 'moveRepeatDelay' instead. (UnityUpgradable) -> moveRepeatDelay", false)]
         public float repeatDelay
         {
@@ -903,10 +1032,14 @@ public float repeatDelay
 
         /// <summary>
         /// A <see cref="Transform"/> representing the real world origin for tracking devices.
-        /// This is used to convert real world positions and rotations for <see cref="UIPointerType.Tracked"/> pointers into Unity's global space.
-        /// When using the XR Interaction Toolkit, this should be pointing to the XR Rig's Transform.
         /// </summary>
-        /// <remarks>This will transform all tracked pointers. If unset, or set to null, the Unity world origin will be used as the basis for all tracked positions and rotations.</remarks>
+        /// <remarks>
+        /// This is used to convert real world positions and rotations for all <see cref="UIPointerType.Tracked"/>
+        /// pointers into Unity's global space.
+        /// When using the XR Interaction Toolkit, this should be pointing to the XR Rig's Transform.
+        /// If unset, or set to null, the Unity world origin will be used as the basis for all tracked positions and
+        /// rotations.
+        /// </remarks>
         public Transform xrTrackingOrigin
         {
             get => m_XRTrackingOrigin;
@@ -999,10 +1132,6 @@ private bool IsNavigationAction(InputActionReference reference)
         /// </code>
         /// </example>
         /// </remarks>
-        /// <seealso cref="leftClick"/>
-        /// <seealso cref="rightClick"/>
-        /// <seealso cref="middleClick"/>
-        /// <seealso cref="scrollWheel"/>
         public InputActionReference point
         {
             get => m_PointAction;
@@ -1044,10 +1173,6 @@ public InputActionReference point
         /// </code>
         /// </example>
         /// </remarks>
-        /// <seealso cref="leftClick"/>
-        /// <seealso cref="rightClick"/>
-        /// <seealso cref="middleClick"/>
-        /// <seealso cref="point"/>
         public InputActionReference scrollWheel
         {
             get => m_ScrollWheelAction;
@@ -1090,10 +1215,6 @@ public InputActionReference scrollWheel
         /// </code>
         /// </example>
         /// </remarks>
-        /// <seealso cref="rightClick"/>
-        /// <seealso cref="middleClick"/>
-        /// <seealso cref="scrollWheel"/>
-        /// <seealso cref="point"/>
         public InputActionReference leftClick
         {
             get => m_LeftClickAction;
@@ -1141,10 +1262,6 @@ public InputActionReference leftClick
         /// </code>
         /// </example>
         /// </remarks>
-        /// <seealso cref="leftClick"/>
-        /// <seealso cref="rightClick"/>
-        /// <seealso cref="scrollWheel"/>
-        /// <seealso cref="point"/>
         public InputActionReference middleClick
         {
             get => m_MiddleClickAction;
@@ -1192,10 +1309,6 @@ public InputActionReference middleClick
         /// </code>
         /// </example>
         /// </remarks>
-        /// <seealso cref="leftClick"/>
-        /// <seealso cref="middleClick"/>
-        /// <seealso cref="scrollWheel"/>
-        /// <seealso cref="point"/>
         public InputActionReference rightClick
         {
             get => m_RightClickAction;
@@ -1237,8 +1350,6 @@ public InputActionReference rightClick
         /// </code>
         /// </example>
         /// </remarks>
-        /// <seealso cref="submit"/>
-        /// <seealso cref="cancel"/>
         public InputActionReference move
         {
             get => m_MoveAction;
@@ -1279,8 +1390,6 @@ public InputActionReference move
         /// </code>
         /// </example>
         /// </remarks>
-        /// <seealso cref="move"/>
-        /// <seealso cref="cancel"/>
         public InputActionReference submit
         {
             get => m_SubmitAction;
@@ -1321,8 +1430,6 @@ public InputActionReference submit
         /// </code>
         /// </example>
         /// </remarks>
-        /// <seealso cref="move"/>
-        /// <seealso cref="submit"/>
         public InputActionReference cancel
         {
             get => m_CancelAction;
@@ -1364,7 +1471,6 @@ public InputActionReference cancel
         /// </code>
         /// </example>
         /// </remarks>
-        /// <seealso cref="trackedDevicePosition"/>
         public InputActionReference trackedDeviceOrientation
         {
             get => m_TrackedDeviceOrientationAction;
@@ -1406,7 +1512,6 @@ public InputActionReference trackedDeviceOrientation
         /// </code>
         /// </example>
         /// </remarks>
-        /// <seealso cref="trackedDeviceOrientation"/>
         public InputActionReference trackedDevicePosition
         {
             get => m_TrackedDevicePositionAction;
@@ -1424,26 +1529,10 @@ public InputActionReference trackedDevicePosition
         /// Note that if an <c>InputSystemUIInputModule</c> component is programmatically added to a <c>GameObject</c>,
         /// it will automatically receive the default actions as part of its <c>OnEnable</c> method. Use <see cref="UnassignActions"/>
         /// to remove these assignments.
-        ///
+        /// </remarks>
         /// <example>
-        /// <code>
-        /// var go = new GameObject();
-        /// go.AddComponent&lt;EventSystem&gt;();
-        ///
-        /// // Adding the UI module like this will implicitly enable it and thus lead to
-        /// // automatic assignment of the default input actions.
-        /// var uiModule = go.AddComponent&lt;InputSystemUIInputModule&gt;();
-        ///
-        /// // Manually remove the default input actions.
-        /// uiModule.UnassignActions();
-        /// </code>
+        /// <code source="../../../DocCodeSamples.Tests/InputSystemUIInputModuleAssignActionsExample.cs"/>
         /// </example>
-        /// </remarks>
-        /// <seealso cref="actionsAsset"/>
-        /// <seealso cref="DefaultInputActions"/>
-
-        private static DefaultInputActions defaultActions;
-
         public void AssignDefaultActions()
         {
             if (defaultActions == null)
@@ -1463,14 +1552,24 @@ public void AssignDefaultActions()
             trackedDevicePosition = InputActionReference.Create(defaultActions.UI.TrackedDevicePosition);
         }
 
+        private static DefaultInputActions defaultActions;
+
         /// <summary>
-        /// Remove all action assignments, that is <see cref="actionsAsset"/> as well as all individual
-        /// actions such as <see cref="leftClick"/>.
+        /// Remove all action assignments.
         /// </summary>
         /// <remarks>
+        /// Resets <see cref="actionsAsset"/> reference as well as all individual
+        /// actions references, such as <see cref="leftClick"/> , and removes the correspondent callbacks hooked for
+        /// <see cref="InputAction.performed"/> and <see cref="InputAction.canceled"/>
+        ///
+        /// It also disposes <see cref="defaultActions"/>.
+        ///
         /// If the current actions were enabled by the UI input module, they will be disabled in the process.
         /// </remarks>
         /// <seealso cref="AssignDefaultActions"/>
+        /// <example>
+        /// <code source="../../../DocCodeSamples.Tests/InputSystemUIInputModuleAssignActionsExample.cs"/>
+        /// </example>
         public void UnassignActions()
         {
             defaultActions?.Dispose();
@@ -1488,6 +1587,10 @@ public void UnassignActions()
             trackedDevicePosition = default;
         }
 
+        /// <summary>
+        /// (Obsolete) This API has been obsoleted; use <see cref="leftClick"/> instead.
+        /// </summary>
+        /// <exception cref="InvalidOperationException"></exception>
         [Obsolete("'trackedDeviceSelect' has been obsoleted; use 'leftClick' instead.", true)]
         public InputActionReference trackedDeviceSelect
         {
@@ -1496,6 +1599,7 @@ public InputActionReference trackedDeviceSelect
         }
 
 #if UNITY_EDITOR
+        /// <inheritdoc/>
         protected override void Reset()
         {
             base.Reset();
@@ -1509,6 +1613,7 @@ protected override void Reset()
 
 #endif
 
+        /// <inheritdoc/>
         protected override void Awake()
         {
             base.Awake();
@@ -1516,6 +1621,7 @@ protected override void Awake()
             m_NavigationState.Reset();
         }
 
+        /// <inheritdoc/>
         protected override void OnDestroy()
         {
             base.OnDestroy();
@@ -1523,6 +1629,7 @@ protected override void OnDestroy()
             UnhookActions();
         }
 
+        /// <inheritdoc/>
         protected override void OnEnable()
         {
             base.OnEnable();
@@ -1540,6 +1647,7 @@ protected override void OnEnable()
             EnableAllActions();
         }
 
+        /// <inheritdoc/>
         protected override void OnDisable()
         {
             ResetPointers();
@@ -2222,6 +2330,49 @@ private void FilterPointerStatesByType()
             }
         }
 
+        /// <inheritdoc cref="BaseInputModule.Process"/>
+        /// <remarks>
+        /// <para>This method is automatically called by <see cref="EventSystem.Update()"/> once per frame.
+        /// There is no need to call it manually. Unless for specific use cases.
+        /// </para>
+        /// It processes all <see cref="UIPointerType"/> and <see cref="UIPointerBehavior"/> pointer types,
+        /// as well as navigation input state from <see cref="m_PointerStates"/> and <see cref="m_NavigationState"/>.
+        /// These fields hold state based on the actions set up for the UI action map of <see cref="actionsAsset"/>.
+        /// The InputAction callbacks are responsible for updating their state, which means state can change multiple
+        /// times during a frame, even though it will only be processed once per frame. For example, in case there are
+        /// multiple clicks or touches in a single frame, they can allocate multiple pointers in the same frame, which
+        /// will all then be processed by frame when <see cref="EventSystem.Update()"/> calls this method.
+        /// <para>
+        /// Also, this method is responsible for purging stale pointers when a device is removed, and for filtering
+        /// pointer states
+        /// </para>
+        /// </remarks>
+        /// <example>
+        /// <code>
+        /// using UnityEngine;
+        /// using UnityEngine.InputSystem.UI;
+        ///
+        /// public class CustomInputModuleProcessor : MonoBehaviour
+        /// {
+        ///     // Reference to the InputSystemUIInputModule, set in the Inspector
+        ///     public InputSystemUIInputModule uiModule;
+        ///
+        ///     void Update()
+        ///     {
+        ///         // Process the input module in the Update loop for a specific case
+        ///         // if this needs to be called outside the EventSystem.Update() event
+        ///         if (uiModule != null)
+        ///         {
+        ///             uiModule.Process();
+        ///         }
+        ///     }
+        /// }
+        /// </code>
+        /// </example>
+        /// <seealso cref="UIPointerType"/>
+        /// <seealso cref="UIPointerBehavior"/>
+        /// <seealso cref="BaseInputModule.Process"/>
+        /// <seealso cref="actionsAsset"/>
         public override void Process()
         {
             if (m_NeedToPurgeStalePointers)
@@ -2380,6 +2531,9 @@ private InputActionReference UpdateReferenceForNewAsset(InputActionReference act
             return InputActionReference.Create(newAction);
         }
 
+        /// <summary>
+        ///  The <see cref="InputActionAsset"/> that contains the necessary UI actions used by the UI module.
+        /// </summary>
         public InputActionAsset actionsAsset
         {
             get => m_ActionsAsset;
diff --git a/Packages/com.unity.inputsystem/InputSystem/Plugins/XInput/XInputController.cs b/Packages/com.unity.inputsystem/InputSystem/Plugins/XInput/XInputController.cs
index fcaa117956..870ae9a7d5 100644
--- a/Packages/com.unity.inputsystem/InputSystem/Plugins/XInput/XInputController.cs
+++ b/Packages/com.unity.inputsystem/InputSystem/Plugins/XInput/XInputController.cs
@@ -148,20 +148,156 @@ internal enum DeviceType
         /// Controller subtype enumeration in <c>SubType</c> field of <c>XINPUT_CAPABILITIES</c>.
         /// </summary>
         /// <remarks>
-        /// See <a href="https://docs.microsoft.com/en-us/windows/win32/xinput/xinput-and-controller-subtypes">MSDN</a>.
+        /// Provides additional detail about the underlying hardware being used and how it maps physical to logical
+        /// controls.
+        ///
+        /// See <a href="https://docs.microsoft.com/en-us/windows/win32/xinput/xinput-and-controller-subtypes">MSDN</a>
+        /// for additional details.
         /// </remarks>
         public enum DeviceSubType
         {
+            /// <summary>
+            /// The controller type is unknown.
+            /// </summary>
             Unknown = 0x00,
+
+            /// <summary>
+            /// Gamepad controller.
+            /// </summary>
+            /// <remarks>
+            /// Includes left and right stick as <see cref="Gamepad.leftStick" /> and <see cref="Gamepad.rightStick"/>,
+            /// left and right trigger as <see cref="Gamepad.leftTrigger"/> and <see cref="Gamepad.rightTrigger"/>,
+            /// directional pad as <see cref="Gamepad.dpad"/>,
+            /// and all standard buttons (<see cref="Gamepad.buttonSouth"/>, <see cref="Gamepad.buttonEast"/>,
+            /// <see cref="Gamepad.buttonWest"/>, <see cref="Gamepad.buttonNorth"/>,
+            /// <see cref="Gamepad.startButton"/>, <see cref="Gamepad.selectButton"/>,
+            /// <see cref="Gamepad.leftShoulder"/>, <see cref="Gamepad.rightShoulder"/>,
+            /// <see cref="Gamepad.leftStickButton"/>, <see cref="Gamepad.rightStickButton"/>).
+            /// </remarks>
             Gamepad = 0x01,
+
+            /// <summary>
+            /// Racing wheel controller.
+            /// </summary>
+            /// <remarks>
+            /// <see cref="UnityEngine.InputSystem.Gamepad.leftStick" /> x-axis reports the wheel rotation,
+            /// <see cref="Gamepad.rightTrigger"/> is the acceleration pedal, and
+            /// <see cref="Gamepad.leftTrigger"/>Left Trigger is the brake pedal.
+            /// Includes Directional Pad as <see cref="Gamepad.dpad"/> and most standard buttons
+            /// (<see cref="Gamepad.buttonSouth"/>, <see cref="Gamepad.buttonEast"/>,
+            /// <see cref="Gamepad.buttonWest"/>, <see cref="Gamepad.buttonNorth"/>,
+            /// <see cref="Gamepad.startButton"/>, <see cref="Gamepad.selectButton"/>,
+            /// <see cref="Gamepad.leftShoulder"/>, <see cref="Gamepad.rightShoulder"/>).
+            /// <see cref="Gamepad.leftStickButton"/> and <see cref="Gamepad.rightStickButton"/> are optional.
+            /// </remarks>
             Wheel = 0x02,
+
+            /// <summary>
+            /// Arcade stick controller.
+            /// </summary>
+            /// <remarks>
+            /// Includes a Digital Stick that reports as a <see cref="Gamepad.dpad"/> (up, down, left, right),
+            /// and most standard buttons (<see cref="Gamepad.buttonSouth"/>, <see cref="Gamepad.buttonEast"/>,
+            /// <see cref="Gamepad.buttonWest"/>, <see cref="Gamepad.buttonNorth"/>,
+            /// <see cref="Gamepad.startButton"/>, <see cref="Gamepad.selectButton"/>).
+            /// The <see cref="Gamepad.leftTrigger"/> and <see cref="Gamepad.rightTrigger"/> are implemented as digital
+            /// buttons and report either 0.0f or 1.0f.
+            /// The <see cref="Gamepad.leftShoulder"/>, <see cref="Gamepad.rightShoulder"/> and
+            /// <see cref="Gamepad.leftStickButton"/>, <see cref="Gamepad.rightStickButton"/> are optional.
+            /// </remarks>
             ArcadeStick = 0x03,
+
+            /// <summary>
+            /// Flight stick controller.
+            /// </summary>
+            /// <remarks>
+            /// Includes a pitch and roll stick that reports as the <see cref="Gamepad.leftStick"/>, a POV Hat which
+            /// reports as the <see cref="Gamepad.rightStick"/>, a rudder (handle twist or rocker) that reports as
+            /// <see cref="Gamepad.leftTrigger"/>, and a throttle control as the <see cref="Gamepad.rightTrigger"/>.
+            /// Includes support for a primary weapon (<see cref="Gamepad.buttonSouth"/>), secondary weapon
+            /// (<see cref="Gamepad.buttonEast"/>), and other standard buttons (<see cref="Gamepad.buttonWest"/>,
+            /// <see cref="Gamepad.buttonNorth"/>, <see cref="Gamepad.startButton"/>,
+            /// <see cref="Gamepad.selectButton"/>).
+            /// <see cref="Gamepad.leftShoulder"/>, <see cref="Gamepad.rightShoulder"/> and
+            /// <see cref="Gamepad.leftStickButton"/>, <see cref="Gamepad.rightStickButton"/> are optional.
+            /// </remarks>
             FlightStick = 0x04,
+
+            /// <summary>
+            /// Dance pad controller.
+            /// </summary>
+            /// <remarks>
+            /// Includes the <see cref="Gamepad.dpad"/> and standard buttons (<see cref="Gamepad.buttonSouth"/>,
+            /// <see cref="Gamepad.buttonEast"/>, <see cref="Gamepad.buttonWest"/>,
+            /// <see cref="Gamepad.buttonNorth"/>) on the pad, plus <see cref="Gamepad.startButton"/> and
+            /// <see cref="Gamepad.selectButton"/>.
+            /// </remarks>
             DancePad = 0x05,
+
+            /// <summary>
+            /// Guitar controller.
+            /// </summary>
+            /// <remarks>
+            /// The strum bar maps to <see cref="Gamepad.dpad"/> (up and down), and the frets are assigned to
+            /// <see cref="Gamepad.buttonSouth"/> (green), <see cref="Gamepad.buttonEast"/> (red),
+            /// <see cref="Gamepad.buttonNorth"/> (yellow), <see cref="Gamepad.buttonWest"/> (blue), and
+            /// <see cref="Gamepad.leftShoulder"/> (orange).
+            /// <see cref="Gamepad.rightStick"/> y-axis is associated with a vertical orientation sensor;
+            /// <see cref="Gamepad.rightStick"/> x-axis is the whammy bar.
+            /// Includes support for <see cref="Gamepad.selectButton"/>, <see cref="Gamepad.startButton"/>,
+            /// <see cref="Gamepad.dpad"/> (left, right).
+            /// <see cref="Gamepad.leftTrigger"/> (pickup selector), <see cref="Gamepad.rightTrigger"/>,
+            /// <see cref="Gamepad.rightShoulder"/>, <see cref="Gamepad.leftStickButton"/> (fret modifier),
+            /// <see cref="Gamepad.rightStickButton"/> are optional.
+            /// </remarks>
             Guitar = 0x06,
+
+            /// <summary>
+            /// Alternate guitar controller.
+            /// </summary>
+            /// <remarks>
+            /// Similar to <see cref="Guitar"/> but supports a larger range of movement for the vertical orientation
+            /// sensor.
+            /// </remarks>
             GuitarAlternate = 0x07,
+
+            /// <summary>
+            /// Drum kit controller.
+            /// </summary>
+            /// <remarks>
+            /// The drum pads are assigned to buttons: <see cref="Gamepad.buttonSouth"/> for green (Floor Tom),
+            /// <see cref="Gamepad.buttonEast"/> for red (Snare Drum),
+            /// <see cref="Gamepad.buttonWest"/> for blue (Low Tom),
+            /// <see cref="Gamepad.buttonNorth"/> for yellow (High Tom),
+            /// and <see cref="Gamepad.leftShoulder"/> for the pedal (Bass Drum).
+            /// Includes <see cref="Gamepad.dpad"/>, <see cref="Gamepad.selectButton"/>, and
+            /// <see cref="Gamepad.startButton"/>. <see cref="Gamepad.rightShoulder"/>,
+            /// <see cref="Gamepad.leftStickButton"/>, and <see cref="Gamepad.rightStickButton"/> are optional.
+            /// </remarks>
             DrumKit = 0x08,
+
+            /// <summary>
+            /// Bass guitar controller.
+            /// </summary>
+            /// <remarks>
+            /// Identical to <see cref="Guitar" />, with the distinct subtype to simplify setup.
+            /// </remarks>
             GuitarBass = 0x0B,
+
+            /// <summary>
+            /// Arcade pad controller.
+            /// </summary>
+            /// <remarks>
+            /// Includes Directional Pad and most standard buttons
+            /// (<see cref="Gamepad.buttonSouth"/>, <see cref="Gamepad.buttonEast"/>,
+            /// <see cref="Gamepad.buttonWest"/>, <see cref="Gamepad.buttonNorth"/>,
+            /// <see cref="Gamepad.startButton"/>, <see cref="Gamepad.selectButton"/>,
+            /// <see cref="Gamepad.leftShoulder"/>, <see cref="Gamepad.rightShoulder"/>).
+            /// The <see cref="Gamepad.leftTrigger"/>, <see cref="Gamepad.rightTrigger"/> are implemented as digital
+            /// buttons and report either 0.0f or 1.0f.
+            /// <see cref="Gamepad.leftStick"/>, <see cref="Gamepad.rightStick"/>,
+            /// <see cref="Gamepad.leftStickButton"/> and <see cref="Gamepad.rightStickButton"/> are optional.
+            /// </remarks>
             ArcadePad = 0x13
         }
 
diff --git a/Packages/com.unity.inputsystem/InputSystem/State/InputStateHistory.cs b/Packages/com.unity.inputsystem/InputSystem/State/InputStateHistory.cs
index e98443475f..1cd3f4a620 100644
--- a/Packages/com.unity.inputsystem/InputSystem/State/InputStateHistory.cs
+++ b/Packages/com.unity.inputsystem/InputSystem/State/InputStateHistory.cs
@@ -29,7 +29,7 @@ namespace UnityEngine.InputSystem.LowLevel
     ///
     /// The class listens to changes on the given controls by adding change monitors (<see cref="IInputStateChangeMonitor"/>)
     /// to each control.
-    ///
+    /// </remarks>
     /// <example>
     /// <code>
     /// // Track all stick controls in the system.
@@ -54,7 +54,7 @@ namespace UnityEngine.InputSystem.LowLevel
     /// history.Dispose();
     /// </code>
     /// </example>
-    /// </remarks>
+    /// <seealso cref="Record"/>
     public class InputStateHistory : IDisposable, IEnumerable<InputStateHistory.Record>, IInputStateChangeMonitor
     {
         private const int kDefaultHistorySize = 128;
@@ -62,30 +62,34 @@ public class InputStateHistory : IDisposable, IEnumerable<InputStateHistory.Reco
         /// <summary>
         /// Total number of state records currently captured in the history.
         /// </summary>
-        /// <value>Number of records in the collection.</value>
         /// <remarks>
+        /// Number of records in the collection.
+        ///
         /// This will always be at most <see cref="historyDepth"/>.
+        /// To record a change use <see cref="RecordStateChange(InputControl,InputEventPtr)"/>.
         /// </remarks>
-        /// <seealso cref="historyDepth"/>
-        /// <seealso cref="RecordStateChange(InputControl,InputEventPtr)"/>
         public int Count => m_RecordCount;
 
         /// <summary>
         /// Current version stamp. Every time a record is stored in the history,
         /// this is incremented by one.
         /// </summary>
-        /// <value>Version stamp that indicates the number of mutations.</value>
-        /// <seealso cref="RecordStateChange(InputControl,InputEventPtr)"/>
+        /// <remarks>
+        /// Version stamp that indicates the number of mutations.
+        /// To record a change use <see cref="RecordStateChange(InputControl,InputEventPtr)"/>.
+        /// </remarks>
         public uint version => m_CurrentVersion;
 
         /// <summary>
         /// Maximum number of records that can be recorded in the history.
         /// </summary>
-        /// <value>Upper limit on number of records.</value>
         /// <exception cref="ArgumentException"><paramref name="value"/> is negative.</exception>
         /// <remarks>
+        /// Upper limit on number of records.
         /// A fixed size memory block of unmanaged memory will be allocated to store history
-        /// records. This property determines TODO
+        /// records.
+        /// When the history is full, it will start overwriting the oldest
+        /// entry each time a new history record is received.
         /// </remarks>
         public int historyDepth
         {
@@ -100,6 +104,15 @@ public int historyDepth
             }
         }
 
+        /// <summary>
+        /// Size of additional data storage to allocate per record.
+        /// </summary>
+        /// <exception cref="ArgumentException"><paramref name="value"/> is negative.</exception>
+        /// <remarks>
+        /// Additional custom data can be stored per record up to the size of this value.
+        /// To retrieve a pointer to this memory use <see cref="Record.GetUnsafeExtraMemoryPtr"/>
+        /// Used by <see cref="EnhancedTouch.Touch.history"/>
+        /// </remarks>
         public int extraMemoryPerRecord
         {
             get => m_ExtraMemoryPerRecord;
@@ -113,6 +126,14 @@ public int extraMemoryPerRecord
             }
         }
 
+        /// <summary>
+        /// Specify which player loop positions the state history will be monitored for.
+        /// </summary>
+        /// <exception cref="ArgumentException"><paramref name="value"/>When an invalid mask is provided (e.g. <see cref="InputUpdateType.None"/>).</exception>
+        /// <remarks>
+        /// The state history will only be monitored for the specified player loop positions.
+        /// <see cref="InputUpdateType.Editor"/> is excluded from this list
+        /// </remarks>
         public InputUpdateType updateMask
         {
             get => m_UpdateMask ?? InputSystem.s_Manager.updateMask & ~InputUpdateType.Editor;
@@ -124,8 +145,22 @@ public InputUpdateType updateMask
             }
         }
 
+        /// <summary>
+        /// List of input controls the state history will be recording for.
+        /// </summary>
+        /// <remarks>
+        /// The list of input controls the state history will be recording for is specified on construction of the <see cref="InputStateHistory"/>
+        /// </remarks>
         public ReadOnlyArray<InputControl> controls => new ReadOnlyArray<InputControl>(m_Controls, 0, m_ControlCount);
 
+        /// <summary>
+        /// Returns an entry in the state history at the given index.
+        /// </summary>
+        /// <param name="index">Index into the array.</param>
+        /// <remarks>
+        /// Returns a <see cref="Record"/> entry from the state history at the given index.
+        /// </remarks>
+        /// <exception cref="IndexOutOfRangeException"><paramref name="index"/> is less than 0 or greater than <see cref="Count"/>.</exception>
         public unsafe Record this[int index]
         {
             get
@@ -148,9 +183,34 @@ public unsafe Record this[int index]
             }
         }
 
+        /// <summary>
+        /// Optional delegate to perform when a record is added to the history array.
+        /// </summary>
+        /// <remarks>
+        /// Can be used to fill in the extra memory with custom data using <see cref="Record.GetUnsafeExtraMemoryPtr"/>
+        /// </remarks>
         public Action<Record> onRecordAdded { get; set; }
+
+        /// <summary>
+        /// Optional delegate to decide whether the state change should be stored in the history.
+        /// </summary>
+        /// <remarks>
+        /// Can be used to filter out some events to focus on recording the ones you are most interested in.
+        ///
+        /// If the callback returns <c>true</c>, a record will be added to the history
+        /// If the callback returns <c>false</c>, the event will be ignored and not recorded.
+        /// </remarks>
         public Func<InputControl, double, InputEventPtr, bool> onShouldRecordStateChange { get; set; }
 
+        /// <summary>
+        /// Creates a new InputStateHistory class to record all control state changes.
+        /// </summary>
+        /// <param name="maxStateSizeInBytes">Maximum size of control state in the record entries. Controls with larger state will not be recorded.</param>
+        /// <remarks>
+        /// Creates a new InputStateHistory to record a history of control state changes.
+        ///
+        /// New controls are automatically added into the state history if their state is smaller than the threshold.
+        /// </remarks>
         public InputStateHistory(int maxStateSizeInBytes)
         {
             if (maxStateSizeInBytes <= 0)
@@ -160,6 +220,19 @@ public InputStateHistory(int maxStateSizeInBytes)
             m_StateSizeInBytes = maxStateSizeInBytes.AlignToMultipleOf(4);
         }
 
+        /// <summary>
+        /// Creates a new InputStateHistory class to record state changes for a specified control.
+        /// </summary>
+        /// <param name="path">Control path to identify which controls to monitor.</param>
+        /// <remarks>
+        /// Creates a new InputStateHistory to record a history of state changes for the specified controls.
+        /// </remarks>
+        /// <example>
+        /// <code>
+        /// // Track all stick controls in the system.
+        /// var history = new InputStateHistory("*/&lt;Stick&gt;");
+        /// </code>
+        /// </example>
         public InputStateHistory(string path)
         {
             using (var controls = InputSystem.FindControls(path))
@@ -169,6 +242,13 @@ public InputStateHistory(string path)
             }
         }
 
+        /// <summary>
+        /// Creates a new InputStateHistory class to record state changes for a specified control.
+        /// </summary>
+        /// <param name="control">Control to monitor.</param>
+        /// <remarks>
+        /// Creates a new InputStateHistory to record a history of state changes for the specified control.
+        /// </remarks>
         public InputStateHistory(InputControl control)
         {
             if (control == null)
@@ -178,6 +258,13 @@ public InputStateHistory(InputControl control)
             m_ControlCount = 1;
         }
 
+        /// <summary>
+        /// Creates a new InputStateHistory class to record state changes for a specified controls.
+        /// </summary>
+        /// <param name="controls">Controls to monitor.</param>
+        /// <remarks>
+        /// Creates a new InputStateHistory to record a history of state changes for the specified controls.
+        /// </remarks>
         public InputStateHistory(IEnumerable<InputControl> controls)
         {
             if (controls != null)
@@ -187,11 +274,22 @@ public InputStateHistory(IEnumerable<InputControl> controls)
             }
         }
 
+        /// <summary>
+        /// InputStateHistory destructor.
+        /// </summary>
         ~InputStateHistory()
         {
             Dispose();
         }
 
+        /// <summary>
+        /// Clear the history record.
+        /// </summary>
+        /// <remarks>
+        /// Clear the history record. Resetting the list to empty.
+        ///
+        /// This won't clear controls that have been added on the fly.
+        /// </remarks>
         public void Clear()
         {
             m_HeadIndex = 0;
@@ -201,6 +299,15 @@ public void Clear()
             // NOTE: Won't clear controls that have been added on the fly.
         }
 
+        /// <summary>
+        /// Add a record to the input state history.
+        /// </summary>
+        /// <param name="record">Record to add.</param>
+        /// <returns>The newly added record from the history array (as a copy is made).</returns>
+        /// <remarks>
+        /// Add a record to the input state history.
+        /// Allocates an entry in the history array and returns this copy of the original data passed to the function.
+        /// </remarks>
         public unsafe Record AddRecord(Record record)
         {
             var recordPtr = AllocateRecord(out var index);
@@ -209,6 +316,21 @@ public unsafe Record AddRecord(Record record)
             return newRecord;
         }
 
+        /// <summary>
+        /// Start recording state history for the specified controls.
+        /// </summary>
+        /// <remarks>
+        /// Start recording state history for the controls specified in the <see cref="InputStateHistory"/> constructor.
+        /// </remarks>
+        /// <example>
+        /// <code>
+        /// using (var allTouchTaps = new InputStateHistory("&lt;Touchscreen&gt;/touch*/tap"))
+        /// {
+        ///     allTouchTaps.StartRecording();
+        ///     allTouchTaps.StopRecording();
+        /// }
+        /// </code>
+        /// </example>
         public void StartRecording()
         {
             // We defer allocation until we actually get values on a control.
@@ -217,12 +339,38 @@ public void StartRecording()
                 InputState.AddChangeMonitor(control, this);
         }
 
+        /// <summary>
+        /// Stop recording state history for the specified controls.
+        /// </summary>
+        /// <remarks>
+        /// Stop recording state history for the controls specified in the <see cref="InputStateHistory"/> constructor.
+        /// </remarks>
+        /// <example>
+        /// <code>
+        /// using (var allTouchTaps = new InputStateHistory("&lt;Touchscreen&gt;/touch*/tap"))
+        /// {
+        ///     allTouchTaps.StartRecording();
+        ///     allTouchTaps.StopRecording();
+        /// }
+        /// </code>
+        /// </example>
         public void StopRecording()
         {
             foreach (var control in controls)
                 InputState.RemoveChangeMonitor(control, this);
         }
 
+        /// <summary>
+        /// Record a state change for a specific control.
+        /// </summary>
+        /// <param name="control">The control to record the state change for.</param>
+        /// <param name="eventPtr">The current event data to record.</param>
+        /// <returns>The newly added record.</returns>
+        /// <remarks>
+        /// Record a state change for a specific control.
+        /// Will call the <see cref="onRecordAdded"/> delegate after adding the record.
+        /// Note this does not call the <see cref="onShouldRecordStateChange"/> delegate.
+        /// </remarks>
         public unsafe Record RecordStateChange(InputControl control, InputEventPtr eventPtr)
         {
             if (eventPtr.IsA<DeltaStateEvent>())
@@ -236,6 +384,18 @@ public unsafe Record RecordStateChange(InputControl control, InputEventPtr event
             return RecordStateChange(control, statePtr, eventPtr.time);
         }
 
+        /// <summary>
+        /// Record a state change for a specific control.
+        /// </summary>
+        /// <param name="control">The control to record the state change for.</param>
+        /// <param name="statePtr">The current state data to record.</param>
+        /// <param name="time">Time stamp to apply (overriding the event timestamp)</param>
+        /// <returns>The newly added record.</returns>
+        /// <remarks>
+        /// Record a state change for a specific control.
+        /// Will call the <see cref="onRecordAdded"/> delegate after adding the record.
+        /// Note this does not call the <see cref="onShouldRecordStateChange"/> delegate.
+        /// </remarks>
         public unsafe Record RecordStateChange(InputControl control, void* statePtr, double time)
         {
             var controlIndex = ArrayHelpers.IndexOfReference(m_Controls, control, m_ControlCount);
@@ -277,16 +437,37 @@ public unsafe Record RecordStateChange(InputControl control, void* statePtr, dou
             return record;
         }
 
+        /// <summary>
+        /// Enumerate all state history records.
+        /// </summary>
+        /// <returns>An enumerator going over the state history records.</returns>
+        /// <remarks>
+        /// Enumerate all state history records.
+        /// </remarks>
+        /// <seealso cref="GetEnumerator"/>
         public IEnumerator<Record> GetEnumerator()
         {
             return new Enumerator(this);
         }
 
+        /// <summary>
+        /// Enumerate all state history records.
+        /// </summary>
+        /// <returns>An enumerator going over the state history records.</returns>
+        /// <remarks>
+        /// Enumerate all state history records.
+        /// </remarks>
         IEnumerator IEnumerable.GetEnumerator()
         {
             return GetEnumerator();
         }
 
+        /// <summary>
+        /// Dispose of the state history records.
+        /// </summary>
+        /// <remarks>
+        /// Stops recording and cleans up the state history
+        /// </remarks>
         public void Dispose()
         {
             StopRecording();
@@ -294,6 +475,12 @@ public void Dispose()
             GC.SuppressFinalize(this);
         }
 
+        /// <summary>
+        /// Destroy the state history records.
+        /// </summary>
+        /// <remarks>
+        /// Deletes the state history records.
+        /// </remarks>
         protected void Destroy()
         {
             if (m_RecordBuffer.IsCreated)
@@ -325,6 +512,15 @@ private void Allocate()
                 NativeArrayOptions.UninitializedMemory);
         }
 
+        /// <summary>
+        /// Remap a records internal index to an index from the start of the recording in the circular buffer.
+        /// </summary>
+        /// <remarks>
+        /// Remap a records internal index, which is relative to the start of the record buffer,
+        /// to an index relative to the start of the recording in the circular buffer.
+        /// </remarks>
+        /// <param name="index">Record index (from the start of the record array).</param>
+        /// <returns>An index relative to the start of the recording in the circular buffer.</returns>
         protected internal int RecordIndexToUserIndex(int index)
         {
             if (index < m_HeadIndex)
@@ -332,11 +528,30 @@ protected internal int RecordIndexToUserIndex(int index)
             return index - m_HeadIndex;
         }
 
+        /// <summary>
+        /// Remap an index from the start of the recording in the circular buffer to a records internal index.
+        /// </summary>
+        /// <remarks>
+        /// Remap an index relative to the start of the recording in the circular buffer,
+        /// to a records internal index, which is relative to the start of the record buffer.
+        /// </remarks>
+        /// <param name="index">An index relative to the start of the recording in the circular buffer.</param>
+        /// <returns>Record index (from the start of the record array).</returns>
         protected internal int UserIndexToRecordIndex(int index)
         {
             return (m_HeadIndex + index) % m_HistoryDepth;
         }
 
+        /// <summary>
+        /// Retrieve a record from the input state history.
+        /// </summary>
+        /// <remarks>
+        /// Retrieve a record from the input state history by Record index.
+        /// </remarks>
+        /// <param name="index">Record index into the input state history records buffer.</param>
+        /// <returns>The record header for the specified index</returns>
+        /// <exception cref="InvalidOperationException">When the buffer is no longer valid as it has been disposed.</exception>
+        /// <exception cref="ArgumentOutOfRangeException">If the index is out of range of the history depth.</exception>
         protected internal unsafe RecordHeader* GetRecord(int index)
         {
             if (!m_RecordBuffer.IsCreated)
@@ -346,11 +561,27 @@ protected internal int UserIndexToRecordIndex(int index)
             return GetRecordUnchecked(index);
         }
 
+        /// <summary>
+        /// Retrieve a record from the input state history, without any bounds check.
+        /// </summary>
+        /// <remarks>
+        /// Retrieve a record from the input state history by record index, without any bounds check
+        /// </remarks>
+        /// <param name="index">Record index into the input state history records buffer.</param>
+        /// <returns>The record header for the specified index</returns>
         internal unsafe RecordHeader* GetRecordUnchecked(int index)
         {
             return (RecordHeader*)((byte*)m_RecordBuffer.GetUnsafePtr() + index * bytesPerRecord);
         }
 
+        /// <summary>
+        /// Allocate a new record in the input state history.
+        /// </summary>
+        /// <remarks>
+        /// Allocate a new record in the input state history.
+        /// </remarks>
+        /// <param name="index">The index of the newly created record</param>
+        /// <returns>The header of the newly created record</returns>
         protected internal unsafe RecordHeader* AllocateRecord(out int index)
         {
             if (!m_RecordBuffer.IsCreated)
@@ -371,6 +602,13 @@ protected internal int UserIndexToRecordIndex(int index)
             return (RecordHeader*)((byte*)m_RecordBuffer.GetUnsafePtr() + bytesPerRecord * index);
         }
 
+        /// <summary>
+        /// Returns value from the control in the specified record header.
+        /// </summary>
+        /// <param name="data">The record header to query.</param>
+        /// <typeparam name="TValue">The type of the value being read</typeparam>
+        /// <returns>The value from the record.</returns>
+        /// <exception cref="InvalidOperationException">When the record is no longer value or the specified type is not present.</exception>
         protected unsafe TValue ReadValue<TValue>(RecordHeader* data)
             where TValue : struct
         {
@@ -387,6 +625,15 @@ protected unsafe TValue ReadValue<TValue>(RecordHeader* data)
             return controlOfType.ReadValueFromState(statePtr);
         }
 
+        /// <summary>
+        /// Read the control's final, processed value from the given state and return the value as an object.
+        /// </summary>
+        /// <param name="data">The record header to query.</param>
+        /// <returns>The value of the control associated with the record header.</returns>
+        /// <remarks>
+        /// This method allocates GC memory and should not be used during normal gameplay operation.
+        /// </remarks>
+        /// <exception cref="InvalidOperationException">When the specified value is not present.</exception>
         protected unsafe object ReadValueAsObject(RecordHeader* data)
         {
             // Get control. If we only have a single one, the index isn't stored on the data.
@@ -399,6 +646,18 @@ protected unsafe object ReadValueAsObject(RecordHeader* data)
             return control.ReadValueFromStateAsObject(statePtr);
         }
 
+        /// <summary>
+        /// Delegate to list to control state change notifications.
+        /// </summary>
+        /// <param name="control">Control that is being monitored by the state change monitor and that had its state memory changed.</param>
+        /// <param name="time">Time on the <see cref="InputEvent.time"/> timeline at which the control state change was received.</param>
+        /// <param name="eventPtr">If the state change was initiated by a state event (either a <see cref="StateEvent"/>
+        /// or <see cref="DeltaStateEvent"/>), this is the pointer to that event. Otherwise, it is pointer that is still
+        /// <see cref="InputEventPtr.valid"/>, but refers a "dummy" event that is not a <see cref="StateEvent"/> or <see cref="DeltaStateEvent"/>.</param>
+        /// <param name="monitorIndex">Index of the monitor as passed to <see cref="InputState.AddChangeMonitor(InputControl,IInputStateChangeMonitor,long,uint)"/></param>
+        /// <remarks>
+        /// Records a state change after checking the <see cref="updateMask"/> and the <see cref="onShouldRecordStateChange"/> callback.
+        /// </remarks>
         unsafe void IInputStateChangeMonitor.NotifyControlStateChanged(InputControl control, double time,
             InputEventPtr eventPtr, long monitorIndex)
         {
@@ -416,6 +675,15 @@ unsafe void IInputStateChangeMonitor.NotifyControlStateChanged(InputControl cont
         }
 
         // Unused.
+        /// <summary>
+        /// Called when a timeout set on a state change monitor has expired.
+        /// </summary>
+        /// <param name="control">Control on which the timeout expired.</param>
+        /// <param name="time">Input time at which the timer expired. This is the time at which an <see cref="InputSystem.Update"/> is being
+        /// run whose <see cref="InputState.currentTime"/> is past the time of expiration.</param>
+        /// <param name="monitorIndex">Index of the monitor as given to <see cref="InputState.AddChangeMonitor(InputControl,IInputStateChangeMonitor,long,uint)"/>.</param>
+        /// <param name="timerIndex">Index of the timer as given to <see cref="InputState.AddChangeMonitorTimeout"/>.</param>
+        /// <seealso cref="InputState.AddChangeMonitorTimeout"/>
         void IInputStateChangeMonitor.NotifyTimerExpired(InputControl control, double time, long monitorIndex,
             int timerIndex)
         {
@@ -473,16 +741,50 @@ public void Dispose()
             }
         }
 
+        /// <summary>State change record header</summary>
+        /// <remarks>
+        /// Input State change record header containing the timestamp and other common record data.
+        /// Stored in the <see cref="InputStateHistory"/>.
+        /// </remarks>
+        /// <seealso cref="InputStateHistory"/>
         [StructLayout(LayoutKind.Explicit)]
         protected internal unsafe struct RecordHeader
         {
+            /// <summary>
+            /// The time stamp of the input state record.
+            /// </summary>
+            /// <remarks>
+            /// The time stamp of the input state record in the owning container.
+            /// <see cref="IInputRuntime.currentTime"/>
+            /// </remarks>
             [FieldOffset(0)] public double time;
+
+            /// <summary>
+            /// The version of the input state record.
+            /// </summary>
+            /// <remarks>
+            /// Current version stamp. See <see cref="InputStateHistory.version"/>.
+            /// </remarks>
             [FieldOffset(8)] public uint version;
+
+            /// <summary>
+            /// The index of the record.
+            /// </summary>
+            /// <remarks>
+            /// The index of the record relative to the start of the buffer.
+            /// See <see cref="InputStateHistory.RecordIndexToUserIndex"/> to remap this record index to a user index.
+            /// </remarks>
             [FieldOffset(12)] public int controlIndex;
 
             [FieldOffset(12)] private fixed byte m_StateWithoutControlIndex[1];
             [FieldOffset(16)] private fixed byte m_StateWithControlIndex[1];
 
+            /// <summary>
+            /// The state data including the control index.
+            /// </summary>
+            /// <remarks>
+            /// The state data including the control index.
+            /// </remarks>
             public byte* statePtrWithControlIndex
             {
                 get
@@ -492,6 +794,12 @@ public byte* statePtrWithControlIndex
                 }
             }
 
+            /// <summary>
+            /// The state data excluding the control index.
+            /// </summary>
+            /// <remarks>
+            /// The state data excluding the control index.
+            /// </remarks>
             public byte* statePtrWithoutControlIndex
             {
                 get
@@ -501,10 +809,26 @@ public byte* statePtrWithoutControlIndex
                 }
             }
 
+            /// <summary>
+            /// Size of the state data including the control index.
+            /// </summary>
+            /// <remarks>
+            /// Size of the data including the control index.
+            /// </remarks>
             public const int kSizeWithControlIndex = 16;
+
+            /// <summary>
+            /// Size of the state data excluding the control index.
+            /// </summary>
+            /// <remarks>
+            /// Size of the data excluding the control index.
+            /// </remarks>
             public const int kSizeWithoutControlIndex = 12;
         }
 
+        /// <summary>State change record</summary>
+        /// <remarks>Input State change record stored in the <see cref="InputStateHistory"/>.</remarks>
+        /// <seealso cref="InputStateHistory"/>
         public unsafe struct Record : IEquatable<Record>
         {
             // We store an index rather than a direct pointer to make this struct safer to use.
@@ -516,10 +840,31 @@ public unsafe struct Record : IEquatable<Record>
             internal int recordIndex => m_IndexPlusOne - 1;
             internal uint version => m_Version;
 
+            /// <summary>
+            /// Identifies if the record is valid.
+            /// </summary>
+            /// <value>True if the record is a valid entry. False if invalid.</value>
+            /// <remarks>
+            /// When the history is cleared with <see cref="Clear"/> the entries become invalid.
+            /// </remarks>
             public bool valid => m_Owner != default && m_IndexPlusOne != default && header->version == m_Version;
 
+            /// <summary>
+            /// Identifies the owning container for the record.
+            /// </summary>
+            /// <value>The owning <see cref="InputStateHistory"/> container for the record.</value>
+            /// <remarks>
+            /// Identifies the owning <see cref="InputStateHistory"/> container for the record.
+            /// </remarks>
             public InputStateHistory owner => m_Owner;
 
+            /// <summary>
+            /// The index of the input state record in the owning container.
+            /// </summary>
+            /// <value>
+            /// The index of the input state record in the owning container.
+            /// </value>
+            /// <exception cref="InvalidOperationException">When the record is no longer value.</exception>
             public int index
             {
                 get
@@ -529,6 +874,14 @@ public int index
                 }
             }
 
+            /// <summary>
+            /// The time stamp of the input state record.
+            /// </summary>
+            /// <value>
+            /// The time stamp of the input state record in the owning container.
+            /// <see cref="IInputRuntime.currentTime"/>
+            /// </value>
+            /// <exception cref="InvalidOperationException">When the record is no longer value.</exception>
             public double time
             {
                 get
@@ -538,6 +891,13 @@ public double time
                 }
             }
 
+            /// <summary>
+            /// The control associated with the input state record.
+            /// </summary>
+            /// <value>
+            /// The control associated with the input state record.
+            /// </value>
+            /// <exception cref="InvalidOperationException">When the record is no longer value.</exception>
             public InputControl control
             {
                 get
@@ -550,6 +910,13 @@ public InputControl control
                 }
             }
 
+            /// <summary>
+            /// The next input state record in the owning container.
+            /// </summary>
+            /// <value>
+            /// The next input state record in the owning <see cref="InputStateHistory"/>container.
+            /// </value>
+            /// <exception cref="InvalidOperationException">When the record is no longer value.</exception>
             public Record next
             {
                 get
@@ -563,6 +930,13 @@ public Record next
                 }
             }
 
+            /// <summary>
+            /// The previous input state record in the owning container.
+            /// </summary>
+            /// <value>
+            /// The previous input state record in the owning <see cref="InputStateHistory"/>container.
+            /// </value>
+            /// <exception cref="InvalidOperationException">When the record is no longer value.</exception>
             public Record previous
             {
                 get
@@ -583,6 +957,12 @@ internal Record(InputStateHistory owner, int index, RecordHeader* header)
                 m_Version = header->version;
             }
 
+            /// <summary>
+            /// Returns value from the control in the record.
+            /// </summary>
+            /// <typeparam name="TValue">The type of the value being read</typeparam>
+            /// <returns>Returns the value from the record.</returns>
+            /// <exception cref="InvalidOperationException">When the record is no longer value or the specified type is not present.</exception>
             public TValue ReadValue<TValue>()
                 where TValue : struct
             {
@@ -590,12 +970,27 @@ public TValue ReadValue<TValue>()
                 return m_Owner.ReadValue<TValue>(header);
             }
 
+            /// <summary>
+            /// Read the control's final, processed value from the given state and return the value as an object.
+            /// </summary>
+            /// <returns>The value of the control associated with the record.</returns>
+            /// <remarks>
+            /// This method allocates GC memory and should not be used during normal gameplay operation.
+            /// </remarks>
+            /// <exception cref="InvalidOperationException">When the specified value is not present.</exception>
             public object ReadValueAsObject()
             {
                 CheckValid();
                 return m_Owner.ReadValueAsObject(header);
             }
 
+            /// <summary>
+            /// Read the state memory for the record.
+            /// </summary>
+            /// <returns>The state memory for the record.</returns>
+            /// <remarks>
+            /// Read the state memory for the record.
+            /// </remarks>
             public void* GetUnsafeMemoryPtr()
             {
                 CheckValid();
@@ -609,6 +1004,14 @@ public object ReadValueAsObject()
                 return header->statePtrWithControlIndex;
             }
 
+            /// <summary>
+            /// Read the extra memory for the record.
+            /// </summary>
+            /// <returns>The extra memory for the record.</returns>
+            /// <remarks>
+            /// Additional date can be stored in a record in the extra memory section.
+            /// </remarks>
+            /// <seealso cref="InputStateHistory.extraMemoryPerRecord"/>
             public void* GetUnsafeExtraMemoryPtr()
             {
                 CheckValid();
@@ -622,6 +1025,13 @@ public object ReadValueAsObject()
                 return (byte*)header + m_Owner.bytesPerRecord - m_Owner.extraMemoryPerRecord;
             }
 
+            /// <summary>Copy data from one record to another.</summary>
+            /// <param name="record">Source record to copy from.</param>
+            /// <remarks>
+            /// Copy data from one record to another.
+            /// </remarks>
+            /// <exception cref="ArgumentException">When the source record history is not valid.</exception>
+            /// <exception cref="InvalidOperationException">When the control is not tracked by the owning <see cref="InputStateHistory"/> container.</exception>
             public void CopyFrom(Record record)
             {
                 if (!record.valid)
@@ -686,16 +1096,27 @@ internal void CheckValid()
                     throw new InvalidOperationException("Record is no longer valid");
             }
 
+            /// <summary>Compare two records.</summary>
+            /// <remarks>Compare two records.</remarks>
+            /// <param name="other">The record to compare with.</param>
+            /// <returns>True if the records are the same, False if they differ.</returns>
             public bool Equals(Record other)
             {
                 return ReferenceEquals(m_Owner, other.m_Owner) && m_IndexPlusOne == other.m_IndexPlusOne && m_Version == other.m_Version;
             }
 
+            /// <summary>Compare two records.</summary>
+            /// <remarks>Compare two records.</remarks>
+            /// <param name="obj">The record to compare with.</param>
+            /// <returns>True if the records are the same, False if they differ.</returns>
             public override bool Equals(object obj)
             {
                 return obj is Record other && Equals(other);
             }
 
+            /// <summary>Return the hash code of the record.</summary>
+            /// <remarks>Return the hash code of the record.</remarks>
+            /// <returns>The hash code of the record.</returns>
             public override int GetHashCode()
             {
                 unchecked
@@ -707,6 +1128,9 @@ public override int GetHashCode()
                 }
             }
 
+            /// <summary>Return the string representation of the record.</summary>
+            /// <remarks>Includes the control, value and time of the record (or &lt;Invalid&gt; if not valid).</remarks>
+            /// <returns>The string representation of the record.</returns>
             public override string ToString()
             {
                 if (!valid)
@@ -720,10 +1144,27 @@ public override string ToString()
     /// <summary>
     /// Records value changes of a given control over time.
     /// </summary>
-    /// <typeparam name="TValue"></typeparam>
+    /// <typeparam name="TValue">The type of the record being stored</typeparam>
+    /// <remarks>
+    /// This class makes it easy to track input values over time. It will automatically retain input state up to a given
+    /// maximum history depth (<see cref="InputStateHistory.historyDepth"/>). When the history is full, it will start overwriting the oldest
+    /// entry each time a new history record is received.
+    ///
+    /// The class listens to changes on the given controls by adding change monitors (<see cref="IInputStateChangeMonitor"/>)
+    /// to each control.
+    /// </remarks>
     public class InputStateHistory<TValue> : InputStateHistory, IReadOnlyList<InputStateHistory<TValue>.Record>
         where TValue : struct
     {
+        /// <summary>
+        /// Creates a new InputStateHistory class to record all control state changes.
+        /// </summary>
+        /// <param name="maxStateSizeInBytes">Maximum size of control state in the record entries. Controls with larger state will not be recorded.</param>
+        /// <remarks>
+        /// Creates a new InputStateHistory to record a history of control state changes.
+        ///
+        /// New controls are automatically added into the state history if there state is smaller than the threshold.
+        /// </remarks>
         public InputStateHistory(int? maxStateSizeInBytes = null)
         // Using the size of the value here isn't quite correct but the value is used as an upper
         // bound on stored state size for which the size of the value should be a reasonable guess.
@@ -733,11 +1174,31 @@ public InputStateHistory(int? maxStateSizeInBytes = null)
                 throw new ArgumentException("Max state size cannot be smaller than sizeof(TValue)", nameof(maxStateSizeInBytes));
         }
 
+        /// <summary>
+        /// Creates a new InputStateHistory class to record state changes for a specified control.
+        /// </summary>
+        /// <param name="control">Control to monitor.</param>
+        /// <remarks>
+        /// Creates a new InputStateHistory to record a history of state changes for the specified control.
+        /// </remarks>
         public InputStateHistory(InputControl<TValue> control)
             : base(control)
         {
         }
 
+        /// <summary>
+        /// Creates a new InputStateHistory class to record state changes for a specified control.
+        /// </summary>
+        /// <param name="path">Control path to identify which controls to monitor.</param>
+        /// <remarks>
+        /// Creates a new InputStateHistory to record a history of state changes for the specified controls.
+        /// </remarks>
+        /// <example>
+        /// <code>
+        /// // Track all stick controls in the system.
+        /// var history = new InputStateHistory&lt;Vector2&gt;("*/&lt;Stick&gt;");
+        /// </code>
+        /// </example>
         public InputStateHistory(string path)
             : base(path)
         {
@@ -748,11 +1209,23 @@ public InputStateHistory(string path)
                         $"Control '{control}' matched by '{path}' has value type '{TypeHelpers.GetNiceTypeName(control.valueType)}' which is incompatible with '{TypeHelpers.GetNiceTypeName(typeof(TValue))}'");
         }
 
+        /// <summary>
+        /// InputStateHistory destructor.
+        /// </summary>
         ~InputStateHistory()
         {
             Destroy();
         }
 
+        /// <summary>
+        /// Add a record to the input state history.
+        /// </summary>
+        /// <param name="record">Record to add.</param>
+        /// <returns>The newly added record from the history array (as a copy is made).</returns>
+        /// <remarks>
+        /// Add a record to the input state history.
+        /// Allocates an entry in the history array and returns this copy of the original data passed to the function.
+        /// </remarks>
         public unsafe Record AddRecord(Record record)
         {
             var recordPtr = AllocateRecord(out var index);
@@ -761,6 +1234,26 @@ public unsafe Record AddRecord(Record record)
             return newRecord;
         }
 
+        /// <summary>
+        /// Record a state change for a specific control.
+        /// </summary>
+        /// <param name="control">The control to record the state change for.</param>
+        /// <param name="value">The value to record.</param>
+        /// <param name="time">Time stamp to apply (overriding the event timestamp)</param>
+        /// <returns>The newly added record.</returns>
+        /// <remarks>
+        /// Record a state change for a specific control.
+        /// Will call the <see cref="InputStateHistory.onRecordAdded"/> delegate after adding the record.
+        /// Note this does not call the <see cref="InputStateHistory.onShouldRecordStateChange"/> delegate.
+        /// </remarks>
+        /// <example>
+        /// <code>
+        /// using (var allTouchTaps = new InputStateHistory&lt;float&gt;(Gamepad.current.leftTrigger))
+        /// {
+        ///     history.RecordStateChange(Gamepad.current.leftTrigger, 0.234f);
+        /// }
+        /// </code>
+        /// </example>
         public unsafe Record RecordStateChange(InputControl<TValue> control, TValue value, double time = -1)
         {
             using (StateEvent.From(control.device, out var eventPtr))
@@ -774,16 +1267,39 @@ public unsafe Record RecordStateChange(InputControl<TValue> control, TValue valu
             }
         }
 
+        /// <summary>
+        /// Enumerate all state history records.
+        /// </summary>
+        /// <returns>An enumerator going over the state history records.</returns>
+        /// <remarks>
+        /// Enumerate all state history records.
+        /// </remarks>
+        /// <seealso cref="GetEnumerator"/>
         public new IEnumerator<Record> GetEnumerator()
         {
             return new Enumerator(this);
         }
 
+        /// <summary>
+        /// Enumerate all state history records.
+        /// </summary>
+        /// <returns>An enumerator going over the state history records.</returns>
+        /// <remarks>
+        /// Enumerate all state history records.
+        /// </remarks>
         IEnumerator IEnumerable.GetEnumerator()
         {
             return GetEnumerator();
         }
 
+        /// <summary>
+        /// Returns an entry in the state history at the given index.
+        /// </summary>
+        /// <param name="index">Index into the array.</param>
+        /// <remarks>
+        /// Returns a <see cref="Record"/> entry from the state history at the given index.
+        /// </remarks>
+        /// <exception cref="IndexOutOfRangeException"><paramref name="index"/> is less than 0 or greater than <see cref="InputStateHistory.Count"/>.</exception>
         public new unsafe Record this[int index]
         {
             get
@@ -838,6 +1354,9 @@ public void Dispose()
             }
         }
 
+        /// <summary>State change record</summary>
+        /// <remarks>Input State change record stored in the <see cref="InputStateHistory{TValue}"/></remarks>
+        /// <seealso cref="InputStateHistory{TValue}"/>
         public new unsafe struct Record : IEquatable<Record>
         {
             private readonly InputStateHistory<TValue> m_Owner;
@@ -847,10 +1366,31 @@ public void Dispose()
             internal RecordHeader* header => m_Owner.GetRecord(recordIndex);
             internal int recordIndex => m_IndexPlusOne - 1;
 
+            /// <summary>
+            /// Identifies if the record is valid.
+            /// </summary>
+            /// <value>True if the record is a valid entry. False if invalid.</value>
+            /// <remarks>
+            /// When the history is cleared with <see cref="InputStateHistory.Clear"/> the entries become invalid.
+            /// </remarks>
             public bool valid => m_Owner != default && m_IndexPlusOne != default && header->version == m_Version;
 
+            /// <summary>
+            /// Identifies the owning container for the record.
+            /// </summary>
+            /// <value>The owning <see cref="InputStateHistory"/> container for the record.</value>
+            /// <remarks>
+            /// Identifies the owning <see cref="InputStateHistory"/> container for the record.
+            /// </remarks>
             public InputStateHistory<TValue> owner => m_Owner;
 
+            /// <summary>
+            /// The index of the input state record in the owning container.
+            /// </summary>
+            /// <value>
+            /// The index of the input state record in the owning container.
+            /// </value>
+            /// <exception cref="InvalidOperationException">When the record is no longer value.</exception>
             public int index
             {
                 get
@@ -860,6 +1400,14 @@ public int index
                 }
             }
 
+            /// <summary>
+            /// The time stamp of the input state record.
+            /// </summary>
+            /// <value>
+            /// The time stamp of the input state record in the owning container.
+            /// <see cref="IInputRuntime.currentTime"/>
+            /// </value>
+            /// <exception cref="InvalidOperationException">When the record is no longer value.</exception>
             public double time
             {
                 get
@@ -869,6 +1417,13 @@ public double time
                 }
             }
 
+            /// <summary>
+            /// The control associated with the input state record.
+            /// </summary>
+            /// <value>
+            /// The control associated with the input state record.
+            /// </value>
+            /// <exception cref="InvalidOperationException">When the record is no longer value.</exception>
             public InputControl<TValue> control
             {
                 get
@@ -881,6 +1436,13 @@ public InputControl<TValue> control
                 }
             }
 
+            /// <summary>
+            /// The next input state record in the owning container.
+            /// </summary>
+            /// <value>
+            /// The next input state record in the owning <see cref="InputStateHistory{TValue}"/>container.
+            /// </value>
+            /// <exception cref="InvalidOperationException">When the record is no longer value.</exception>
             public Record next
             {
                 get
@@ -894,6 +1456,13 @@ public Record next
                 }
             }
 
+            /// <summary>
+            /// The previous input state record in the owning container.
+            /// </summary>
+            /// <value>
+            /// The previous input state record in the owning <see cref="InputStateHistory{TValue}"/>container.
+            /// </value>
+            /// <exception cref="InvalidOperationException">When the record is no longer value.</exception>
             public Record previous
             {
                 get
@@ -921,12 +1490,24 @@ internal Record(InputStateHistory<TValue> owner, int index)
                 m_Version = default;
             }
 
+            /// <summary>
+            /// Returns value from the control in the Record.
+            /// </summary>
+            /// <returns>Returns value from the Record.</returns>
+            /// <exception cref="InvalidOperationException">When the record is no longer value or the specified type is not present.</exception>
             public TValue ReadValue()
             {
                 CheckValid();
                 return m_Owner.ReadValue<TValue>(header);
             }
 
+            /// <summary>
+            /// Read the state memory for the record.
+            /// </summary>
+            /// <returns>The state memory for the record.</returns>
+            /// <remarks>
+            /// Read the state memory for the record.
+            /// </remarks>
             public void* GetUnsafeMemoryPtr()
             {
                 CheckValid();
@@ -940,6 +1521,14 @@ public TValue ReadValue()
                 return header->statePtrWithControlIndex;
             }
 
+            /// <summary>
+            /// Read the extra memory for the record.
+            /// </summary>
+            /// <returns>The extra memory for the record.</returns>
+            /// <remarks>
+            /// Additional date can be stored in a record in the extra memory section.
+            /// </remarks>
+            /// <seealso cref="InputStateHistory.extraMemoryPerRecord"/>
             public void* GetUnsafeExtraMemoryPtr()
             {
                 CheckValid();
@@ -953,6 +1542,13 @@ public TValue ReadValue()
                 return (byte*)header + m_Owner.bytesPerRecord - m_Owner.extraMemoryPerRecord;
             }
 
+            /// <summary>Copy data from one record to another.</summary>
+            /// <param name="record">Source Record to copy from.</param>
+            /// <remarks>
+            /// Copy data from one record to another.
+            /// </remarks>
+            /// <exception cref="ArgumentException">When the source record history is not valid.</exception>
+            /// <exception cref="InvalidOperationException">When the control is not tracked by the owning <see cref="InputStateHistory{TValue}"/> container.</exception>
             public void CopyFrom(Record record)
             {
                 CheckValid();
@@ -971,16 +1567,27 @@ private void CheckValid()
                     throw new InvalidOperationException("Record is no longer valid");
             }
 
+            /// <summary>Compare two records.</summary>
+            /// <remarks>Compare two records.</remarks>
+            /// <param name="other">The record to compare with.</param>
+            /// <returns>True if the records are the same, False if they differ.</returns>
             public bool Equals(Record other)
             {
                 return ReferenceEquals(m_Owner, other.m_Owner) && m_IndexPlusOne == other.m_IndexPlusOne && m_Version == other.m_Version;
             }
 
+            /// <summary>Compare two records.</summary>
+            /// <remarks>Compare two records.</remarks>
+            /// <param name="obj">The record to compare with.</param>
+            /// <returns>True if the records are the same, False if they differ.</returns>
             public override bool Equals(object obj)
             {
                 return obj is Record other && Equals(other);
             }
 
+            /// <summary>Return the hash code of the record.</summary>
+            /// <remarks>Return the hash code of the record.</remarks>
+            /// <returns>The hash code of the record.</returns>
             public override int GetHashCode()
             {
                 unchecked
@@ -992,6 +1599,9 @@ public override int GetHashCode()
                 }
             }
 
+            /// <summary>Return the string representation of the record.</summary>
+            /// <remarks>Includes the control, value and time of the record (or &lt;Invalid&gt; if not valid).</remarks>
+            /// <returns>The string representation of the record.</returns>
             public override string ToString()
             {
                 if (!valid)
diff --git a/Packages/com.unity.inputsystem/Tests/TestFixture/AssemblyInfo.cs b/Packages/com.unity.inputsystem/Tests/TestFixture/AssemblyInfo.cs
index f8e6d4dd32..3e9571c222 100644
--- a/Packages/com.unity.inputsystem/Tests/TestFixture/AssemblyInfo.cs
+++ b/Packages/com.unity.inputsystem/Tests/TestFixture/AssemblyInfo.cs
@@ -4,7 +4,7 @@
 // Keep this in sync with "Packages/com.unity.inputsystem/package.json".
 // NOTE: Unfortunately, System.Version doesn't use semantic versioning so we can't include
 //       "-preview" suffixes here.
-[assembly: AssemblyVersion("1.11.3")]
+[assembly: AssemblyVersion("1.12.0")]
 [assembly: InternalsVisibleTo("Unity.InputSystem.Tests.Editor")]
 [assembly: InternalsVisibleTo("Unity.InputSystem.Tests")]
 [assembly: InternalsVisibleTo("Unity.InputSystem.IntegrationTests")]
diff --git a/Packages/com.unity.inputsystem/package.json b/Packages/com.unity.inputsystem/package.json
index 30751e47ba..988027fcde 100755
--- a/Packages/com.unity.inputsystem/package.json
+++ b/Packages/com.unity.inputsystem/package.json
@@ -1,7 +1,7 @@
 {
 	"name": "com.unity.inputsystem",
 	"displayName": "Input System",
-	"version": "1.11.3",
+	"version": "1.12.0",
 	"unity": "2019.4",
 	"description": "A new input system which can be used as a more extensible and customizable alternative to Unity's classic input system in UnityEngine.Input.",
 	"keywords": [